diff --git a/buffet/data_encoding.cc b/buffet/data_encoding.cc
index 0e040ab..1c0013a 100644
--- a/buffet/data_encoding.cc
+++ b/buffet/data_encoding.cc
@@ -72,9 +72,8 @@
   return result;
 }
 
-std::string WebParamsEncode(
-    std::vector<std::pair<std::string, std::string>> const& params,
-    bool encodeSpaceAsPlus) {
+std::string WebParamsEncode(WebParamList const& params,
+                            bool encodeSpaceAsPlus) {
   std::vector<std::string> pairs;
   pairs.reserve(params.size());
   for (auto const& p : params) {
@@ -86,9 +85,8 @@
   return string_utils::Join('&', pairs);
 }
 
-std::vector<std::pair<std::string, std::string>> WebParamsDecode(
-    std::string const& data) {
-  std::vector<std::pair<std::string, std::string>> result;
+WebParamList WebParamsDecode(std::string const& data) {
+  WebParamList result;
   std::vector<std::string> params = string_utils::Split(data, '&');
   for (auto p : params) {
     auto pair = string_utils::SplitAtFirst(p, '=');
diff --git a/buffet/data_encoding.h b/buffet/data_encoding.h
index 6c46e45..7a4eda0 100644
--- a/buffet/data_encoding.h
+++ b/buffet/data_encoding.h
@@ -11,6 +11,8 @@
 namespace chromeos {
 namespace data_encoding {
 
+typedef std::vector<std::pair<std::string, std::string>> WebParamList;
+
 // Encode/escape string to be used in the query portion of a URL.
 // If |encodeSpaceAsPlus| is set to true, spaces are encoded as '+' instead
 // of "%20"
@@ -26,20 +28,16 @@
 
 // Converts a list of key-value pairs into a string compatible with
 // 'application/x-www-form-urlencoded' content encoding.
-std::string WebParamsEncode(
-    std::vector<std::pair<std::string, std::string>> const& params,
-    bool encodeSpaceAsPlus);
+std::string WebParamsEncode(WebParamList const& params, bool encodeSpaceAsPlus);
 
-inline std::string WebParamsEncode(
-    std::vector<std::pair<std::string, std::string>> const& params) {
+inline std::string WebParamsEncode(WebParamList const& params) {
   return WebParamsEncode(params, true);
 }
 
 // Parses a string of '&'-delimited key-value pairs (separated by '=') and
 // encoded in a way compatible with 'application/x-www-form-urlencoded'
 // content encoding.
-std::vector<std::pair<std::string, std::string>> WebParamsDecode(
-    std::string const& data);
+WebParamList WebParamsDecode(std::string const& data);
 
 } // namespace data_encoding
 } // namespace chromeos
diff --git a/buffet/http_request.cc b/buffet/http_request.cc
index 5d82473..3e9ec71 100644
--- a/buffet/http_request.cc
+++ b/buffet/http_request.cc
@@ -160,6 +160,11 @@
     transport_->AddHeader(header, value);
 }
 
+void Request::AddHeaders(HeaderList const& headers) {
+  for (auto&& pair : headers)
+    AddHeader(pair.first.c_str(), pair.second.c_str());
+}
+
 bool Request::AddRequestBody(void const* data, size_t size) {
   return transport_ && transport_->AddRequestBody(data, size);
 }
diff --git a/buffet/http_request.h b/buffet/http_request.h
index acdab89..fcdc9bd 100644
--- a/buffet/http_request.h
+++ b/buffet/http_request.h
@@ -227,6 +227,7 @@
 
   // Adds additional HTTP request header
   void AddHeader(char const* header, char const* value);
+  void AddHeaders(HeaderList const& headers);
 
   // Removes HTTP request header
   void RemoveHeader(char const* header);
diff --git a/buffet/http_transport_curl.cc b/buffet/http_transport_curl.cc
index 47090e9..6cb9c16 100644
--- a/buffet/http_transport_curl.cc
+++ b/buffet/http_transport_curl.cc
@@ -16,6 +16,42 @@
 using namespace chromeos;
 using namespace chromeos::http::curl;
 
+#define VERBOSE_CURL 0  // Set to 1 to log advanced debugging info for CURL
+
+#if VERBOSE_CURL
+static int curl_trace(CURL *handle, curl_infotype type,
+                      char *data, size_t size, void *userp) {
+  std::string msg(data, size);
+
+  switch (type) {
+  case CURLINFO_TEXT:
+    LOG(INFO) << "== Info: " << msg;
+    break;
+  case CURLINFO_HEADER_OUT:
+    LOG(INFO) << "=> Send headers:\n" << msg;
+    break;
+  case CURLINFO_DATA_OUT:
+    LOG(INFO) << "=> Send data:\n" << msg;
+    break;
+  case CURLINFO_SSL_DATA_OUT:
+    LOG(INFO) << "=> Send SSL data" << msg;
+    break;
+  case CURLINFO_HEADER_IN:
+    LOG(INFO) << "<= Recv header: " << msg;
+    break;
+  case CURLINFO_DATA_IN:
+    LOG(INFO) << "<= Recv data:\n" << msg;
+    break;
+  case CURLINFO_SSL_DATA_IN:
+    LOG(INFO) << "<= Recv SSL data" << msg;
+    break;
+  default:
+    break;
+  }
+  return 0;
+}
+#endif
+
 Transport::Transport(std::string const& url, char const* method) :
     request_url_(url),
     method_(method ? method : request_type::kGet) {
@@ -42,8 +78,8 @@
   return accept_;
 }
 
-std::vector<std::pair<std::string, std::string>> Transport::GetHeaders() const {
-  auto headers = MapToVector(headers_);
+chromeos::http::HeaderList Transport::GetHeaders() const {
+  chromeos::http::HeaderList headers = MapToVector(headers_);
   std::vector<std::string> ranges;
   if (method_ != request_type::kHead) {
     ranges.reserve(ranges_.size());
@@ -104,8 +140,14 @@
     return false;
   }
 
+  LOG(INFO) << "Sending a " << method_ << " request to " << request_url_;
   curl_easy_setopt(curl_handle_, CURLOPT_URL, request_url_.c_str());
 
+#if VERBOSE_CURL
+  curl_easy_setopt(curl_handle_, CURLOPT_DEBUGFUNCTION, curl_trace);
+  curl_easy_setopt(curl_handle_, CURLOPT_VERBOSE, 1L);
+#endif
+
   if (!user_agent_.empty()) {
     curl_easy_setopt(curl_handle_,
                      CURLOPT_USERAGENT, user_agent_.c_str());
@@ -121,7 +163,15 @@
     curl_easy_setopt(curl_handle_, CURLOPT_HTTPGET, 1L);
   } else if (method_ == request_type::kHead) {
     curl_easy_setopt(curl_handle_, CURLOPT_NOBODY, 1L);
-  } else if (method_ == request_type::kPost) {
+  } else if (method_ == request_type::kPut) {
+    curl_easy_setopt(curl_handle_, CURLOPT_UPLOAD, 1L);
+    curl_easy_setopt(curl_handle_, CURLOPT_INFILESIZE_LARGE,
+                     curl_off_t(request_data_.size()));
+    curl_easy_setopt(curl_handle_,
+                     CURLOPT_READFUNCTION, &Transport::read_callback);
+    curl_easy_setopt(curl_handle_, CURLOPT_READDATA, this);
+  } else {
+    // POST and custom request methods
     curl_easy_setopt(curl_handle_, CURLOPT_POST, 1L);
     curl_easy_setopt(curl_handle_, CURLOPT_POSTFIELDS, nullptr);
     if (!request_data_.empty()) {
@@ -131,22 +181,15 @@
     }
     curl_easy_setopt(curl_handle_, CURLOPT_POSTFIELDSIZE_LARGE,
                      curl_off_t(request_data_.size()));
-  } else if (method_ == request_type::kPut) {
-    curl_easy_setopt(curl_handle_, CURLOPT_UPLOAD, 1L);
-    curl_easy_setopt(curl_handle_, CURLOPT_INFILESIZE_LARGE,
-                     curl_off_t(request_data_.size()));
-    curl_easy_setopt(curl_handle_,
-                     CURLOPT_READFUNCTION, &Transport::read_callback);
-    curl_easy_setopt(curl_handle_, CURLOPT_READDATA, this);
-  } else {
-    curl_easy_setopt(curl_handle_, CURLOPT_CUSTOMREQUEST, method_.c_str());
-    if (!request_data_.empty()) {
-      curl_easy_setopt(curl_handle_,
-                       CURLOPT_READFUNCTION, &Transport::read_callback);
-      curl_easy_setopt(curl_handle_, CURLOPT_READDATA, this);
-    }
+    if (method_ != request_type::kPost)
+      curl_easy_setopt(curl_handle_, CURLOPT_CUSTOMREQUEST, method_.c_str());
   }
 
+  VLOG_IF(2, !request_data_.empty()) << "Request data ("
+      << request_data_.size() << "): "
+      << std::string(reinterpret_cast<char const*>(request_data_.data()),
+      request_data_.size());
+
   // Setup HTTP response data.
   if (method_ != request_type::kHead) {
     curl_easy_setopt(curl_handle_,
@@ -165,6 +208,7 @@
   if (!headers.empty()) {
     for (auto pair : headers) {
       std::string header = string_utils::Join(": ", pair.first, pair.second);
+      VLOG(2) << "Request header: " << header;
       header_list = curl_slist_append(header_list, header.c_str());
     }
     curl_easy_setopt(curl_handle_, CURLOPT_HTTPHEADER, header_list);
@@ -186,6 +230,13 @@
     stage_ = Stage::response_received;
   }
   curl_slist_free_all(header_list);
+  if (stage_ == Stage::response_received) {
+    LOG(INFO) << "Response: " << GetResponseStatusCode() << " ("
+              << GetResponseStatusText() << ")";
+    VLOG(2) << "Response data (" << response_data_.size() << "): "
+        << std::string(reinterpret_cast<char const*>(response_data_.data()),
+                       response_data_.size());
+  }
   return (ret == CURLE_OK);
 }
 
@@ -202,6 +253,9 @@
   return p != headers_.end() ? p->second : std::string();
 }
 
+std::vector<unsigned char> const& Transport::GetResponseData() const {
+  return response_data_;
+}
 
 void Transport::Close() {
   if (curl_handle_) {
@@ -241,6 +295,13 @@
   Transport* me = reinterpret_cast<Transport*>(data);
   size_t hdr_len = size * num;
   std::string header(ptr, int(hdr_len));
+  // Remove newlines at the end of header line.
+  while (!header.empty() && (header.back() == '\r' || header.back() == '\n')) {
+    header.pop_back();
+  }
+
+  VLOG(2) << "Response header: " << header;
+
   if (!me->status_text_set_) {
     // First header - response code as "HTTP/1.1 200 OK".
     // Need to extract the OK part
diff --git a/buffet/http_transport_curl.h b/buffet/http_transport_curl.h
index ab2ea2b..5ef533e 100644
--- a/buffet/http_transport_curl.h
+++ b/buffet/http_transport_curl.h
@@ -89,9 +89,7 @@
   virtual std::string GetResponseHeader(char const* header_name) const override;
 
   // Implementation of Response::GetData.
-  virtual std::vector<unsigned char> const& GetResponseData() const override {
-    return response_data_;
-  }
+  virtual std::vector<unsigned char> const& GetResponseData() const override;
 
   // Implementation of Response::GetErrorMessage.
   virtual std::string GetErrorMessage() const override { return error_; }
@@ -100,7 +98,7 @@
   virtual void Close() override;
 
  private:
-  std::vector<std::pair<std::string, std::string>> GetHeaders() const;
+   HeaderList GetHeaders() const;
 
   // Write data callback. Used by CURL when receiving response data.
   static size_t write_callback(char* ptr, size_t size, size_t num, void* data);
diff --git a/buffet/http_utils.cc b/buffet/http_utils.cc
index a921386..9db6b1c 100644
--- a/buffet/http_utils.cc
+++ b/buffet/http_utils.cc
@@ -10,78 +10,128 @@
 #include <base/json/json_reader.h>
 #include <base/json/json_writer.h>
 
-#include "mime_utils.h"
+#include "buffet/mime_utils.h"
+#include "buffet/data_encoding.h"
 
 namespace chromeos {
 namespace http {
 
-std::unique_ptr<Response> Get(char const* url) {
+std::unique_ptr<Response> Get(std::string const& url) {
   Request request(url);
   return request.GetResponse();
 }
 
-std::string GetAsString(char const* url) {
+std::string GetAsString(std::string const& url) {
   auto resp = Get(url);
   return resp ? resp->GetDataAsString() : std::string();
 }
 
-std::unique_ptr<Response> Head(char const* url) {
+std::unique_ptr<Response> Head(std::string const& url) {
   Request request(url, request_type::kHead);
   return request.GetResponse();
 }
 
-std::unique_ptr<Response> PostText(char const* url,
+std::unique_ptr<Response> PostText(std::string const& url,
                                    char const* data,
-                                   char const* mime_type) {
+                                   char const* mime_type,
+                                   HeaderList const& headers) {
   if (mime_type == nullptr) {
     mime_type = chromeos::mime::application::kWwwFormUrlEncoded;
   }
 
-  return PostBinary(url, data, strlen(data), mime_type);
+  return PostBinary(url, data, strlen(data), mime_type, headers);
 }
 
-std::unique_ptr<Response> PostBinary(char const* url, void const* data,
-                                     size_t data_size, char const* mime_type) {
-  if (mime_type == nullptr) {
-    mime_type = chromeos::mime::application::kOctet_stream;
+std::unique_ptr<Response> SendRequest(char const* method,
+                                      std::string const& url,
+                                      void const* data,
+                                      size_t data_size,
+                                      char const* mime_type,
+                                      HeaderList const& headers) {
+  Request request(url, method);
+  request.AddHeaders(headers);
+  if (data_size > 0) {
+    if (mime_type == nullptr) {
+      mime_type = chromeos::mime::application::kOctet_stream;
+    }
+    request.SetContentType(mime_type);
+    request.AddRequestBody(data, data_size);
   }
-
-  Request request(url, request_type::kPost);
-  request.SetContentType(mime_type);
-  request.AddRequestBody(data, data_size);
   return request.GetResponse();
 }
 
-std::unique_ptr<Response> PostJson(char const* url, base::Value const* json) {
-  std::string data;
-  base::JSONWriter::Write(json, &data);
-  return PostBinary(url, data.c_str(), data.size(), mime::application::kJson);
+std::unique_ptr<Response> PostBinary(std::string const& url, void const* data,
+                                     size_t data_size, char const* mime_type,
+                                     HeaderList const& headers) {
+  return SendRequest(request_type::kPost, url,
+                     data, data_size, mime_type, headers);
 }
 
-std::unique_ptr<base::Value> ParseJsonResponse(Response const* response,
-                                               std::string* error_message) {
-  std::unique_ptr<base::Value> value;
+std::unique_ptr<Response> PostFormData(std::string const& url,
+                                       FormFieldList const& data,
+                                       HeaderList const& headers) {
+  std::string encoded_data = chromeos::data_encoding::WebParamsEncode(data);
+  return PostBinary(url, encoded_data.c_str(), encoded_data.size(),
+                    chromeos::mime::application::kWwwFormUrlEncoded, headers);
+}
+
+
+std::unique_ptr<Response> PostJson(std::string const& url,
+                                   base::Value const* json,
+                                   HeaderList const& headers) {
+  std::string data;
+  if (json)
+    base::JSONWriter::Write(json, &data);
+  return PostBinary(url, data.c_str(), data.size(),
+                    mime::application::kJson, headers);
+}
+
+std::unique_ptr<Response> PatchJson(std::string const& url,
+                                    base::Value const* json,
+                                    HeaderList const& headers) {
+  std::string data;
+  if (json)
+    base::JSONWriter::Write(json, &data);
+  return SendRequest(request_type::kPatch, url, data.c_str(), data.size(),
+                     mime::application::kJson, headers);
+}
+
+std::unique_ptr<base::DictionaryValue> ParseJsonResponse(
+    Response const* response, int* status_code, std::string* error_message) {
+  std::unique_ptr<base::DictionaryValue> dict;
   if (response) {
-    if (response->IsSuccessful()) {
-      // Make sure we have a correct content type. Do not try to parse
-      // binary files, or HTML output. Limit to application/json and text/plain.
-      auto content_type = mime::RemoveParameters(response->GetContentType());
-      if (content_type == mime::application::kJson ||
-          content_type == mime::text::kPlain) {
-        std::string json = response->GetDataAsString();
-        value.reset(base::JSONReader::ReadAndReturnError(json,
-                                                         base::JSON_PARSE_RFC,
-                                                         nullptr,
-                                                         error_message));
+    if (status_code)
+      *status_code = response->GetStatusCode();
+
+    // Make sure we have a correct content type. Do not try to parse
+    // binary files, or HTML output. Limit to application/json and text/plain.
+    auto content_type = mime::RemoveParameters(response->GetContentType());
+    if (content_type == mime::application::kJson ||
+        content_type == mime::text::kPlain) {
+      std::string json = response->GetDataAsString();
+      auto value = base::JSONReader::ReadAndReturnError(json,
+                                                        base::JSON_PARSE_RFC,
+                                                        nullptr,
+                                                        error_message);
+      if (value) {
+        base::DictionaryValue* dict_value = nullptr;
+        if (value->GetAsDictionary(&dict_value)) {
+          dict.reset(dict_value);
+        } else {
+          delete value;
+          if (error_message) {
+            *error_message = "Reponse is not a valid JSON object";
+          }
+        }
       }
-      else if (error_message) {
-        *error_message = "Unexpected response content type: " + content_type;
-      }
+    }
+    else if (error_message) {
+      *error_message = "Unexpected response content type: " + content_type;
     }
   } else if (error_message) {
     *error_message = "NULL response.";
   }
-  return value;
+  return dict;
 }
 
 } // namespace http
diff --git a/buffet/http_utils.h b/buffet/http_utils.h
index 0fff847..724f118 100644
--- a/buffet/http_utils.h
+++ b/buffet/http_utils.h
@@ -7,11 +7,16 @@
 
 #include "buffet/http_request.h"
 
-namespace base { class Value; }
+namespace base {
+  class Value;
+  class DictionaryValue;
+}  // namespace base
 
 namespace chromeos {
 namespace http {
 
+typedef std::vector<std::pair<std::string, std::string>> FormFieldList;
+
 ////////////////////////////////////////////////////////////////////////////////
 // The following are simple utility helper functions for common HTTP operations
 // that use http::Request object behind the scenes and set it up accordingly.
@@ -20,29 +25,48 @@
 // directly.
 ////////////////////////////////////////////////////////////////////////////////
 
+// Performs a generic HTTP request with binary data. Success status,
+// returned data and additional information (such as returned HTTP headers)
+// can be obtained from the returned Response object.
+// If data MIME type is not specified, "application/octet-stream" is assumed.
+std::unique_ptr<Response> SendRequest(char const* method,
+                                      std::string const& url,
+                                      void const* data,
+                                      size_t data_size,
+                                      char const* mime_type,
+                                      HeaderList const& headers);
+
 // Performs a simple GET request and returns the data as a string.
-std::string GetAsString(char const* url);
+std::string GetAsString(std::string const& url);
 
 // Performs a GET request. Success status, returned data and additional
 // information (such as returned HTTP headers) can be obtained from
 // the returned Response object.
-std::unique_ptr<Response> Get(char const* url);
+std::unique_ptr<Response> Get(std::string const& url);
 
 // Performs a HEAD request. Success status and additional
 // information (such as returned HTTP headers) can be obtained from
 // the returned Response object.
-std::unique_ptr<Response> Head(char const* url);
+std::unique_ptr<Response> Head(std::string const& url);
 
 // Performs a POST request with binary data. Success status, returned data
 // and additional information (such as returned HTTP headers) can be obtained
 // from the returned Response object.
 // If data MIME type is not specified, "application/octet-stream" is assumed
-std::unique_ptr<Response> PostBinary(char const* url,
+std::unique_ptr<Response> PostBinary(std::string const& url,
                                      void const* data,
                                      size_t data_size,
-                                     char const* mime_type);
+                                     char const* mime_type,
+                                     HeaderList const& headers);
 
-inline std::unique_ptr<Response> PostBinary(char const* url,
+inline std::unique_ptr<Response> PostBinary(std::string const& url,
+                                            void const* data,
+                                            size_t data_size,
+                                            char const* mime_type) {
+  return PostBinary(url, data, data_size, mime_type, HeaderList());
+}
+
+inline std::unique_ptr<Response> PostBinary(std::string const& url,
                                             void const* data,
                                             size_t data_size) {
   return PostBinary(url, data, data_size, nullptr);
@@ -52,26 +76,67 @@
 // and additional information (such as returned HTTP headers) can be obtained
 // from the returned Response object.
 // If data MIME type is not specified, "application/x-www-form-urlencoded"
-// is assumed
-std::unique_ptr<Response> PostText(char const* url,
+// is assumed.
+std::unique_ptr<Response> PostText(std::string const& url,
                                    char const* data,
-                                   char const* mime_type);
+                                   char const* mime_type,
+                                   HeaderList const& headers);
 
-inline std::unique_ptr<Response> PostText(char const* url, char const* data) {
+inline std::unique_ptr<Response> PostText(std::string const& url,
+                                          char const* data,
+                                          char const* mime_type) {
+  return PostText(url, data, mime_type, HeaderList());
+}
+
+inline std::unique_ptr<Response> PostText(std::string const& url,
+                                          char const* data) {
   return PostText(url, data, nullptr);
 }
 
+// Performs a POST request with form data. Success status, returned data
+// and additional information (such as returned HTTP headers) can be obtained
+// from the returned Response object. The form data is a list of key/value
+// pairs. The data is posed as "application/x-www-form-urlencoded".
+std::unique_ptr<Response> PostFormData(std::string const& url,
+                                       FormFieldList const& data,
+                                       HeaderList const& headers);
+
+inline std::unique_ptr<Response> PostFormData(std::string const& url,
+                                              FormFieldList const& data) {
+  return PostFormData(url, data, HeaderList());
+}
+
 // Performs a POST request with JSON data. Success status, returned data
 // and additional information (such as returned HTTP headers) can be obtained
 // from the returned Response object. If a JSON response is expected,
 // use ParseJsonResponse() method on the returned Response object.
-std::unique_ptr<Response> PostJson(char const* url, base::Value const* json);
+std::unique_ptr<Response> PostJson(std::string const& url,
+                                   base::Value const* json,
+                                   HeaderList const& headers);
+
+inline std::unique_ptr<Response> PostJson(std::string const& url,
+                                          base::Value const* json) {
+  return PostJson(url, json, HeaderList());
+}
+
+// Performs a PATCH request with JSON data. Success status, returned data
+// and additional information (such as returned HTTP headers) can be obtained
+// from the returned Response object. If a JSON response is expected,
+// use ParseJsonResponse() method on the returned Response object.
+std::unique_ptr<Response> PatchJson(std::string const& url,
+                                    base::Value const* json,
+                                    HeaderList const& headers);
+
+inline std::unique_ptr<Response> PatchJson(std::string const& url,
+                                           base::Value const* json) {
+  return PatchJson(url, json, HeaderList());
+}
 
 // Given an http::Response object, parse the body data into Json object.
 // Returns null if failed. Optional |error_message| can be passed in to
 // get the extended error information as to why the parse failed.
-std::unique_ptr<base::Value> ParseJsonResponse(Response const* response,
-                                               std::string* error_message);
+std::unique_ptr<base::DictionaryValue> ParseJsonResponse(
+    Response const* response, int* status_code, std::string* error_message);
 
 } // namespace http
 } // namespace chromeos
diff --git a/buffet/transport_interface.h b/buffet/transport_interface.h
index fa858c6..0f9363b 100644
--- a/buffet/transport_interface.h
+++ b/buffet/transport_interface.h
@@ -12,6 +12,8 @@
 namespace chromeos {
 namespace http {
 
+typedef std::vector<std::pair<std::string, std::string>> HeaderList;
+
 ///////////////////////////////////////////////////////////////////////////////
 // TransportInterface is an interface to abstract specific implementation
 // of HTTP communication. This interface (and its underlying implementation)