diff --git a/buffet/buffet.gyp b/buffet/buffet.gyp
index f02e494..63fde02 100644
--- a/buffet/buffet.gyp
+++ b/buffet/buffet.gyp
@@ -5,7 +5,6 @@
         'dbus-1',
         'libchrome-<(libbase_ver)',
         'libchromeos-<(libbase_ver)',
-        'libcurl',
         'libmetrics-<(libbase_ver)',
       ],
     },
@@ -29,10 +28,6 @@
         'commands/schema_utils.cc',
         'dbus_constants.cc',
         'device_registration_info.cc',
-        'http_request.cc',
-        'http_connection_curl.cc',
-        'http_transport_curl.cc',
-        'http_utils.cc',
         'manager.cc',
         'storage_impls.cc',
       ],
@@ -71,6 +66,7 @@
           'variables': {
             'deps': [
               'libchrome-test-<(libbase_ver)',
+              'libchromeos-test-<(libbase_ver)',
             ],
           },
           'includes': ['../common-mk/common_test.gypi'],
@@ -86,9 +82,6 @@
             'commands/schema_utils_unittest.cc',
             'commands/unittest_utils.cc',
             'device_registration_info_unittest.cc',
-            'http_connection_fake.cc',
-            'http_transport_fake.cc',
-            'http_utils_unittest.cc',
           ],
         },
       ],
diff --git a/buffet/device_registration_info.cc b/buffet/device_registration_info.cc
index a1cb374..7677a89 100644
--- a/buffet/device_registration_info.cc
+++ b/buffet/device_registration_info.cc
@@ -11,6 +11,8 @@
 #include <base/json/json_writer.h>
 #include <base/values.h>
 #include <chromeos/data_encoding.h>
+#include <chromeos/http_transport_curl.h>
+#include <chromeos/http_utils.h>
 #include <chromeos/mime_utils.h>
 #include <chromeos/string_utils.h>
 #include <chromeos/url_utils.h>
@@ -18,8 +20,6 @@
 #include "buffet/commands/command_definition.h"
 #include "buffet/commands/command_manager.h"
 #include "buffet/device_registration_storage_keys.h"
-#include "buffet/http_transport_curl.h"
-#include "buffet/http_utils.h"
 #include "buffet/storage_impls.h"
 
 const char buffet::kErrorDomainOAuth2[] = "oauth2";
@@ -69,14 +69,14 @@
     const std::string& access_token) {
   std::string authorization =
       chromeos::string_utils::Join(' ', access_token_type, access_token);
-  return {buffet::http::request_header::kAuthorization, authorization};
+  return {chromeos::http::request_header::kAuthorization, authorization};
 }
 
 std::unique_ptr<base::DictionaryValue> ParseOAuthResponse(
-    const buffet::http::Response* response, chromeos::ErrorPtr* error) {
+    const chromeos::http::Response* response, chromeos::ErrorPtr* error) {
   int code = 0;
-  auto resp = buffet::http::ParseJsonResponse(response, &code, error);
-  if (resp && code >= buffet::http::status_code::BadRequest) {
+  auto resp = chromeos::http::ParseJsonResponse(response, &code, error);
+  if (resp && code >= chromeos::http::status_code::BadRequest) {
     if (error) {
       std::string error_code, error_message;
       if (resp->GetString("error", &error_code) &&
@@ -143,7 +143,7 @@
 
 DeviceRegistrationInfo::DeviceRegistrationInfo(
     const std::shared_ptr<CommandManager>& command_manager)
-    : transport_(new http::curl::Transport()),
+    : transport_(new chromeos::http::curl::Transport()),
       // TODO(avakulenko): Figure out security implications of storing
       // this data unencrypted.
       storage_(new FileStorage(base::FilePath(kDeviceInfoFilePath))),
@@ -152,7 +152,7 @@
 
 DeviceRegistrationInfo::DeviceRegistrationInfo(
     const std::shared_ptr<CommandManager>& command_manager,
-    const std::shared_ptr<http::Transport>& transport,
+    const std::shared_ptr<chromeos::http::Transport>& transport,
     const std::shared_ptr<StorageInterface>& storage)
     : transport_(transport),
       storage_(storage),
@@ -269,7 +269,7 @@
     return true;
   }
 
-  auto response = http::PostFormData(GetOAuthURL("token"), {
+  auto response = chromeos::http::PostFormData(GetOAuthURL("token"), {
     {"refresh_token", refresh_token_},
     {"client_id", client_id_},
     {"client_secret", client_secret_},
@@ -307,13 +307,13 @@
   if (!CheckRegistration(error))
     return std::unique_ptr<base::Value>();
 
-  auto response = http::Get(GetDeviceURL(),
-                            {GetAuthorizationHeader()}, transport_, error);
+  auto response = chromeos::http::Get(
+      GetDeviceURL(), {GetAuthorizationHeader()}, transport_, error);
   int status_code = 0;
   std::unique_ptr<base::DictionaryValue> json =
-      http::ParseJsonResponse(response.get(), &status_code, error);
+      chromeos::http::ParseJsonResponse(response.get(), &status_code, error);
   if (json) {
-    if (status_code >= http::status_code::BadRequest) {
+    if (status_code >= chromeos::http::status_code::BadRequest) {
       LOG(WARNING) << "Failed to retrieve the device info. Response code = "
                    << status_code;
       ParseGCDError(json.get(), error);
@@ -377,8 +377,9 @@
   req_json.Set("deviceDraft.commandDefs", commands.release());
 
   std::string url = GetServiceURL("registrationTickets", {{"key", api_key_}});
-  auto resp_json = http::ParseJsonResponse(
-      http::PostJson(url, &req_json, transport_, error).get(), nullptr, error);
+  auto resp_json = chromeos::http::ParseJsonResponse(
+      chromeos::http::PostJson(url, &req_json, transport_, error).get(),
+      nullptr, error);
   if (!resp_json)
     return std::string();
 
@@ -415,9 +416,9 @@
   }
 
   std::string url = GetServiceURL("registrationTickets/" + ticket_id_);
-  std::unique_ptr<http::Response> response;
+  std::unique_ptr<chromeos::http::Response> response;
   if (!user_auth_code.empty()) {
-    response = http::PostFormData(GetOAuthURL("token"), {
+    response = chromeos::http::PostFormData(GetOAuthURL("token"), {
       {"code", user_auth_code},
       {"client_id", client_id_},
       {"client_secret", client_secret_},
@@ -442,11 +443,12 @@
 
     base::DictionaryValue user_info;
     user_info.SetString("userEmail", "me");
-    response = http::PatchJson(
+    response = chromeos::http::PatchJson(
         url, &user_info, {BuildAuthHeader(token_type, user_access_token)},
         transport_, error);
 
-    auto json = http::ParseJsonResponse(response.get(), nullptr, error);
+    auto json = chromeos::http::ParseJsonResponse(response.get(), nullptr,
+                                                  error);
     if (!json)
       return false;
   }
@@ -454,10 +456,11 @@
   std::string auth_code;
   url += "/finalize?key=" + api_key_;
   LOG(INFO) << "Sending request to: " << url;
-  response = http::PostBinary(url, nullptr, 0, transport_, error);
+  response = chromeos::http::PostBinary(url, nullptr, 0, transport_, error);
   if (!response)
     return false;
-  auto json_resp = http::ParseJsonResponse(response.get(), nullptr, error);
+  auto json_resp = chromeos::http::ParseJsonResponse(response.get(), nullptr,
+                                                     error);
   if (!json_resp)
     return false;
   if (!response->IsSuccessful()) {
@@ -473,7 +476,7 @@
   }
 
   // Now get access_token and refresh_token
-  response = http::PostFormData(GetOAuthURL("token"), {
+  response = chromeos::http::PostFormData(GetOAuthURL("token"), {
     {"code", auth_code},
     {"client_id", client_id_},
     {"client_secret", client_secret_},
diff --git a/buffet/device_registration_info.h b/buffet/device_registration_info.h
index 1f7d1fb..dc58eda 100644
--- a/buffet/device_registration_info.h
+++ b/buffet/device_registration_info.h
@@ -14,8 +14,8 @@
 #include <base/time/time.h>
 #include <chromeos/data_encoding.h>
 #include <chromeos/error.h>
+#include <chromeos/http_transport.h>
 
-#include "buffet/http_transport.h"
 #include "buffet/storage_interface.h"
 
 namespace base {
@@ -41,9 +41,10 @@
       const std::shared_ptr<CommandManager>& command_manager);
   // This constructor allows to pass in a custom HTTP transport
   // (mainly for testing).
-  DeviceRegistrationInfo(const std::shared_ptr<CommandManager>& command_manager,
-                         const std::shared_ptr<http::Transport>& transport,
-                         const std::shared_ptr<StorageInterface>& storage);
+  DeviceRegistrationInfo(
+      const std::shared_ptr<CommandManager>& command_manager,
+      const std::shared_ptr<chromeos::http::Transport>& transport,
+      const std::shared_ptr<StorageInterface>& storage);
 
   // Returns the authorization HTTP header that can be used to talk
   // to GCD server for authenticated device communication.
@@ -138,7 +139,7 @@
   std::string display_name_ = "Coffee Pot";
 
   // HTTP transport used for communications.
-  std::shared_ptr<http::Transport> transport_;
+  std::shared_ptr<chromeos::http::Transport> transport_;
   // Serialization interface to save and load device registration info.
   std::shared_ptr<StorageInterface> storage_;
   // Global command manager.
diff --git a/buffet/device_registration_info_unittest.cc b/buffet/device_registration_info_unittest.cc
index 779e29e..27aeaa0 100644
--- a/buffet/device_registration_info_unittest.cc
+++ b/buffet/device_registration_info_unittest.cc
@@ -5,6 +5,8 @@
 #include <base/json/json_reader.h>
 #include <base/values.h>
 #include <chromeos/bind_lambda.h>
+#include <chromeos/http_request.h>
+#include <chromeos/http_transport_fake.h>
 #include <chromeos/mime_utils.h>
 #include <gtest/gtest.h>
 
@@ -12,12 +14,13 @@
 #include "buffet/commands/unittest_utils.h"
 #include "buffet/device_registration_info.h"
 #include "buffet/device_registration_storage_keys.h"
-#include "buffet/http_request.h"
-#include "buffet/http_transport_fake.h"
 #include "buffet/storage_impls.h"
 
-using namespace buffet;          // NOLINT(build/namespaces)
-using namespace buffet::http;    // NOLINT(build/namespaces)
+using chromeos::http::request_header::kAuthorization;
+using chromeos::http::fake::ServerRequest;
+using chromeos::http::fake::ServerResponse;
+
+namespace buffet {
 
 namespace {
 
@@ -69,8 +72,7 @@
   data->SetString(storage_keys::kRobotAccount, test_data::kRobotAccountEmail);
 }
 
-void OAuth2Handler(const fake::ServerRequest& request,
-                  fake::ServerResponse* response) {
+void OAuth2Handler(const ServerRequest& request, ServerResponse* response) {
   base::DictionaryValue json;
   if (request.GetFormField("grant_type") == "refresh_token") {
     // Refresh device access token.
@@ -109,15 +111,15 @@
     FAIL() << "Unexpected grant type";
   }
   json.SetInteger("expires_in", 3600);
-  response->ReplyJson(status_code::Ok, &json);
+  response->ReplyJson(chromeos::http::status_code::Ok, &json);
 }
 
-void DeviceInfoHandler(const fake::ServerRequest& request,
-                       fake::ServerResponse* response) {
+void DeviceInfoHandler(const ServerRequest& request, ServerResponse* response) {
   std::string auth = "Bearer ";
   auth += test_data::kAccessToken;
-  EXPECT_EQ(auth, request.GetHeader(http::request_header::kAuthorization));
-  response->ReplyJson(status_code::Ok, {
+  EXPECT_EQ(auth,
+            request.GetHeader(chromeos::http::request_header::kAuthorization));
+  response->ReplyJson(chromeos::http::status_code::Ok, {
     {"channel.supportedType", "xmpp"},
     {"deviceKind", "vendor"},
     {"id", test_data::kDeviceId},
@@ -125,12 +127,12 @@
   });
 }
 
-void FinalizeTicketHandler(const fake::ServerRequest& request,
-                           fake::ServerResponse* response) {
+void FinalizeTicketHandler(const ServerRequest& request,
+                           ServerResponse* response) {
   EXPECT_EQ(test_data::kApiKey, request.GetFormField("key"));
   EXPECT_TRUE(request.GetData().empty());
 
-  response->ReplyJson(status_code::Ok, {
+  response->ReplyJson(chromeos::http::status_code::Ok, {
     {"id", test_data::kClaimTicketId},
     {"kind", "clouddevices#registrationTicket"},
     {"oauthClientId", test_data::kClientId},
@@ -161,7 +163,7 @@
     InitDefaultStorage(&data_);
     storage_ = std::make_shared<MemStorage>();
     storage_->Save(&data_);
-    transport_ = std::make_shared<fake::Transport>();
+    transport_ = std::make_shared<chromeos::http::fake::Transport>();
     command_manager_ = std::make_shared<CommandManager>();
     dev_reg_ = std::unique_ptr<DeviceRegistrationInfo>(
         new DeviceRegistrationInfo(command_manager_, transport_, storage_));
@@ -169,7 +171,7 @@
 
   base::DictionaryValue data_;
   std::shared_ptr<MemStorage> storage_;
-  std::shared_ptr<fake::Transport> transport_;
+  std::shared_ptr<chromeos::http::fake::Transport> transport_;
   std::unique_ptr<DeviceRegistrationInfo> dev_reg_;
   std::shared_ptr<CommandManager> command_manager_;
 };
@@ -219,7 +221,8 @@
   storage_->Save(&data_);
   EXPECT_TRUE(dev_reg_->Load());
 
-  transport_->AddHandler(dev_reg_->GetOAuthURL("token"), request_type::kPost,
+  transport_->AddHandler(dev_reg_->GetOAuthURL("token"),
+                         chromeos::http::request_type::kPost,
                          base::Bind(OAuth2Handler));
   transport_->ResetRequestCount();
   EXPECT_TRUE(dev_reg_->CheckRegistration(nullptr));
@@ -231,9 +234,11 @@
   storage_->Save(&data_);
   EXPECT_TRUE(dev_reg_->Load());
 
-  transport_->AddHandler(dev_reg_->GetOAuthURL("token"), request_type::kPost,
+  transport_->AddHandler(dev_reg_->GetOAuthURL("token"),
+                         chromeos::http::request_type::kPost,
                          base::Bind(OAuth2Handler));
-  transport_->AddHandler(dev_reg_->GetDeviceURL(), request_type::kGet,
+  transport_->AddHandler(dev_reg_->GetDeviceURL(),
+                         chromeos::http::request_type::kGet,
                          base::Bind(DeviceInfoHandler));
   transport_->ResetRequestCount();
   auto device_info = dev_reg_->GetDeviceInfo(nullptr);
@@ -251,9 +256,11 @@
   storage_->Save(&data_);
   EXPECT_TRUE(dev_reg_->Load());
 
-  transport_->AddHandler(dev_reg_->GetOAuthURL("token"), request_type::kPost,
+  transport_->AddHandler(dev_reg_->GetOAuthURL("token"),
+                         chromeos::http::request_type::kPost,
                          base::Bind(OAuth2Handler));
-  transport_->AddHandler(dev_reg_->GetDeviceURL(), request_type::kGet,
+  transport_->AddHandler(dev_reg_->GetDeviceURL(),
+                         chromeos::http::request_type::kGet,
                          base::Bind(DeviceInfoHandler));
   std::string id = dev_reg_->GetDeviceId(nullptr);
   EXPECT_EQ(test_data::kDeviceId, id);
@@ -262,8 +269,8 @@
 TEST_F(DeviceRegistrationInfoTest, StartRegistration) {
   EXPECT_TRUE(dev_reg_->Load());
 
-  auto create_ticket = [](const fake::ServerRequest& request,
-                          fake::ServerResponse* response) {
+  auto create_ticket = [](const ServerRequest& request,
+                          ServerResponse* response) {
     EXPECT_EQ(test_data::kApiKey, request.GetFormField("key"));
     auto json = request.GetDataAsJson();
     EXPECT_NE(nullptr, json.get());
@@ -294,7 +301,7 @@
     device_draft->SetString("kind", "clouddevices#device");
     json_resp.Set("deviceDraft", device_draft);
 
-    response->ReplyJson(status_code::Ok, &json_resp);
+    response->ReplyJson(chromeos::http::status_code::Ok, &json_resp);
   };
 
   auto json_base = buffet::unittests::CreateDictionaryValue(R"({
@@ -323,7 +330,7 @@
   EXPECT_TRUE(command_manager_->LoadCommands(*json_cmds, "", nullptr));
 
   transport_->AddHandler(dev_reg_->GetServiceURL("registrationTickets"),
-                         request_type::kPost,
+                         chromeos::http::request_type::kPost,
                          base::Bind(create_ticket));
   std::map<std::string, std::string> params;
   std::string json_resp = dev_reg_->StartRegistration(params, nullptr);
@@ -345,10 +352,12 @@
   std::string ticket_url =
       dev_reg_->GetServiceURL("registrationTickets/" +
                              std::string(test_data::kClaimTicketId));
-  transport_->AddHandler(ticket_url + "/finalize", request_type::kPost,
+  transport_->AddHandler(ticket_url + "/finalize",
+                         chromeos::http::request_type::kPost,
                          base::Bind(FinalizeTicketHandler));
 
-  transport_->AddHandler(dev_reg_->GetOAuthURL("token"), request_type::kPost,
+  transport_->AddHandler(dev_reg_->GetOAuthURL("token"),
+                         chromeos::http::request_type::kPost,
                          base::Bind(OAuth2Handler));
 
   storage_->reset_save_count();
@@ -389,26 +398,28 @@
   std::string ticket_url =
       dev_reg_->GetServiceURL("registrationTickets/" +
                              std::string(test_data::kClaimTicketId));
-  transport_->AddHandler(ticket_url + "/finalize", request_type::kPost,
+  transport_->AddHandler(ticket_url + "/finalize",
+                         chromeos::http::request_type::kPost,
                          base::Bind(FinalizeTicketHandler));
 
-  transport_->AddHandler(dev_reg_->GetOAuthURL("token"), request_type::kPost,
+  transport_->AddHandler(dev_reg_->GetOAuthURL("token"),
+                         chromeos::http::request_type::kPost,
                          base::Bind(OAuth2Handler));
 
   // Handle patching in the user email onto the device record.
-  auto email_patch_handler = [](const fake::ServerRequest& request,
-                                fake::ServerResponse* response) {
+  auto email_patch_handler = [](const ServerRequest& request,
+                                ServerResponse* response) {
     std::string auth_header = "Bearer ";
     auth_header += test_data::kUserAccessToken;
     EXPECT_EQ(auth_header,
-              request.GetHeader(http::request_header::kAuthorization));
+        request.GetHeader(chromeos::http::request_header::kAuthorization));
     auto json = request.GetDataAsJson();
     EXPECT_NE(nullptr, json.get());
     std::string value;
     EXPECT_TRUE(json->GetString("userEmail", &value));
     EXPECT_EQ("me", value);
 
-    response->ReplyJson(status_code::Ok, {
+    response->ReplyJson(chromeos::http::status_code::Ok, {
       {"id", test_data::kClaimTicketId},
       {"kind", "clouddevices#registrationTicket"},
       {"oauthClientId", test_data::kClientId},
@@ -418,7 +429,7 @@
       {"deviceDraft.channel.supportedType", "xmpp"},
     });
   };
-  transport_->AddHandler(ticket_url, request_type::kPatch,
+  transport_->AddHandler(ticket_url, chromeos::http::request_type::kPatch,
                          base::Bind(email_patch_handler));
 
   storage_->reset_save_count();
@@ -429,3 +440,5 @@
             storage_->save_count());  // The device info must have been saved.
   EXPECT_EQ(4, transport_->GetRequestCount());
 }
+
+}  // namespace buffet
diff --git a/buffet/http_connection.h b/buffet/http_connection.h
deleted file mode 100644
index 893b992..0000000
--- a/buffet/http_connection.h
+++ /dev/null
@@ -1,87 +0,0 @@
-// Copyright 2014 The Chromium OS Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style license that can be
-// found in the LICENSE file.
-
-#ifndef BUFFET_HTTP_CONNECTION_H_
-#define BUFFET_HTTP_CONNECTION_H_
-
-#include <string>
-#include <vector>
-
-#include <base/basictypes.h>
-#include <chromeos/error.h>
-
-#include "buffet/http_transport.h"
-
-namespace buffet {
-namespace http {
-
-///////////////////////////////////////////////////////////////////////////////
-// Connection class is the base class for HTTP communication session.
-// It abstracts the implementation of underlying transport library (ex libcurl).
-// When the Connection-derived class is constructed, it is pre-set up with
-// basic initialization information necessary to initiate the server request
-// connection (such as the URL, request method, etc - see
-// Transport::CreateConnection() for more details). But most implementations
-// would not probably initiate the physical connection until SendHeaders
-// is called.
-// You normally shouldn't worry about using this class directly.
-// http::Request and http::Response classes use it for communication.
-///////////////////////////////////////////////////////////////////////////////
-class Connection {
- public:
-  explicit Connection(std::shared_ptr<Transport> transport)
-      : transport_(transport) {}
-  virtual ~Connection() = default;
-
-  // Called by http::Request to initiate the connection with the server.
-  // This normally opens the socket and sends the request headers.
-  virtual bool SendHeaders(const HeaderList& headers,
-                           chromeos::ErrorPtr* error) = 0;
-  // If needed, this function can be called to send the request body data.
-  // This function can be called repeatedly until all data is sent.
-  virtual bool WriteRequestData(const void* data, size_t size,
-                                chromeos::ErrorPtr* error) = 0;
-  // This function is called when all the data is sent off and it's time
-  // to receive the response data.
-  virtual bool FinishRequest(chromeos::ErrorPtr* error) = 0;
-
-  // Returns the HTTP status code (e.g. 200 for success).
-  virtual int GetResponseStatusCode() const = 0;
-  // Returns the status text (e.g. for error 403 it could be "NOT AUTHORIZED").
-  virtual std::string GetResponseStatusText() const = 0;
-  // Returns the HTTP protocol version (e.g. "HTTP/1.1").
-  virtual std::string GetProtocolVersion() const = 0;
-  // Returns the value of particular response header, or empty string if the
-  // headers wasn't received.
-  virtual std::string GetResponseHeader(
-      const std::string& header_name) const = 0;
-  // Returns the response data size, if known. For chunked (streaming)
-  // transmission this might not be known until all the data is sent.
-  // In this case GetResponseDataSize() will return 0.
-  virtual uint64_t GetResponseDataSize() const = 0;
-  // This function is called to read a block of response data.
-  // It needs to be called repeatedly until it returns false or |size_read| is
-  // set to 0. |data| is the destination buffer to read the data into.
-  // |buffer_size| is the size of the buffer (amount of data to read).
-  // |read_size| is the amount of data actually read, which could be less than
-  // the size requested or 0 if there is no more data available.
-  virtual bool ReadResponseData(void* data,
-                                size_t buffer_size,
-                                size_t* size_read,
-                                chromeos::ErrorPtr* error) = 0;
-
- protected:
-  // |transport_| is mainly used to keep the object alive as long as the
-  // connection exists. But some implementations of Connection could use
-  // the Transport-derived class for their own needs as well.
-  std::shared_ptr<Transport> transport_;
-
- private:
-  DISALLOW_COPY_AND_ASSIGN(Connection);
-};
-
-}  // namespace http
-}  // namespace buffet
-
-#endif  // BUFFET_HTTP_CONNECTION_H_
diff --git a/buffet/http_connection_curl.cc b/buffet/http_connection_curl.cc
deleted file mode 100644
index 86715ab..0000000
--- a/buffet/http_connection_curl.cc
+++ /dev/null
@@ -1,233 +0,0 @@
-// Copyright 2014 The Chromium OS Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style license that can be
-// found in the LICENSE file.
-
-#include "buffet/http_connection_curl.h"
-
-#include <base/logging.h>
-#include <chromeos/string_utils.h>
-
-#include "buffet/http_request.h"
-#include "buffet/http_transport_curl.h"
-
-namespace buffet {
-namespace http {
-namespace 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:
-    VLOG(3) << "== Info: " << msg;
-    break;
-  case CURLINFO_HEADER_OUT:
-    VLOG(3) << "=> Send headers:\n" << msg;
-    break;
-  case CURLINFO_DATA_OUT:
-    VLOG(3) << "=> Send data:\n" << msg;
-    break;
-  case CURLINFO_SSL_DATA_OUT:
-    VLOG(3) << "=> Send SSL data" << msg;
-    break;
-  case CURLINFO_HEADER_IN:
-    VLOG(3) << "<= Recv header: " << msg;
-    break;
-  case CURLINFO_DATA_IN:
-    VLOG(3) << "<= Recv data:\n" << msg;
-    break;
-  case CURLINFO_SSL_DATA_IN:
-    VLOG(3) << "<= Recv SSL data" << msg;
-    break;
-  default:
-    break;
-  }
-  return 0;
-}
-
-Connection::Connection(CURL* curl_handle, const std::string& method,
-                       std::shared_ptr<http::Transport> transport) :
-    http::Connection(transport), method_(method), curl_handle_(curl_handle) {
-  VLOG(1) << "curl::Connection created: " << method_;
-}
-
-Connection::~Connection() {
-  VLOG(1) << "curl::Connection destroyed";
-}
-
-bool Connection::SendHeaders(const HeaderList& headers,
-                             chromeos::ErrorPtr* error) {
-  headers_.insert(headers.begin(), headers.end());
-  return true;
-}
-
-bool Connection::WriteRequestData(const void* data, size_t size,
-                                  chromeos::ErrorPtr* error) {
-  if (size > 0) {
-    auto data_ptr = reinterpret_cast<const unsigned char*>(data);
-    request_data_.insert(request_data_.end(), data_ptr, data_ptr + size);
-  }
-  return true;
-}
-
-bool Connection::FinishRequest(chromeos::ErrorPtr* error) {
-  if (VLOG_IS_ON(3)) {
-    curl_easy_setopt(curl_handle_, CURLOPT_DEBUGFUNCTION, curl_trace);
-    curl_easy_setopt(curl_handle_, CURLOPT_VERBOSE, 1L);
-  }
-
-  // Set up HTTP request data.
-  if (method_ == request_type::kPut) {
-    curl_easy_setopt(curl_handle_, CURLOPT_INFILESIZE_LARGE,
-                      curl_off_t(request_data_.size()));
-  } else {
-    curl_easy_setopt(curl_handle_, CURLOPT_POSTFIELDSIZE_LARGE,
-                      curl_off_t(request_data_.size()));
-  }
-  if (!request_data_.empty()) {
-    curl_easy_setopt(curl_handle_,
-                     CURLOPT_READFUNCTION, &Connection::read_callback);
-    curl_easy_setopt(curl_handle_, CURLOPT_READDATA, this);
-    VLOG(2) << "Raw request data: "
-        << std::string(reinterpret_cast<const char*>(request_data_.data()),
-                       request_data_.size());
-  }
-
-  curl_slist* header_list = nullptr;
-  if (!headers_.empty()) {
-    for (auto pair : headers_) {
-      std::string header = chromeos::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);
-  }
-
-  headers_.clear();
-
-  // Set up HTTP response data.
-  if (method_ != request_type::kHead) {
-    curl_easy_setopt(curl_handle_,
-                     CURLOPT_WRITEFUNCTION, &Connection::write_callback);
-    curl_easy_setopt(curl_handle_, CURLOPT_WRITEDATA, this);
-  }
-
-  // HTTP response headers
-  curl_easy_setopt(curl_handle_,
-                   CURLOPT_HEADERFUNCTION, &Connection::header_callback);
-  curl_easy_setopt(curl_handle_, CURLOPT_HEADERDATA, this);
-
-  CURLcode ret = curl_easy_perform(curl_handle_);
-  if (header_list)
-    curl_slist_free_all(header_list);
-  if (ret != CURLE_OK) {
-    chromeos::Error::AddTo(error, http::curl::kErrorDomain,
-                           chromeos::string_utils::ToString(ret),
-                           curl_easy_strerror(ret));
-  } else {
-    LOG(INFO) << "Response: " << GetResponseStatusCode() << " ("
-      << GetResponseStatusText() << ")";
-    VLOG(2) << "Response data (" << response_data_.size() << "): "
-        << std::string(reinterpret_cast<const char*>(response_data_.data()),
-                       response_data_.size());
-  }
-  return (ret == CURLE_OK);
-}
-
-int Connection::GetResponseStatusCode() const {
-  long status_code = 0;  // NOLINT(runtime/int) - curl expects a long here.
-  curl_easy_getinfo(curl_handle_, CURLINFO_RESPONSE_CODE, &status_code);
-  return status_code;
-}
-
-std::string Connection::GetResponseStatusText() const {
-  return status_text_;
-}
-
-std::string Connection::GetProtocolVersion() const {
-  return protocol_version_;
-}
-
-std::string Connection::GetResponseHeader(
-    const std::string& header_name) const {
-  auto p = headers_.find(header_name);
-  return p != headers_.end() ? p->second : std::string();
-}
-
-uint64_t Connection::GetResponseDataSize() const {
-  return response_data_.size();
-}
-
-bool Connection::ReadResponseData(void* data,
-                                  size_t buffer_size,
-                                  size_t* size_read,
-                                  chromeos::ErrorPtr* error) {
-  size_t size_to_read = response_data_.size() - response_data_ptr_;
-  if (size_to_read > buffer_size)
-    size_to_read = buffer_size;
-  memcpy(data, response_data_.data() + response_data_ptr_, size_to_read);
-  if (size_read)
-    *size_read = size_to_read;
-  response_data_ptr_ += size_to_read;
-  return true;
-}
-
-size_t Connection::write_callback(char* ptr, size_t size,
-                                  size_t num, void* data) {
-  Connection* me = reinterpret_cast<Connection*>(data);
-  size_t data_len = size * num;
-  me->response_data_.insert(me->response_data_.end(), ptr, ptr + data_len);
-  return data_len;
-}
-
-size_t Connection::read_callback(char* ptr, size_t size,
-                                 size_t num, void* data) {
-  Connection* me = reinterpret_cast<Connection*>(data);
-  size_t data_len = size * num;
-
-  if (me->request_data_ptr_ >= me->request_data_.size())
-    return 0;
-
-  if (me->request_data_ptr_ + data_len > me->request_data_.size())
-    data_len = me->request_data_.size() - me->request_data_ptr_;
-
-  memcpy(ptr, me->request_data_.data() + me->request_data_ptr_, data_len);
-  me->request_data_ptr_ += data_len;
-
-  return data_len;
-}
-
-size_t Connection::header_callback(char* ptr, size_t size,
-                                   size_t num, void* data) {
-  using chromeos::string_utils::SplitAtFirst;
-  Connection* me = reinterpret_cast<Connection*>(data);
-  size_t hdr_len = size * num;
-  std::string header(ptr, 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
-    auto pair = SplitAtFirst(header, ' ');
-    me->protocol_version_ = pair.first;
-    me->status_text_ = SplitAtFirst(pair.second, ' ').second;
-    me->status_text_set_ = true;
-  } else {
-    auto pair = SplitAtFirst(header, ':');
-    if (!pair.second.empty())
-      me->headers_.insert(pair);
-  }
-  return hdr_len;
-}
-
-}  // namespace curl
-}  // namespace http
-}  // namespace buffet
diff --git a/buffet/http_connection_curl.h b/buffet/http_connection_curl.h
deleted file mode 100644
index 67d7eac..0000000
--- a/buffet/http_connection_curl.h
+++ /dev/null
@@ -1,86 +0,0 @@
-// Copyright 2014 The Chromium OS Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style license that can be
-// found in the LICENSE file.
-
-#ifndef BUFFET_HTTP_CONNECTION_CURL_H_
-#define BUFFET_HTTP_CONNECTION_CURL_H_
-
-#include <map>
-#include <string>
-#include <vector>
-
-#include <base/basictypes.h>
-#include <curl/curl.h>
-
-#include "buffet/http_connection.h"
-
-namespace buffet {
-namespace http {
-namespace curl {
-
-// This is a libcurl-based implementation of http::Connection.
-class Connection : public http::Connection {
- public:
-  Connection(CURL* curl_handle, const std::string& method,
-             std::shared_ptr<http::Transport> transport);
-  virtual ~Connection();
-
-  // Overrides from http::Connection.
-  // See http_connection.h for description of these methods.
-  bool SendHeaders(const HeaderList& headers,
-                   chromeos::ErrorPtr* error) override;
-  bool WriteRequestData(const void* data, size_t size,
-                        chromeos::ErrorPtr* error) override;
-  bool FinishRequest(chromeos::ErrorPtr* error) override;
-
-  int GetResponseStatusCode() const override;
-  std::string GetResponseStatusText() const override;
-  std::string GetProtocolVersion() const override;
-  std::string GetResponseHeader(const std::string& header_name) const override;
-  uint64_t GetResponseDataSize() const override;
-  bool ReadResponseData(void* data, size_t buffer_size,
-                        size_t* size_read, chromeos::ErrorPtr* error) override;
-
- protected:
-  // 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);
-  // Read data callback. Used by CURL when sending request body data.
-  static size_t read_callback(char* ptr, size_t size, size_t num, void* data);
-  // Write header data callback. Used by CURL when receiving response headers.
-  static size_t header_callback(char* ptr, size_t size, size_t num, void* data);
-
-  // HTTP request verb, such as "GET", "POST", "PUT", ...
-  std::string method_;
-
-  // Binary data for request body.
-  std::vector<unsigned char> request_data_;
-  // Read pointer for request data. Used when streaming data to the server.
-  size_t request_data_ptr_ = 0;
-
-  // Received response data.
-  std::vector<unsigned char> response_data_;
-  size_t response_data_ptr_ = 0;
-
-  // List of optional request headers provided by the caller.
-  // After request has been sent, contains the received response headers.
-  std::map<std::string, std::string> headers_;
-
-  // HTTP protocol version, such as HTTP/1.1
-  std::string protocol_version_;
-  // Response status text, such as "OK" for 200, or "Forbidden" for 403
-  std::string status_text_;
-  // Flag used when parsing response headers to separate the response status
-  // from the rest of response headers.
-  bool status_text_set_ = false;
-
-  CURL* curl_handle_ = nullptr;
-
- private:
-  DISALLOW_COPY_AND_ASSIGN(Connection);
-};
-
-}  // namespace curl
-}  // namespace http
-}  // namespace buffet
-
-#endif  // BUFFET_HTTP_CONNECTION_CURL_H_
diff --git a/buffet/http_connection_fake.cc b/buffet/http_connection_fake.cc
deleted file mode 100644
index 6cfdde3..0000000
--- a/buffet/http_connection_fake.cc
+++ /dev/null
@@ -1,98 +0,0 @@
-// Copyright 2014 The Chromium OS Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style license that can be
-// found in the LICENSE file.
-
-#include "buffet/http_connection_fake.h"
-
-#include <base/logging.h>
-#include <chromeos/mime_utils.h>
-#include <chromeos/string_utils.h>
-
-#include "buffet/http_request.h"
-
-namespace buffet {
-namespace http {
-namespace fake {
-
-Connection::Connection(const std::string& url, const std::string& method,
-                       std::shared_ptr<http::Transport> transport) :
-    http::Connection(transport), request_(url, method) {
-  VLOG(1) << "fake::Connection created: " << method;
-}
-
-Connection::~Connection() {
-  VLOG(1) << "fake::Connection destroyed";
-}
-
-bool Connection::SendHeaders(const HeaderList& headers,
-                             chromeos::ErrorPtr* error) {
-  request_.AddHeaders(headers);
-  return true;
-}
-
-bool Connection::WriteRequestData(const void* data, size_t size,
-                                  chromeos::ErrorPtr* error) {
-  request_.AddData(data, size);
-  return true;
-}
-
-bool Connection::FinishRequest(chromeos::ErrorPtr* error) {
-  using chromeos::string_utils::ToString;
-  request_.AddHeaders({{request_header::kContentLength,
-                      ToString(request_.GetData().size())}});
-  fake::Transport* transport = static_cast<fake::Transport*>(transport_.get());
-  CHECK(transport) << "Expecting a fake transport";
-  auto handler = transport->GetHandler(request_.GetURL(), request_.GetMethod());
-  if (handler.is_null()) {
-    LOG(ERROR) << "Received unexpected " << request_.GetMethod()
-               << " request at " << request_.GetURL();
-    response_.ReplyText(status_code::NotFound,
-                        "<html><body>Not found</body></html>",
-                        chromeos::mime::text::kHtml);
-  } else {
-    handler.Run(request_, &response_);
-  }
-  return true;
-}
-
-int Connection::GetResponseStatusCode() const {
-  return response_.GetStatusCode();
-}
-
-std::string Connection::GetResponseStatusText() const {
-  return response_.GetStatusText();
-}
-
-std::string Connection::GetProtocolVersion() const {
-  return response_.GetProtocolVersion();
-}
-
-std::string Connection::GetResponseHeader(
-    const std::string& header_name) const {
-  return response_.GetHeader(header_name);
-}
-
-uint64_t Connection::GetResponseDataSize() const {
-  // HEAD requests must not return body.
-  return (request_.GetMethod() != request_type::kHead) ?
-      response_.GetData().size() : 0;
-}
-
-bool Connection::ReadResponseData(void* data,
-                                  size_t buffer_size,
-                                  size_t* size_read,
-                                  chromeos::ErrorPtr* error) {
-  size_t size_to_read = GetResponseDataSize() - response_data_ptr_;
-  if (size_to_read > buffer_size)
-    size_to_read = buffer_size;
-  if (size_to_read > 0)
-    memcpy(data, response_.GetData().data() + response_data_ptr_, size_to_read);
-  if (size_read)
-    *size_read = size_to_read;
-  response_data_ptr_ += size_to_read;
-  return true;
-}
-
-}  // namespace fake
-}  // namespace http
-}  // namespace buffet
diff --git a/buffet/http_connection_fake.h b/buffet/http_connection_fake.h
deleted file mode 100644
index 513228a..0000000
--- a/buffet/http_connection_fake.h
+++ /dev/null
@@ -1,62 +0,0 @@
-// Copyright 2014 The Chromium OS Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style license that can be
-// found in the LICENSE file.
-
-#ifndef BUFFET_HTTP_CONNECTION_FAKE_H_
-#define BUFFET_HTTP_CONNECTION_FAKE_H_
-
-#include <map>
-#include <string>
-#include <vector>
-
-#include <base/basictypes.h>
-
-#include "buffet/http_connection.h"
-#include "buffet/http_transport_fake.h"
-
-namespace buffet {
-namespace http {
-namespace fake {
-
-// This is a fake implementation of http::Connection for unit testing.
-class Connection : public http::Connection {
- public:
-  Connection(const std::string& url, const std::string& method,
-             std::shared_ptr<http::Transport> transport);
-  virtual ~Connection();
-
-  // Overrides from http::Connection.
-  // See http_connection.h for description of these methods.
-  bool SendHeaders(const HeaderList& headers,
-                   chromeos::ErrorPtr* error) override;
-  bool WriteRequestData(const void* data, size_t size,
-                        chromeos::ErrorPtr* error) override;
-  bool FinishRequest(chromeos::ErrorPtr* error) override;
-
-  int GetResponseStatusCode() const override;
-  std::string GetResponseStatusText() const override;
-  std::string GetProtocolVersion() const override;
-  std::string GetResponseHeader(const std::string& header_name) const override;
-  uint64_t GetResponseDataSize() const override;
-  bool ReadResponseData(void* data, size_t buffer_size,
-                        size_t* size_read, chromeos::ErrorPtr* error) override;
-
- private:
-  // Request and response objects passed to the user-provided request handler
-  // callback. The request object contains all the request information.
-  // The response object is the server response that is created by
-  // the handler in response to the request.
-  ServerRequest request_;
-  ServerResponse response_;
-
-  // Internal read data pointer needed for ReadResponseData() implementation.
-  size_t response_data_ptr_ = 0;
-
-  DISALLOW_COPY_AND_ASSIGN(Connection);
-};
-
-}  // namespace fake
-}  // namespace http
-}  // namespace buffet
-
-#endif  // BUFFET_HTTP_CONNECTION_FAKE_H_
diff --git a/buffet/http_request.cc b/buffet/http_request.cc
deleted file mode 100644
index dfeac7f..0000000
--- a/buffet/http_request.cc
+++ /dev/null
@@ -1,301 +0,0 @@
-// Copyright 2014 The Chromium OS Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style license that can be
-// found in the LICENSE file.
-
-#include "buffet/http_request.h"
-
-#include <base/logging.h>
-#include <chromeos/map_utils.h>
-#include <chromeos/mime_utils.h>
-#include <chromeos/string_utils.h>
-
-#include "buffet/http_connection_curl.h"
-#include "buffet/http_transport_curl.h"
-
-namespace buffet {
-namespace http {
-
-// request_type
-const char request_type::kOptions[]               = "OPTIONS";
-const char request_type::kGet[]                   = "GET";
-const char request_type::kHead[]                  = "HEAD";
-const char request_type::kPost[]                  = "POST";
-const char request_type::kPut[]                   = "PUT";
-const char request_type::kPatch[]                 = "PATCH";
-const char request_type::kDelete[]                = "DELETE";
-const char request_type::kTrace[]                 = "TRACE";
-const char request_type::kConnect[]               = "CONNECT";
-const char request_type::kCopy[]                  = "COPY";
-const char request_type::kMove[]                  = "MOVE";
-
-// request_header
-const char request_header::kAccept[]              = "Accept";
-const char request_header::kAcceptCharset[]       = "Accept-Charset";
-const char request_header::kAcceptEncoding[]      = "Accept-Encoding";
-const char request_header::kAcceptLanguage[]      = "Accept-Language";
-const char request_header::kAllow[]               = "Allow";
-const char request_header::kAuthorization[]       = "Authorization";
-const char request_header::kCacheControl[]        = "Cache-Control";
-const char request_header::kConnection[]          = "Connection";
-const char request_header::kContentEncoding[]     = "Content-Encoding";
-const char request_header::kContentLanguage[]     = "Content-Language";
-const char request_header::kContentLength[]       = "Content-Length";
-const char request_header::kContentLocation[]     = "Content-Location";
-const char request_header::kContentMd5[]          = "Content-MD5";
-const char request_header::kContentRange[]        = "Content-Range";
-const char request_header::kContentType[]         = "Content-Type";
-const char request_header::kCookie[]              = "Cookie";
-const char request_header::kDate[]                = "Date";
-const char request_header::kExpect[]              = "Expect";
-const char request_header::kExpires[]             = "Expires";
-const char request_header::kFrom[]                = "From";
-const char request_header::kHost[]                = "Host";
-const char request_header::kIfMatch[]             = "If-Match";
-const char request_header::kIfModifiedSince[]     = "If-Modified-Since";
-const char request_header::kIfNoneMatch[]         = "If-None-Match";
-const char request_header::kIfRange[]             = "If-Range";
-const char request_header::kIfUnmodifiedSince[]   = "If-Unmodified-Since";
-const char request_header::kLastModified[]        = "Last-Modified";
-const char request_header::kMaxForwards[]         = "Max-Forwards";
-const char request_header::kPragma[]              = "Pragma";
-const char request_header::kProxyAuthorization[]  = "Proxy-Authorization";
-const char request_header::kRange[]               = "Range";
-const char request_header::kReferer[]             = "Referer";
-const char request_header::kTE[]                  = "TE";
-const char request_header::kTrailer[]             = "Trailer";
-const char request_header::kTransferEncoding[]    = "Transfer-Encoding";
-const char request_header::kUpgrade[]             = "Upgrade";
-const char request_header::kUserAgent[]           = "User-Agent";
-const char request_header::kVia[]                 = "Via";
-const char request_header::kWarning[]             = "Warning";
-
-// response_header
-const char response_header::kAcceptRanges[]       = "Accept-Ranges";
-const char response_header::kAge[]                = "Age";
-const char response_header::kAllow[]              = "Allow";
-const char response_header::kCacheControl[]       = "Cache-Control";
-const char response_header::kConnection[]         = "Connection";
-const char response_header::kContentEncoding[]    = "Content-Encoding";
-const char response_header::kContentLanguage[]    = "Content-Language";
-const char response_header::kContentLength[]      = "Content-Length";
-const char response_header::kContentLocation[]    = "Content-Location";
-const char response_header::kContentMd5[]         = "Content-MD5";
-const char response_header::kContentRange[]       = "Content-Range";
-const char response_header::kContentType[]        = "Content-Type";
-const char response_header::kDate[]               = "Date";
-const char response_header::kETag[]               = "ETag";
-const char response_header::kExpires[]            = "Expires";
-const char response_header::kLastModified[]       = "Last-Modified";
-const char response_header::kLocation[]           = "Location";
-const char response_header::kPragma[]             = "Pragma";
-const char response_header::kProxyAuthenticate[]  = "Proxy-Authenticate";
-const char response_header::kRetryAfter[]         = "Retry-After";
-const char response_header::kServer[]             = "Server";
-const char response_header::kSetCookie[]          = "Set-Cookie";
-const char response_header::kTrailer[]            = "Trailer";
-const char response_header::kTransferEncoding[]   = "Transfer-Encoding";
-const char response_header::kUpgrade[]            = "Upgrade";
-const char response_header::kVary[]               = "Vary";
-const char response_header::kVia[]                = "Via";
-const char response_header::kWarning[]            = "Warning";
-const char response_header::kWwwAuthenticate[]    = "WWW-Authenticate";
-
-// ***********************************************************
-// ********************** Request Class **********************
-// ***********************************************************
-Request::Request(const std::string& url, const char* method,
-                 std::shared_ptr<Transport> transport) :
-    transport_(transport), request_url_(url), method_(method) {
-  VLOG(1) << "http::Request created";
-  if (!transport_)
-    transport_.reset(new http::curl::Transport());
-}
-
-Request::~Request() {
-  VLOG(1) << "http::Request destroyed";
-}
-
-void Request::AddRange(int64_t bytes) {
-  if (bytes < 0) {
-    ranges_.emplace_back(Request::range_value_omitted, -bytes);
-  } else {
-    ranges_.emplace_back(bytes, Request::range_value_omitted);
-  }
-}
-
-void Request::AddRange(uint64_t from_byte, uint64_t to_byte) {
-  ranges_.emplace_back(from_byte, to_byte);
-}
-
-std::unique_ptr<Response> Request::GetResponse(chromeos::ErrorPtr* error) {
-  if (!SendRequestIfNeeded(error) || !connection_->FinishRequest(error))
-    return std::unique_ptr<Response>();
-  std::unique_ptr<Response> response(new Response(std::move(connection_)));
-  transport_.reset();  // Indicate that the response has been received
-  return response;
-}
-
-void Request::SetAccept(const char* accept_mime_types) {
-  accept_ = accept_mime_types;
-}
-
-std::string Request::GetAccept() const {
-  return accept_;
-}
-
-void Request::SetContentType(const char* contentType) {
-  content_type_ = contentType;
-}
-
-std::string Request::GetContentType() const {
-  return content_type_;
-}
-
-void Request::AddHeader(const char* header, const char* value) {
-  headers_[header] = value;
-}
-
-void Request::AddHeaders(const HeaderList& headers) {
-  headers_.insert(headers.begin(), headers.end());
-}
-
-bool Request::AddRequestBody(const void* data,
-                             size_t size,
-                             chromeos::ErrorPtr* error) {
-  if (!SendRequestIfNeeded(error))
-    return false;
-  return connection_->WriteRequestData(data, size, error);
-}
-
-void Request::SetReferer(const char* referer) {
-  referer_ = referer;
-}
-
-std::string Request::GetReferer() const {
-  return referer_;
-}
-
-void Request::SetUserAgent(const char* user_agent) {
-  user_agent_ = user_agent;
-}
-
-std::string Request::GetUserAgent() const {
-  return user_agent_;
-}
-
-bool Request::SendRequestIfNeeded(chromeos::ErrorPtr* error) {
-  if (transport_) {
-    if (!connection_) {
-      http::HeaderList headers = chromeos::MapToVector(headers_);
-      std::vector<std::string> ranges;
-      if (method_ != request_type::kHead) {
-        ranges.reserve(ranges_.size());
-        for (auto p : ranges_) {
-          if (p.first != range_value_omitted ||
-              p.second != range_value_omitted) {
-            std::string range;
-            if (p.first != range_value_omitted) {
-              range = chromeos::string_utils::ToString(p.first);
-            }
-            range += '-';
-            if (p.second != range_value_omitted) {
-              range += chromeos::string_utils::ToString(p.second);
-            }
-            ranges.push_back(range);
-          }
-        }
-      }
-      if (!ranges.empty())
-        headers.emplace_back(request_header::kRange,
-                             "bytes=" +
-                                 chromeos::string_utils::Join(',', ranges));
-
-      headers.emplace_back(request_header::kAccept, GetAccept());
-      if (method_ != request_type::kGet && method_ != request_type::kHead) {
-        if (!content_type_.empty())
-          headers.emplace_back(request_header::kContentType, content_type_);
-      }
-      connection_ = transport_->CreateConnection(transport_, request_url_,
-                                                 method_, headers,
-                                                 user_agent_, referer_,
-                                                 error);
-    }
-
-    if (connection_)
-      return true;
-  } else {
-    chromeos::Error::AddTo(error, http::curl::kErrorDomain,
-                           "request_already_received",
-                           "HTTP response already received");
-  }
-  return false;
-}
-
-// ************************************************************
-// ********************** Response Class **********************
-// ************************************************************
-Response::Response(std::unique_ptr<Connection> connection)
-    : connection_(std::move(connection)) {
-  VLOG(1) << "http::Response created";
-  // Response object doesn't have streaming interface for response data (yet),
-  // so read the data into a buffer and cache it.
-  if (connection_) {
-    size_t size = static_cast<size_t>(connection_->GetResponseDataSize());
-    response_data_.reserve(size);
-    unsigned char buffer[1024];
-    size_t read = 0;
-    while (connection_->ReadResponseData(buffer, sizeof(buffer),
-                                         &read, nullptr) && read > 0) {
-      response_data_.insert(response_data_.end(), buffer, buffer + read);
-    }
-  }
-}
-
-Response::~Response() {
-  VLOG(1) << "http::Response destroyed";
-}
-
-bool Response::IsSuccessful() const {
-  int code = GetStatusCode();
-  return code >= status_code::Continue && code < status_code::BadRequest;
-}
-
-int Response::GetStatusCode() const {
-  if (!connection_)
-    return -1;
-
-  return connection_->GetResponseStatusCode();
-}
-
-std::string Response::GetStatusText() const {
-  if (!connection_)
-    return std::string();
-
-  return connection_->GetResponseStatusText();
-}
-
-std::string Response::GetContentType() const {
-  return GetHeader(response_header::kContentType);
-}
-
-const std::vector<unsigned char>& Response::GetData() const {
-  return response_data_;
-}
-
-std::string Response::GetDataAsString() const {
-  if (response_data_.empty())
-    return std::string();
-
-  const char* data_buf = reinterpret_cast<const char*>(response_data_.data());
-  return std::string(data_buf, data_buf + response_data_.size());
-}
-
-std::string Response::GetHeader(const char* header_name) const {
-  if (connection_)
-    return connection_->GetResponseHeader(header_name);
-
-  return std::string();
-}
-
-}  // namespace http
-}  // namespace buffet
diff --git a/buffet/http_request.h b/buffet/http_request.h
deleted file mode 100644
index d9e73a4..0000000
--- a/buffet/http_request.h
+++ /dev/null
@@ -1,352 +0,0 @@
-// Copyright 2014 The Chromium OS Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style license that can be
-// found in the LICENSE file.
-
-#ifndef BUFFET_HTTP_REQUEST_H_
-#define BUFFET_HTTP_REQUEST_H_
-
-#include <limits>
-#include <map>
-#include <memory>
-#include <string>
-#include <utility>
-#include <vector>
-
-#include <base/basictypes.h>
-#include <chromeos/error.h>
-
-#include "buffet/http_connection.h"
-#include "buffet/http_transport.h"
-
-namespace buffet {
-namespace http {
-
-// HTTP request verbs
-namespace request_type {
-  extern const char kOptions[];
-  extern const char kGet[];
-  extern const char kHead[];
-  extern const char kPost[];
-  extern const char kPut[];
-  extern const char kPatch[];  // Not a standard HTTP/1.1 request method
-  extern const char kDelete[];
-  extern const char kTrace[];
-  extern const char kConnect[];
-  extern const char kCopy[];   // Not a standard HTTP/1.1 request method
-  extern const char kMove[];   // Not a standard HTTP/1.1 request method
-}  // namespace request_type
-
-// HTTP request header names
-namespace request_header {
-  extern const char kAccept[];
-  extern const char kAcceptCharset[];
-  extern const char kAcceptEncoding[];
-  extern const char kAcceptLanguage[];
-  extern const char kAllow[];
-  extern const char kAuthorization[];
-  extern const char kCacheControl[];
-  extern const char kConnection[];
-  extern const char kContentEncoding[];
-  extern const char kContentLanguage[];
-  extern const char kContentLength[];
-  extern const char kContentLocation[];
-  extern const char kContentMd5[];
-  extern const char kContentRange[];
-  extern const char kContentType[];
-  extern const char kCookie[];
-  extern const char kDate[];
-  extern const char kExpect[];
-  extern const char kExpires[];
-  extern const char kFrom[];
-  extern const char kHost[];
-  extern const char kIfMatch[];
-  extern const char kIfModifiedSince[];
-  extern const char kIfNoneMatch[];
-  extern const char kIfRange[];
-  extern const char kIfUnmodifiedSince[];
-  extern const char kLastModified[];
-  extern const char kMaxForwards[];
-  extern const char kPragma[];
-  extern const char kProxyAuthorization[];
-  extern const char kRange[];
-  extern const char kReferer[];
-  extern const char kTE[];
-  extern const char kTrailer[];
-  extern const char kTransferEncoding[];
-  extern const char kUpgrade[];
-  extern const char kUserAgent[];
-  extern const char kVia[];
-  extern const char kWarning[];
-}  // namespace request_header
-
-// HTTP response header names
-namespace response_header {
-  extern const char kAcceptRanges[];
-  extern const char kAge[];
-  extern const char kAllow[];
-  extern const char kCacheControl[];
-  extern const char kConnection[];
-  extern const char kContentEncoding[];
-  extern const char kContentLanguage[];
-  extern const char kContentLength[];
-  extern const char kContentLocation[];
-  extern const char kContentMd5[];
-  extern const char kContentRange[];
-  extern const char kContentType[];
-  extern const char kDate[];
-  extern const char kETag[];
-  extern const char kExpires[];
-  extern const char kLastModified[];
-  extern const char kLocation[];
-  extern const char kPragma[];
-  extern const char kProxyAuthenticate[];
-  extern const char kRetryAfter[];
-  extern const char kServer[];
-  extern const char kSetCookie[];
-  extern const char kTrailer[];
-  extern const char kTransferEncoding[];
-  extern const char kUpgrade[];
-  extern const char kVary[];
-  extern const char kVia[];
-  extern const char kWarning[];
-  extern const char kWwwAuthenticate[];
-}  // namespace response_header
-
-// HTTP request status (error) codes
-namespace status_code {
-  // OK to continue with request
-  static const int Continue = 100;
-  // Server has switched protocols in upgrade header
-  static const int SwitchProtocols = 101;
-
-  // Request completed
-  static const int Ok = 200;
-  // Object created, reason = new URI
-  static const int Created = 201;
-  // Async completion (TBS)
-  static const int Accepted = 202;
-  // Partial completion
-  static const int Partial = 203;
-  // No info to return
-  static const int NoContent = 204;
-  // Request completed, but clear form
-  static const int ResetContent = 205;
-  // Partial GET fulfilled
-  static const int PartialContent = 206;
-
-  // Server couldn't decide what to return
-  static const int Ambiguous = 300;
-  // Object permanently moved
-  static const int Moved = 301;
-  // Object temporarily moved
-  static const int Redirect = 302;
-  // Redirection w/ new access method
-  static const int RedirectMethod = 303;
-  // If-Modified-Since was not modified
-  static const int NotModified = 304;
-  // Redirection to proxy, location header specifies proxy to use
-  static const int UseProxy = 305;
-  // HTTP/1.1: keep same verb
-  static const int RedirectKeepVerb = 307;
-
-  // Invalid syntax
-  static const int BadRequest = 400;
-  // Access denied
-  static const int Denied = 401;
-  // Payment required
-  static const int PaymentRequired = 402;
-  // Request forbidden
-  static const int Forbidden = 403;
-  // Object not found
-  static const int NotFound = 404;
-  // Method is not allowed
-  static const int BadMethod = 405;
-  // No response acceptable to client found
-  static const int NoneAcceptable = 406;
-  // Proxy authentication required
-  static const int ProxyAuthRequired = 407;
-  // Server timed out waiting for request
-  static const int RequestTimeout = 408;
-  // User should resubmit with more info
-  static const int Conflict = 409;
-  // The resource is no longer available
-  static const int Gone = 410;
-  // The server refused to accept request w/o a length
-  static const int LengthRequired = 411;
-  // Precondition given in request failed
-  static const int PrecondionFailed = 412;
-  // Request entity was too large
-  static const int RequestTooLarge = 413;
-  // Request URI too long
-  static const int UriTooLong = 414;
-  // Unsupported media type
-  static const int UnsupportedMedia = 415;
-  // Retry after doing the appropriate action.
-  static const int RetryWith = 449;
-
-  // Internal server error
-  static const int InternalServerError = 500;
-  // Request not supported
-  static const int NotSupported = 501;
-  // Error response received from gateway
-  static const int BadGateway = 502;
-  // Temporarily overloaded
-  static const int ServiceUnavailable = 503;
-  // Timed out waiting for gateway
-  static const int GatewayTimeout = 504;
-  // HTTP version not supported
-  static const int VersionNotSupported = 505;
-}  // namespace status_code
-
-class Response;  // Just a forward declaration.
-
-///////////////////////////////////////////////////////////////////////////////
-// Request class is the main object used to set up and initiate an HTTP
-// communication session. It is used to specify the HTTP request method,
-// request URL and many optional parameters (such as HTTP headers, user agent,
-// referer URL and so on.
-//
-// Once everything is setup, GetResponse() method is used to send the request
-// and obtain the server response. The returned Response object can be
-// used to inspect the response code, HTTP headers and/or response body.
-///////////////////////////////////////////////////////////////////////////////
-class Request {
- public:
-  // The main constructor. |url| specifies the remote host address/path
-  // to send the request to. |method| is the HTTP request verb and
-  // |transport| is the HTTP transport implementation for server communications.
-  Request(const std::string& url, const char* method,
-          std::shared_ptr<Transport> transport);
-  ~Request();
-
-  // Gets/Sets "Accept:" header value. The default value is "*/*" if not set.
-  void SetAccept(const char* accept_mime_types);
-  std::string GetAccept() const;
-
-  // Gets/Sets "Content-Type:" header value
-  void SetContentType(const char* content_type);
-  std::string GetContentType() const;
-
-  // Adds additional HTTP request header
-  void AddHeader(const char* header, const char* value);
-  void AddHeaders(const HeaderList& headers);
-
-  // Removes HTTP request header
-  void RemoveHeader(const char* header);
-
-  // Adds a request body. This is not to be used with GET method
-  bool AddRequestBody(const void* data, size_t size, chromeos::ErrorPtr* error);
-
-  // Makes a request for a subrange of data. Specifies a partial range with
-  // either from beginning of the data to the specified offset (if |bytes| is
-  // negative) or from the specified offset to the end of data (if |bytes| is
-  // positive).
-  // All individual ranges will be sent as part of "Range:" HTTP request header.
-  void AddRange(int64_t bytes);
-
-  // Makes a request for a subrange of data. Specifies a full range with
-  // start and end bytes from the beginning of the requested data.
-  // All individual ranges will be sent as part of "Range:" HTTP request header.
-  void AddRange(uint64_t from_byte, uint64_t to_byte);
-
-  // Returns the request URL
-  std::string GetRequestURL() const;
-
-  // Gets/Sets a request referer URL (sent as "Referer:" request header).
-  void SetReferer(const char* referer);
-  std::string GetReferer() const;
-
-  // Gets/Sets a user agent string (sent as "User-Agent:" request header).
-  void SetUserAgent(const char* user_agent);
-  std::string GetUserAgent() const;
-
-  // Sends the request to the server and returns the response object.
-  // In case the server couldn't be reached for whatever reason, returns
-  // empty unique_ptr (null). In such a case, the additional error information
-  // can be returned through the optional supplied |error| parameter.
-  std::unique_ptr<Response> GetResponse(chromeos::ErrorPtr* error);
-
- private:
-  // Helper function to create an http::Connection and send off request headers.
-  bool SendRequestIfNeeded(chromeos::ErrorPtr* error);
-
-  // Implementation that provides particular HTTP transport.
-  std::shared_ptr<Transport> transport_;
-
-  // An established connection for adding request body. This connection
-  // is maintained by the request object after the headers have been
-  // sent and before the response is requested.
-  std::unique_ptr<Connection> connection_;
-
-  // Full request URL, such as "http://www.host.com/path/to/object"
-  std::string request_url_;
-  // HTTP request verb, such as "GET", "POST", "PUT", ...
-  std::string method_;
-
-  // Referrer URL, if any. Sent to the server via "Referer: " header.
-  std::string referer_;
-  // User agent string, if any. Sent to the server via "User-Agent: " header.
-  std::string user_agent_;
-  // Content type of the request body data.
-  // Sent to the server via "Content-Type: " header.
-  std::string content_type_;
-  // List of acceptable response data types.
-  // Sent to the server via "Accept: " header.
-  std::string accept_ = "*/*";
-
-  // List of optional request headers provided by the caller.
-  // After request has been sent, contains the received response headers.
-  std::map<std::string, std::string> headers_;
-  // List of optional data ranges to request partial content from the server.
-  // Sent to the server as "Range: " header.
-  std::vector<std::pair<uint64_t, uint64_t>> ranges_;
-
-  // range_value_omitted is used in |ranges_| list to indicate omitted value.
-  // E.g. range (10,range_value_omitted) represents bytes from 10 to the end
-  // of the data stream.
-  const uint64_t range_value_omitted = std::numeric_limits<uint64_t>::max();
-
-  DISALLOW_COPY_AND_ASSIGN(Request);
-};
-
-///////////////////////////////////////////////////////////////////////////////
-// Response class is returned from Request::GetResponse() and is a way
-// to get to response status, error codes, response HTTP headers and response
-// data (body) if available.
-///////////////////////////////////////////////////////////////////////////////
-class Response {
- public:
-  explicit Response(std::unique_ptr<Connection> connection);
-  ~Response();
-
-  // Returns true if server returned a success code (status code below 400).
-  bool IsSuccessful() const;
-
-  // Returns the HTTP status code (e.g. 200 for success)
-  int GetStatusCode() const;
-
-  // Returns the status text (e.g. for error 403 it could be "NOT AUTHORIZED").
-  std::string GetStatusText() const;
-
-  // Returns the content type of the response data.
-  std::string GetContentType() const;
-
-  // Returns response data as a byte array
-  const std::vector<unsigned char>& GetData() const;
-
-  // Returns response data as a string
-  std::string GetDataAsString() const;
-
-  // Returns a value of a given response HTTP header.
-  std::string GetHeader(const char* header_name) const;
-
- private:
-  std::unique_ptr<Connection> connection_;
-  std::vector<unsigned char> response_data_;
-  DISALLOW_COPY_AND_ASSIGN(Response);
-};
-
-}  // namespace http
-}  // namespace buffet
-
-#endif  // BUFFET_HTTP_REQUEST_H_
diff --git a/buffet/http_transport.h b/buffet/http_transport.h
deleted file mode 100644
index 15b0bd6..0000000
--- a/buffet/http_transport.h
+++ /dev/null
@@ -1,53 +0,0 @@
-// Copyright 2014 The Chromium OS Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style license that can be
-// found in the LICENSE file.
-
-#ifndef BUFFET_HTTP_TRANSPORT_H_
-#define BUFFET_HTTP_TRANSPORT_H_
-
-#include <memory>
-#include <string>
-#include <utility>
-#include <vector>
-
-#include <base/basictypes.h>
-#include <chromeos/error.h>
-
-namespace buffet {
-namespace http {
-
-typedef std::vector<std::pair<std::string, std::string>> HeaderList;
-
-class Request;
-class Connection;
-
-///////////////////////////////////////////////////////////////////////////////
-// Transport is a base class for specific implementation of HTTP communication.
-// This class (and its underlying implementation) is used by http::Request and
-// http::Response classes to provide HTTP functionality to the clients.
-///////////////////////////////////////////////////////////////////////////////
-class Transport {
- public:
-  Transport() = default;
-  virtual ~Transport() = default;
-
-  // Creates a connection object and initializes it with the specified data.
-  // |transport| is a shared pointer to this transport object instance,
-  // used to maintain the object alive as long as the connection exists.
-  virtual std::unique_ptr<Connection> CreateConnection(
-      std::shared_ptr<Transport> transport,
-      const std::string& url,
-      const std::string& method,
-      const HeaderList& headers,
-      const std::string& user_agent,
-      const std::string& referer,
-      chromeos::ErrorPtr* error) = 0;
-
- private:
-  DISALLOW_COPY_AND_ASSIGN(Transport);
-};
-
-}  // namespace http
-}  // namespace buffet
-
-#endif  // BUFFET_HTTP_TRANSPORT_H_
diff --git a/buffet/http_transport_curl.cc b/buffet/http_transport_curl.cc
deleted file mode 100644
index d5a30fe..0000000
--- a/buffet/http_transport_curl.cc
+++ /dev/null
@@ -1,81 +0,0 @@
-// Copyright 2014 The Chromium OS Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style license that can be
-// found in the LICENSE file.
-
-#include "buffet/http_transport_curl.h"
-
-#include <base/logging.h>
-
-#include "buffet/http_connection_curl.h"
-#include "buffet/http_request.h"
-
-namespace buffet {
-namespace http {
-namespace curl {
-
-const char kErrorDomain[] = "http_transport";
-
-Transport::Transport() {
-  VLOG(1) << "curl::Transport created";
-}
-
-Transport::~Transport() {
-  VLOG(1) << "curl::Transport destroyed";
-}
-
-std::unique_ptr<http::Connection> Transport::CreateConnection(
-    std::shared_ptr<http::Transport> transport,
-    const std::string& url,
-    const std::string& method,
-    const HeaderList& headers,
-    const std::string& user_agent,
-    const std::string& referer,
-    chromeos::ErrorPtr* error) {
-  CURL* curl_handle = curl_easy_init();
-  if (!curl_handle) {
-    LOG(ERROR) << "Failed to initialize CURL";
-    chromeos::Error::AddTo(error, http::curl::kErrorDomain, "curl_init_failed",
-                           "Failed to initialize CURL");
-    return std::unique_ptr<http::Connection>();
-  }
-
-  LOG(INFO) << "Sending a " << method << " request to " << url;
-  curl_easy_setopt(curl_handle, CURLOPT_URL, url.c_str());
-
-  if (!user_agent.empty()) {
-    curl_easy_setopt(curl_handle,
-                     CURLOPT_USERAGENT, user_agent.c_str());
-  }
-
-  if (!referer.empty()) {
-    curl_easy_setopt(curl_handle,
-                     CURLOPT_REFERER, referer.c_str());
-  }
-
-  // Setup HTTP request method and optional request body.
-  if (method ==  request_type::kGet) {
-    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::kPut) {
-    curl_easy_setopt(curl_handle, CURLOPT_UPLOAD, 1L);
-  } else {
-    // POST and custom request methods
-    curl_easy_setopt(curl_handle, CURLOPT_POST, 1L);
-    curl_easy_setopt(curl_handle, CURLOPT_POSTFIELDS, nullptr);
-    if (method != request_type::kPost)
-      curl_easy_setopt(curl_handle, CURLOPT_CUSTOMREQUEST, method.c_str());
-  }
-
-  std::unique_ptr<http::Connection> connection(
-      new http::curl::Connection(curl_handle, method, transport));
-  CHECK(connection) << "Unable to create Connection object";
-  if (!connection->SendHeaders(headers, error)) {
-    connection.reset();
-  }
-  return connection;
-}
-
-}  // namespace curl
-}  // namespace http
-}  // namespace buffet
diff --git a/buffet/http_transport_curl.h b/buffet/http_transport_curl.h
deleted file mode 100644
index 17b6acc..0000000
--- a/buffet/http_transport_curl.h
+++ /dev/null
@@ -1,47 +0,0 @@
-// Copyright 2014 The Chromium OS Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style license that can be
-// found in the LICENSE file.
-
-#ifndef BUFFET_HTTP_TRANSPORT_CURL_H_
-#define BUFFET_HTTP_TRANSPORT_CURL_H_
-
-#include <string>
-
-#include "buffet/http_transport.h"
-
-namespace buffet {
-namespace http {
-namespace curl {
-
-extern const char kErrorDomain[];
-
-///////////////////////////////////////////////////////////////////////////////
-// An implementation of http::Transport that uses libcurl for
-// HTTP communications. This class (as http::Transport base)
-// is used by http::Request and http::Response classes to provide HTTP
-// functionality to the clients.
-// See http_transport.h for more details.
-///////////////////////////////////////////////////////////////////////////////
-class Transport : public http::Transport {
- public:
-  Transport();
-  virtual ~Transport();
-
-  std::unique_ptr<http::Connection> CreateConnection(
-      std::shared_ptr<http::Transport> transport,
-      const std::string& url,
-      const std::string& method,
-      const HeaderList& headers,
-      const std::string& user_agent,
-      const std::string& referer,
-      chromeos::ErrorPtr* error) override;
-
- private:
-  DISALLOW_COPY_AND_ASSIGN(Transport);
-};
-
-}  // namespace curl
-}  // namespace http
-}  // namespace buffet
-
-#endif  // BUFFET_HTTP_TRANSPORT_CURL_H_
diff --git a/buffet/http_transport_fake.cc b/buffet/http_transport_fake.cc
deleted file mode 100644
index 9aefbe3..0000000
--- a/buffet/http_transport_fake.cc
+++ /dev/null
@@ -1,264 +0,0 @@
-// Copyright 2014 The Chromium OS Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style license that can be
-// found in the LICENSE file.
-
-#include "buffet/http_transport_fake.h"
-
-#include <utility>
-
-#include <base/json/json_reader.h>
-#include <base/json/json_writer.h>
-#include <base/logging.h>
-#include <chromeos/bind_lambda.h>
-#include <chromeos/mime_utils.h>
-#include <chromeos/string_utils.h>
-#include <chromeos/url_utils.h>
-
-#include "buffet/http_connection_fake.h"
-#include "buffet/http_request.h"
-
-namespace buffet {
-
-using http::fake::Transport;
-using http::fake::ServerRequestResponseBase;
-using http::fake::ServerRequest;
-using http::fake::ServerResponse;
-
-Transport::Transport() {
-  VLOG(1) << "fake::Transport created";
-}
-
-Transport::~Transport() {
-  VLOG(1) << "fake::Transport destroyed";
-}
-
-std::unique_ptr<http::Connection> Transport::CreateConnection(
-    std::shared_ptr<http::Transport> transport,
-    const std::string& url,
-    const std::string& method,
-    const HeaderList& headers,
-    const std::string& user_agent,
-    const std::string& referer,
-    chromeos::ErrorPtr* error) {
-  HeaderList headers_copy = headers;
-  if (!user_agent.empty()) {
-    headers_copy.push_back(std::make_pair(http::request_header::kUserAgent,
-                                          user_agent));
-  }
-  if (!referer.empty()) {
-    headers_copy.push_back(std::make_pair(http::request_header::kReferer,
-                                          referer));
-  }
-  std::unique_ptr<http::Connection> connection(
-      new http::fake::Connection(url, method, transport));
-  CHECK(connection) << "Unable to create Connection object";
-  if (!connection->SendHeaders(headers_copy, error))
-    connection.reset();
-  request_count_++;
-  return connection;
-}
-
-static inline std::string GetHandlerMapKey(const std::string& url,
-                                           const std::string& method) {
-  return method + ":" + url;
-}
-
-void Transport::AddHandler(const std::string& url, const std::string& method,
-                           const HandlerCallback& handler) {
-  handlers_.insert(std::make_pair(GetHandlerMapKey(url, method), handler));
-}
-
-void Transport::AddSimpleReplyHandler(const std::string& url,
-                                      const std::string& method,
-                                      int status_code,
-                                      const std::string& reply_text,
-                                      const std::string& mime_type) {
-  auto handler = [status_code, reply_text, mime_type](
-      const ServerRequest& request, ServerResponse* response) {
-    response->ReplyText(status_code, reply_text, mime_type.c_str());
-  };
-  AddHandler(url, method, base::Bind(handler));
-}
-
-Transport::HandlerCallback Transport::GetHandler(
-    const std::string& url, const std::string& method) const {
-  // First try the exact combination of URL/Method
-  auto p = handlers_.find(GetHandlerMapKey(url, method));
-  if (p != handlers_.end())
-    return p->second;
-  // If not found, try URL/*
-  p = handlers_.find(GetHandlerMapKey(url, "*"));
-  if (p != handlers_.end())
-    return p->second;
-  // If still not found, try */method
-  p = handlers_.find(GetHandlerMapKey("*", method));
-  if (p != handlers_.end())
-    return p->second;
-  // Finally, try */*
-  p = handlers_.find(GetHandlerMapKey("*", "*"));
-  return (p != handlers_.end()) ? p->second : HandlerCallback();
-}
-
-void ServerRequestResponseBase::AddData(const void* data, size_t data_size) {
-  auto bytes = reinterpret_cast<const unsigned char*>(data);
-  data_.insert(data_.end(), bytes, bytes + data_size);
-}
-
-std::string ServerRequestResponseBase::GetDataAsString() const {
-  if (data_.empty())
-    return std::string();
-  auto chars = reinterpret_cast<const char*>(data_.data());
-  return std::string(chars, data_.size());
-}
-
-std::unique_ptr<base::DictionaryValue>
-    ServerRequestResponseBase::GetDataAsJson() const {
-  if (chromeos::mime::RemoveParameters(
-          GetHeader(request_header::kContentType)) ==
-      chromeos::mime::application::kJson) {
-    auto value = base::JSONReader::Read(GetDataAsString());
-    if (value) {
-      base::DictionaryValue* dict = nullptr;
-      if (value->GetAsDictionary(&dict)) {
-        return std::unique_ptr<base::DictionaryValue>(dict);
-      } else {
-        delete value;
-      }
-    }
-  }
-  return std::unique_ptr<base::DictionaryValue>();
-}
-
-void ServerRequestResponseBase::AddHeaders(const HeaderList& headers) {
-  for (const auto& pair : headers) {
-    if (pair.second.empty())
-      headers_.erase(pair.first);
-    else
-      headers_.insert(pair);
-  }
-}
-
-std::string ServerRequestResponseBase::GetHeader(
-    const std::string& header_name) const {
-  auto p = headers_.find(header_name);
-  return p != headers_.end() ? p->second : std::string();
-}
-
-ServerRequest::ServerRequest(const std::string& url,
-                             const std::string& method) : method_(method) {
-  auto params = chromeos::url::GetQueryStringParameters(url);
-  url_ = chromeos::url::RemoveQueryString(url, true);
-  form_fields_.insert(params.begin(), params.end());
-}
-
-std::string ServerRequest::GetFormField(const std::string& field_name) const {
-  if (!form_fields_parsed_) {
-    std::string mime_type = chromeos::mime::RemoveParameters(
-        GetHeader(request_header::kContentType));
-    if (mime_type == chromeos::mime::application::kWwwFormUrlEncoded &&
-        !GetData().empty()) {
-      auto fields = chromeos::data_encoding::WebParamsDecode(GetDataAsString());
-      form_fields_.insert(fields.begin(), fields.end());
-    }
-    form_fields_parsed_ = true;
-  }
-  auto p = form_fields_.find(field_name);
-  return p != form_fields_.end() ? p->second : std::string();
-}
-
-void ServerResponse::Reply(int status_code, const void* data, size_t data_size,
-                           const char* mime_type) {
-  data_.clear();
-  status_code_ = status_code;
-  AddData(data, data_size);
-  AddHeaders({
-    {response_header::kContentLength,
-        chromeos::string_utils::ToString(data_size)},
-    {response_header::kContentType, mime_type}
-  });
-}
-
-void ServerResponse::ReplyText(int status_code, const std::string& text,
-                               const char* mime_type) {
-  Reply(status_code, text.data(), text.size(), mime_type);
-}
-
-void ServerResponse::ReplyJson(int status_code, const base::Value* json) {
-  std::string text;
-  base::JSONWriter::WriteWithOptions(json,
-                                     base::JSONWriter::OPTIONS_PRETTY_PRINT,
-                                     &text);
-  std::string mime_type = chromeos::mime::AppendParameter(
-      chromeos::mime::application::kJson,
-      chromeos::mime::parameters::kCharset,
-      "utf-8");
-  ReplyText(status_code, text, mime_type.c_str());
-}
-
-void ServerResponse::ReplyJson(int status_code,
-                               const http::FormFieldList& fields) {
-  base::DictionaryValue json;
-  for (const auto& pair : fields) {
-    json.SetString(pair.first, pair.second);
-  }
-  ReplyJson(status_code, &json);
-}
-
-std::string ServerResponse::GetStatusText() const {
-  static std::vector<std::pair<int, const char*>> status_text_map = {
-    {100, "Continue"},
-    {101, "Switching Protocols"},
-    {102, "Processing"},
-    {200, "OK"},
-    {201, "Created"},
-    {202, "Accepted"},
-    {203, "Non-Authoritative Information"},
-    {204, "No Content"},
-    {205, "Reset Content"},
-    {206, "Partial Content"},
-    {207, "Multi-Status"},
-    {208, "Already Reported"},
-    {226, "IM Used"},
-    {300, "Multiple Choices"},
-    {301, "Moved Permanently"},
-    {302, "Found"},
-    {303, "See Other"},
-    {304, "Not Modified"},
-    {305, "Use Proxy"},
-    {306, "Switch Proxy"},
-    {307, "Temporary Redirect"},
-    {308, "Permanent Redirect"},
-    {400, "Bad Request"},
-    {401, "Unauthorized"},
-    {402, "Payment Required"},
-    {403, "Forbidden"},
-    {404, "Not Found"},
-    {405, "Method Not Allowed"},
-    {406, "Not Acceptable"},
-    {407, "Proxy Authentication Required"},
-    {408, "Request Timeout"},
-    {409, "Conflict"},
-    {410, "Gone"},
-    {411, "Length Required"},
-    {412, "Precondition Failed"},
-    {413, "Request Entity Too Large"},
-    {414, "Request - URI Too Long"},
-    {415, "Unsupported Media Type"},
-    {429, "Too Many Requests"},
-    {431, "Request Header Fields Too Large"},
-    {500, "Internal Server Error"},
-    {501, "Not Implemented"},
-    {502, "Bad Gateway"},
-    {503, "Service Unavailable"},
-    {504, "Gateway Timeout"},
-    {505, "HTTP Version Not Supported"},
-  };
-
-  for (const auto& pair : status_text_map) {
-    if (pair.first == status_code_)
-      return pair.second;
-  }
-  return std::string();
-}
-
-}  // namespace buffet
diff --git a/buffet/http_transport_fake.h b/buffet/http_transport_fake.h
deleted file mode 100644
index 1e58c65..0000000
--- a/buffet/http_transport_fake.h
+++ /dev/null
@@ -1,223 +0,0 @@
-// Copyright 2014 The Chromium OS Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style license that can be
-// found in the LICENSE file.
-
-#ifndef BUFFET_HTTP_TRANSPORT_FAKE_H_
-#define BUFFET_HTTP_TRANSPORT_FAKE_H_
-
-#include <map>
-#include <string>
-#include <type_traits>
-#include <vector>
-
-#include <base/callback.h>
-#include <base/values.h>
-
-#include "buffet/http_transport.h"
-#include "buffet/http_utils.h"
-
-namespace buffet {
-namespace http {
-namespace fake {
-
-class ServerRequest;
-class ServerResponse;
-class Connection;
-
-///////////////////////////////////////////////////////////////////////////////
-// A fake implementation of http::Transport that simulates HTTP communication
-// with a server.
-///////////////////////////////////////////////////////////////////////////////
-class Transport : public http::Transport {
- public:
-  Transport();
-  virtual ~Transport();
-
-  // Server handler callback signature.
-  typedef base::Callback<void(const ServerRequest&, ServerResponse*)>
-      HandlerCallback;
-
-  // This method allows the test code to provide a callback to handle requests
-  // for specific URL/HTTP-verb combination. When a specific |method| request
-  // is made on the given |url|, the |handler| will be invoked and all the
-  // request data will be filled in the |ServerRequest| parameter. Any server
-  // response should be returned through the |ServerResponse| parameter.
-  // Either |method| or |url| (or both) can be specified as "*" to handle
-  // any requests. So, ("http://localhost","*") will handle any request type
-  // on that URL and ("*","GET") will handle any GET requests.
-  // The lookup starts with the most specific data pair to the catch-all (*,*).
-  void AddHandler(const std::string& url, const std::string& method,
-                  const HandlerCallback& handler);
-  // Simple version of AddHandler. AddSimpleReplyHandler just returns the
-  // specified text response of given MIME type.
-  void AddSimpleReplyHandler(const std::string& url,
-                             const std::string& method,
-                             int status_code,
-                             const std::string& reply_text,
-                             const std::string& mime_type);
-  // Retrieve a handler for specific |url| and request |method|.
-  HandlerCallback GetHandler(const std::string& url,
-                             const std::string& method) const;
-
-  // For tests that want to assert on the number of HTTP requests sent,
-  // these methods can be used to do just that.
-  int GetRequestCount() const { return request_count_; }
-  void ResetRequestCount() { request_count_ = 0; }
-
-  // Overload from http::Transport
-  std::unique_ptr<http::Connection> CreateConnection(
-      std::shared_ptr<http::Transport> transport,
-      const std::string& url,
-      const std::string& method,
-      const HeaderList& headers,
-      const std::string& user_agent,
-      const std::string& referer,
-      chromeos::ErrorPtr* error) override;
-
- private:
-  // A list of user-supplied request handlers.
-  std::map<std::string, HandlerCallback> handlers_;
-  // Counter incremented each time a request is made.
-  int request_count_ = 0;
-
-  DISALLOW_COPY_AND_ASSIGN(Transport);
-};
-
-///////////////////////////////////////////////////////////////////////////////
-// A base class for ServerRequest and ServerResponse. It provides common
-// functionality to work with request/response HTTP headers and data.
-///////////////////////////////////////////////////////////////////////////////
-class ServerRequestResponseBase {
- public:
-  ServerRequestResponseBase() = default;
-
-  // Add/retrieve request/response body data.
-  void AddData(const void* data, size_t data_size);
-  const std::vector<unsigned char>& GetData() const { return data_; }
-  std::string GetDataAsString() const;
-  std::unique_ptr<base::DictionaryValue> GetDataAsJson() const;
-
-  // Add/retrieve request/response HTTP headers.
-  void AddHeaders(const HeaderList& headers);
-  std::string GetHeader(const std::string& header_name) const;
-  const std::map<std::string, std::string>& GetHeaders() const {
-    return headers_;
-  }
-
- protected:
-  // Data buffer.
-  std::vector<unsigned char> data_;
-  // Header map.
-  std::map<std::string, std::string> headers_;
-
- private:
-  DISALLOW_COPY_AND_ASSIGN(ServerRequestResponseBase);
-};
-
-///////////////////////////////////////////////////////////////////////////////
-// A container class that encapsulates all the HTTP server request information.
-///////////////////////////////////////////////////////////////////////////////
-class ServerRequest : public ServerRequestResponseBase {
- public:
-  ServerRequest(const std::string& url, const std::string& method);
-
-  // Get the actual request URL. Does not include the query string or fragment.
-  const std::string& GetURL() const { return url_; }
-  // Get the request method.
-  const std::string& GetMethod() const { return method_; }
-  // Get the POST/GET request parameters. These are parsed query string
-  // parameters from the URL. In addition, for POST requests with
-  // application/x-www-form-urlencoded content type, the request body is also
-  // parsed and individual fields can be accessed through this method.
-  std::string GetFormField(const std::string& field_name) const;
-
- private:
-  // Request URL (without query string or URL fragment).
-  std::string url_;
-  // Request method
-  std::string method_;
-  // List of available request data form fields.
-  mutable std::map<std::string, std::string> form_fields_;
-  // Flag used on first request to GetFormField to parse the body of HTTP POST
-  // request with application/x-www-form-urlencoded content.
-  mutable bool form_fields_parsed_ = false;
-
-  DISALLOW_COPY_AND_ASSIGN(ServerRequest);
-};
-
-///////////////////////////////////////////////////////////////////////////////
-// A container class that encapsulates all the HTTP server response information.
-// The request handler will use this class to provide a response to the caller.
-// Call the Reply() or the appropriate ReplyNNN() specialization to provide
-// the response data. Additional calls to AddHeaders() can be made to provide
-// custom response headers. The Reply-methods will already provide the
-// following response headers:
-//    Content-Length
-//    Content-Type
-///////////////////////////////////////////////////////////////////////////////
-class ServerResponse : public ServerRequestResponseBase {
- public:
-  ServerResponse() = default;
-
-  // Generic reply method.
-  void Reply(int status_code, const void* data, size_t data_size,
-             const char* mime_type);
-  // Reply with text body.
-  void ReplyText(int status_code, const std::string& text,
-                 const char* mime_type);
-  // Reply with JSON object. The content type will be "application/json".
-  void ReplyJson(int status_code, const base::Value* json);
-  // Special form for JSON response for simple objects that have a flat
-  // list of key-value pairs of string type.
-  void ReplyJson(int status_code, const FormFieldList& fields);
-
-  // Specialized overload to send the binary data as an array of simple
-  // data elements. Only trivial data types (scalars, POD structures, etc)
-  // can be used.
-  template<typename T>
-  void Reply(int status_code, const std::vector<T>& data,
-             const char* mime_type) {
-    // Make sure T doesn't have virtual functions, custom constructors, etc.
-    static_assert(std::is_trivial<T>::value, "Only simple data is supported");
-    Reply(status_code, data.data(), data.size() * sizeof(T), mime_type);
-  }
-
-  // Specialized overload to send the binary data.
-  // Only trivial data types (scalars, POD structures, etc) can be used.
-  template<typename T>
-  void Reply(int status_code, const T& data, const char* mime_type) {
-    // Make sure T doesn't have virtual functions, custom constructors, etc.
-    static_assert(std::is_trivial<T>::value, "Only simple data is supported");
-    Reply(status_code, &data, sizeof(T), mime_type);
-  }
-
-  // For handlers that want to simulate versions of HTTP protocol other
-  // than HTTP/1.1, call this method with the custom version string,
-  // for example "HTTP/1.0".
-  void SetProtocolVersion(const std::string& protocol_version) {
-    protocol_version_ = protocol_version;
-  }
-
- protected:
-  // These methods are helpers to implement corresponding functionality
-  // of fake::Connection.
-  friend class Connection;
-  // Helper for fake::Connection::GetResponseStatusCode().
-  int GetStatusCode() const { return status_code_; }
-  // Helper for fake::Connection::GetResponseStatusText().
-  std::string GetStatusText() const;
-  // Helper for fake::Connection::GetProtocolVersion().
-  std::string GetProtocolVersion() const { return protocol_version_; }
-
- private:
-  int status_code_ = 0;
-  std::string protocol_version_ = "HTTP/1.1";
-
-  DISALLOW_COPY_AND_ASSIGN(ServerResponse);
-};
-
-}  // namespace fake
-}  // namespace http
-}  // namespace buffet
-
-#endif  // BUFFET_HTTP_TRANSPORT_FAKE_H_
diff --git a/buffet/http_utils.cc b/buffet/http_utils.cc
deleted file mode 100644
index d61d176..0000000
--- a/buffet/http_utils.cc
+++ /dev/null
@@ -1,171 +0,0 @@
-// Copyright 2014 The Chromium OS Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style license that can be
-// found in the LICENSE file.
-
-#include "buffet/http_utils.h"
-
-#include <algorithm>
-
-#include <base/json/json_reader.h>
-#include <base/json/json_writer.h>
-#include <base/values.h>
-#include <chromeos/data_encoding.h>
-#include <chromeos/error_codes.h>
-#include <chromeos/mime_utils.h>
-
-using chromeos::mime::AppendParameter;
-using chromeos::mime::RemoveParameters;
-
-namespace buffet {
-namespace http {
-
-std::unique_ptr<Response> Get(const std::string& url,
-                              const HeaderList& headers,
-                              std::shared_ptr<Transport> transport,
-                              chromeos::ErrorPtr* error) {
-  return SendRequest(request_type::kGet, url, nullptr, 0, nullptr,
-                     headers, transport, error);
-}
-
-std::string GetAsString(const std::string& url,
-                        const HeaderList& headers,
-                        std::shared_ptr<Transport> transport,
-                        chromeos::ErrorPtr* error) {
-  auto resp = Get(url, headers, transport, error);
-  return resp ? resp->GetDataAsString() : std::string();
-}
-
-std::unique_ptr<Response> Head(const std::string& url,
-                               std::shared_ptr<Transport> transport,
-                               chromeos::ErrorPtr* error) {
-  Request request(url, request_type::kHead, transport);
-  return request.GetResponse(error);
-}
-
-std::unique_ptr<Response> PostText(const std::string& url,
-                                   const char* data,
-                                   const char* mime_type,
-                                   const HeaderList& headers,
-                                   std::shared_ptr<Transport> transport,
-                                   chromeos::ErrorPtr* error) {
-  if (mime_type == nullptr) {
-    mime_type = chromeos::mime::application::kWwwFormUrlEncoded;
-  }
-
-  return PostBinary(url, data, strlen(data), mime_type, headers, transport,
-                    error);
-}
-
-std::unique_ptr<Response> SendRequest(const char * method,
-                                      const std::string& url,
-                                      const void* data,
-                                      size_t data_size,
-                                      const char* mime_type,
-                                      const HeaderList& headers,
-                                      std::shared_ptr<Transport> transport,
-                                      chromeos::ErrorPtr* error) {
-  Request request(url, method, transport);
-  request.AddHeaders(headers);
-  if (data_size > 0) {
-    if (mime_type == nullptr) {
-      mime_type = chromeos::mime::application::kOctet_stream;
-    }
-    request.SetContentType(mime_type);
-    if (!request.AddRequestBody(data, data_size, error))
-      return std::unique_ptr<Response>();
-  }
-  return request.GetResponse(error);
-}
-
-std::unique_ptr<Response> PostBinary(const std::string & url, const void* data,
-                                     size_t data_size, const char* mime_type,
-                                     const HeaderList& headers,
-                                     std::shared_ptr<Transport> transport,
-                                     chromeos::ErrorPtr* error) {
-  return SendRequest(request_type::kPost, url,
-                     data, data_size, mime_type, headers, transport, error);
-}
-
-std::unique_ptr<Response> PostFormData(const std::string& url,
-                                       const FormFieldList& data,
-                                       const HeaderList& headers,
-                                       std::shared_ptr<Transport> transport,
-                                       chromeos::ErrorPtr* error) {
-  std::string encoded_data = chromeos::data_encoding::WebParamsEncode(data);
-  return PostBinary(url, encoded_data.c_str(), encoded_data.size(),
-                    chromeos::mime::application::kWwwFormUrlEncoded,
-                    headers, transport, error);
-}
-
-
-std::unique_ptr<Response> PostJson(const std::string& url,
-                                   const base::Value* json,
-                                   const HeaderList& headers,
-                                   std::shared_ptr<Transport> transport,
-                                   chromeos::ErrorPtr* error) {
-  std::string data;
-  if (json)
-    base::JSONWriter::Write(json, &data);
-  std::string mime_type = AppendParameter(chromeos::mime::application::kJson,
-                                          chromeos::mime::parameters::kCharset,
-                                          "utf-8");
-  return PostBinary(url, data.c_str(), data.size(),
-                    mime_type.c_str(), headers, transport, error);
-}
-
-std::unique_ptr<Response> PatchJson(const std::string& url,
-                                    const base::Value* json,
-                                    const HeaderList& headers,
-                                    std::shared_ptr<Transport> transport,
-                                    chromeos::ErrorPtr* error) {
-  std::string data;
-  if (json)
-    base::JSONWriter::Write(json, &data);
-  std::string mime_type = AppendParameter(chromeos::mime::application::kJson,
-                                          chromeos::mime::parameters::kCharset,
-                                          "utf-8");
-  return SendRequest(request_type::kPatch, url, data.c_str(), data.size(),
-                     mime_type.c_str(), headers, transport, error);
-}
-
-std::unique_ptr<base::DictionaryValue> ParseJsonResponse(
-    const Response* response, int* status_code, chromeos::ErrorPtr* error) {
-  if (!response)
-    return std::unique_ptr<base::DictionaryValue>();
-
-  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 = RemoveParameters(response->GetContentType());
-  if (content_type != chromeos::mime::application::kJson &&
-      content_type != chromeos::mime::text::kPlain) {
-    chromeos::Error::AddTo(error, chromeos::errors::json::kDomain,
-                           "non_json_content_type",
-                           "Unexpected response content type: " + content_type);
-    return std::unique_ptr<base::DictionaryValue>();
-  }
-
-  std::string json = response->GetDataAsString();
-  std::string error_message;
-  base::Value* value = base::JSONReader::ReadAndReturnError(
-      json, base::JSON_PARSE_RFC, nullptr, &error_message);
-  if (!value) {
-    chromeos::Error::AddTo(error, chromeos::errors::json::kDomain,
-                           chromeos::errors::json::kParseError, error_message);
-    return std::unique_ptr<base::DictionaryValue>();
-  }
-  base::DictionaryValue* dict_value = nullptr;
-  if (!value->GetAsDictionary(&dict_value)) {
-    delete value;
-    chromeos::Error::AddTo(error, chromeos::errors::json::kDomain,
-                           chromeos::errors::json::kObjectExpected,
-                           "Response is not a valid JSON object");
-    return std::unique_ptr<base::DictionaryValue>();
-  }
-  return std::unique_ptr<base::DictionaryValue>(dict_value);
-}
-
-}  // namespace http
-}  // namespace buffet
diff --git a/buffet/http_utils.h b/buffet/http_utils.h
deleted file mode 100644
index 938905d..0000000
--- a/buffet/http_utils.h
+++ /dev/null
@@ -1,180 +0,0 @@
-// Copyright 2014 The Chromium OS Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style license that can be
-// found in the LICENSE file.
-
-#ifndef BUFFET_HTTP_UTILS_H_
-#define BUFFET_HTTP_UTILS_H_
-
-#include <string>
-#include <utility>
-#include <vector>
-
-#include <chromeos/error.h>
-
-#include "buffet/http_request.h"
-
-namespace base {
-class Value;
-class DictionaryValue;
-}  // namespace base
-
-namespace buffet {
-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.
-//
-// For more advanced functionality you need to use Request/Response objects
-// 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(
-    const char* method, const std::string& url,
-    const void* data, size_t data_size, const char* mime_type,
-    const HeaderList& headers, std::shared_ptr<Transport> transport,
-    chromeos::ErrorPtr* error);
-
-// Performs a simple GET request and returns the data as a string.
-std::string GetAsString(const std::string& url, const HeaderList& headers,
-                        std::shared_ptr<Transport> transport,
-                        chromeos::ErrorPtr* error);
-inline std::string GetAsString(const std::string& url,
-                               std::shared_ptr<Transport> transport,
-                               chromeos::ErrorPtr* error) {
-  return GetAsString(url, HeaderList(), transport, error);
-}
-
-// 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(const std::string& url,
-                              const HeaderList& headers,
-                              std::shared_ptr<Transport> transport,
-                              chromeos::ErrorPtr* error);
-inline std::unique_ptr<Response> Get(
-    const std::string& url, std::shared_ptr<Transport> transport,
-    chromeos::ErrorPtr* error) {
-  return Get(url, HeaderList(), transport, error);
-}
-
-// 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(const std::string& url,
-                               std::shared_ptr<Transport> transport,
-                               chromeos::ErrorPtr* error);
-
-// 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(const std::string& url,
-                                     const void* data,
-                                     size_t data_size,
-                                     const char* mime_type,
-                                     const HeaderList& headers,
-                                     std::shared_ptr<Transport> transport,
-                                     chromeos::ErrorPtr* error);
-
-inline std::unique_ptr<Response> PostBinary(
-    const std::string& url, const void* data, size_t data_size,
-    const char* mime_type, std::shared_ptr<Transport> transport,
-    chromeos::ErrorPtr* error) {
-  return PostBinary(url, data, data_size, mime_type, HeaderList(), transport,
-                    error);
-}
-
-inline std::unique_ptr<Response> PostBinary(
-    const std::string& url, const void* data, size_t data_size,
-    std::shared_ptr<Transport> transport, chromeos::ErrorPtr* error) {
-  return PostBinary(url, data, data_size, nullptr, transport, error);
-}
-
-// Performs a POST request with text 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/x-www-form-urlencoded"
-// is assumed.
-std::unique_ptr<Response> PostText(const std::string& url,
-                                   const char* data,
-                                   const char* mime_type,
-                                   const HeaderList& headers,
-                                   std::shared_ptr<Transport> transport,
-                                   chromeos::ErrorPtr* error);
-
-inline std::unique_ptr<Response> PostText(
-    const std::string& url, const char* data, const char* mime_type,
-    std::shared_ptr<Transport> transport, chromeos::ErrorPtr* error) {
-  return PostText(url, data, mime_type, HeaderList(), transport, error);
-}
-
-inline std::unique_ptr<Response> PostText(
-    const std::string& url, const char* data,
-    std::shared_ptr<Transport> transport, chromeos::ErrorPtr* error) {
-  return PostText(url, data, nullptr, transport, error);
-}
-
-// 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(
-    const std::string& url, const FormFieldList& data,
-    const HeaderList& headers, std::shared_ptr<Transport> transport,
-    chromeos::ErrorPtr* error);
-
-inline std::unique_ptr<Response> PostFormData(
-    const std::string& url, const FormFieldList& data,
-    std::shared_ptr<Transport> transport, chromeos::ErrorPtr* error) {
-  return PostFormData(url, data, HeaderList(), transport, error);
-}
-
-// 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(const std::string& url,
-                                   const base::Value* json,
-                                   const HeaderList& headers,
-                                   std::shared_ptr<Transport> transport,
-                                   chromeos::ErrorPtr* error);
-
-inline std::unique_ptr<Response> PostJson(
-    const std::string& url, const base::Value* json,
-    std::shared_ptr<Transport> transport, chromeos::ErrorPtr* error) {
-  return PostJson(url, json, HeaderList(), transport, error);
-}
-
-// 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(const std::string& url,
-                                    const base::Value* json,
-                                    const HeaderList& headers,
-                                    std::shared_ptr<Transport> transport,
-                                    chromeos::ErrorPtr* error);
-
-inline std::unique_ptr<Response> PatchJson(
-    const std::string& url, const base::Value* json,
-    std::shared_ptr<Transport> transport, chromeos::ErrorPtr* error) {
-  return PatchJson(url, json, HeaderList(), transport, error);
-}
-
-// Given an http::Response object, parse the body data into Json object.
-// Returns null if failed. Optional |error| can be passed in to
-// get the extended error information as to why the parse failed.
-std::unique_ptr<base::DictionaryValue> ParseJsonResponse(
-    const Response* response, int* status_code, chromeos::ErrorPtr* error);
-
-}  // namespace http
-}  // namespace buffet
-
-#endif  // BUFFET_HTTP_UTILS_H_
diff --git a/buffet/http_utils_unittest.cc b/buffet/http_utils_unittest.cc
deleted file mode 100644
index 8f40ad7..0000000
--- a/buffet/http_utils_unittest.cc
+++ /dev/null
@@ -1,341 +0,0 @@
-// Copyright 2014 The Chromium OS Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style license that can be
-// found in the LICENSE file.
-
-#include <string>
-#include <vector>
-
-#include <base/values.h>
-#include <chromeos/bind_lambda.h>
-#include <chromeos/mime_utils.h>
-#include <chromeos/string_utils.h>
-#include <chromeos/url_utils.h>
-#include <gtest/gtest.h>
-
-#include "buffet/http_transport_fake.h"
-#include "buffet/http_utils.h"
-
-using namespace buffet;        // NOLINT(build/namespaces)
-using namespace buffet::http;  // NOLINT(build/namespaces)
-
-static const char kFakeUrl[] = "http://localhost";
-static const char kEchoUrl[] = "http://localhost/echo";
-static const char kMethodEchoUrl[] = "http://localhost/echo/method";
-
-///////////////////// Generic helper request handlers /////////////////////////
-// Returns the request data back with the same content type.
-static void EchoDataHandler(const fake::ServerRequest& request,
-                            fake::ServerResponse* response) {
-  response->Reply(status_code::Ok, request.GetData(),
-                  request.GetHeader(request_header::kContentType).c_str());
-}
-
-// Returns the request method as a plain text response.
-static void EchoMethodHandler(const fake::ServerRequest& request,
-                              fake::ServerResponse* response) {
-  response->ReplyText(status_code::Ok, request.GetMethod(),
-                      chromeos::mime::text::kPlain);
-}
-
-///////////////////////////////////////////////////////////////////////////////
-TEST(HttpUtils, SendRequest_BinaryData) {
-  std::shared_ptr<fake::Transport> transport(new fake::Transport);
-  transport->AddHandler(kEchoUrl, request_type::kPost,
-                        base::Bind(EchoDataHandler));
-
-  // Test binary data round-tripping.
-  std::vector<unsigned char> custom_data{0xFF, 0x00, 0x80, 0x40, 0xC0, 0x7F};
-  auto response = http::SendRequest(request_type::kPost, kEchoUrl,
-                                    custom_data.data(), custom_data.size(),
-                                    chromeos::mime::application::kOctet_stream,
-                                    HeaderList(), transport, nullptr);
-  EXPECT_TRUE(response->IsSuccessful());
-  EXPECT_EQ(chromeos::mime::application::kOctet_stream,
-            response->GetContentType());
-  EXPECT_EQ(custom_data.size(), response->GetData().size());
-  EXPECT_EQ(custom_data, response->GetData());
-}
-
-TEST(HttpUtils, SendRequest_Post) {
-  std::shared_ptr<fake::Transport> transport(new fake::Transport);
-  transport->AddHandler(kMethodEchoUrl, "*", base::Bind(EchoMethodHandler));
-
-  // Test binary data round-tripping.
-  std::vector<unsigned char> custom_data{0xFF, 0x00, 0x80, 0x40, 0xC0, 0x7F};
-
-  // Check the correct HTTP method used.
-  auto response = http::SendRequest(request_type::kPost, kMethodEchoUrl,
-                                    custom_data.data(), custom_data.size(),
-                                    chromeos::mime::application::kOctet_stream,
-                                    HeaderList(), transport, nullptr);
-  EXPECT_TRUE(response->IsSuccessful());
-  EXPECT_EQ(chromeos::mime::text::kPlain, response->GetContentType());
-  EXPECT_EQ(request_type::kPost, response->GetDataAsString());
-}
-
-TEST(HttpUtils, SendRequest_Get) {
-  std::shared_ptr<fake::Transport> transport(new fake::Transport);
-  transport->AddHandler(kMethodEchoUrl, "*", base::Bind(EchoMethodHandler));
-
-  auto response = http::SendRequest(request_type::kGet, kMethodEchoUrl,
-                                    nullptr, 0, nullptr,
-                                    HeaderList(), transport, nullptr);
-  EXPECT_TRUE(response->IsSuccessful());
-  EXPECT_EQ(chromeos::mime::text::kPlain, response->GetContentType());
-  EXPECT_EQ(request_type::kGet, response->GetDataAsString());
-}
-
-TEST(HttpUtils, SendRequest_Put) {
-  std::shared_ptr<fake::Transport> transport(new fake::Transport);
-  transport->AddHandler(kMethodEchoUrl, "*", base::Bind(EchoMethodHandler));
-
-  auto response = http::SendRequest(request_type::kPut, kMethodEchoUrl,
-                                    nullptr, 0, nullptr,
-                                    HeaderList(), transport, nullptr);
-  EXPECT_TRUE(response->IsSuccessful());
-  EXPECT_EQ(chromeos::mime::text::kPlain, response->GetContentType());
-  EXPECT_EQ(request_type::kPut, response->GetDataAsString());
-}
-
-TEST(HttpUtils, SendRequest_NotFound) {
-  std::shared_ptr<fake::Transport> transport(new fake::Transport);
-  // Test failed response (URL not found).
-  auto response = http::SendRequest(request_type::kGet, "http://blah.com",
-                                    nullptr, 0, nullptr,
-                                    HeaderList(), transport, nullptr);
-  EXPECT_FALSE(response->IsSuccessful());
-  EXPECT_EQ(status_code::NotFound, response->GetStatusCode());
-}
-
-TEST(HttpUtils, SendRequest_Headers) {
-  std::shared_ptr<fake::Transport> transport(new fake::Transport);
-
-  static const char json_echo_url[] = "http://localhost/echo/json";
-  auto JsonEchoHandler = [](const fake::ServerRequest& request,
-                            fake::ServerResponse* response) {
-    base::DictionaryValue json;
-    json.SetString("method", request.GetMethod());
-    json.SetString("data", request.GetDataAsString());
-    for (const auto& pair : request.GetHeaders()) {
-      json.SetString("header." + pair.first, pair.second);
-    }
-    response->ReplyJson(status_code::Ok, &json);
-  };
-  transport->AddHandler(json_echo_url, "*",
-                        base::Bind(JsonEchoHandler));
-  auto response = http::SendRequest(
-      request_type::kPost, json_echo_url, "abcd", 4,
-      chromeos::mime::application::kOctet_stream, {
-        {request_header::kCookie, "flavor=vanilla"},
-        {request_header::kIfMatch, "*"},
-      }, transport, nullptr);
-  EXPECT_TRUE(response->IsSuccessful());
-  EXPECT_EQ(chromeos::mime::application::kJson,
-            chromeos::mime::RemoveParameters(response->GetContentType()));
-  auto json = ParseJsonResponse(response.get(), nullptr, nullptr);
-  std::string value;
-  EXPECT_TRUE(json->GetString("method", &value));
-  EXPECT_EQ(request_type::kPost, value);
-  EXPECT_TRUE(json->GetString("data", &value));
-  EXPECT_EQ("abcd", value);
-  EXPECT_TRUE(json->GetString("header.Cookie", &value));
-  EXPECT_EQ("flavor=vanilla", value);
-  EXPECT_TRUE(json->GetString("header.Content-Type", &value));
-  EXPECT_EQ(chromeos::mime::application::kOctet_stream, value);
-  EXPECT_TRUE(json->GetString("header.Content-Length", &value));
-  EXPECT_EQ("4", value);
-  EXPECT_TRUE(json->GetString("header.If-Match", &value));
-  EXPECT_EQ("*", value);
-}
-
-TEST(HttpUtils, Get) {
-  // Sends back the "?test=..." portion of URL.
-  // So if we do GET "http://localhost?test=blah", this handler responds
-  // with "blah" as text/plain.
-  auto GetHandler = [](const fake::ServerRequest& request,
-                       fake::ServerResponse* response) {
-    EXPECT_EQ(request_type::kGet, request.GetMethod());
-    EXPECT_EQ("0", request.GetHeader(request_header::kContentLength));
-    EXPECT_EQ("", request.GetHeader(request_header::kContentType));
-    response->ReplyText(status_code::Ok, request.GetFormField("test"),
-                        chromeos::mime::text::kPlain);
-  };
-
-  std::shared_ptr<fake::Transport> transport(new fake::Transport);
-  transport->AddHandler(kFakeUrl, request_type::kGet, base::Bind(GetHandler));
-  transport->AddHandler(kMethodEchoUrl, "*", base::Bind(EchoMethodHandler));
-
-  // Make sure Get/GetAsString actually do the GET request
-  auto response = http::Get(kMethodEchoUrl, transport, nullptr);
-  EXPECT_TRUE(response->IsSuccessful());
-  EXPECT_EQ(chromeos::mime::text::kPlain, response->GetContentType());
-  EXPECT_EQ(request_type::kGet, response->GetDataAsString());
-  EXPECT_EQ(request_type::kGet,
-            http::GetAsString(kMethodEchoUrl, transport, nullptr));
-
-  for (std::string data : {"blah", "some data", ""}) {
-    std::string url = chromeos::url::AppendQueryParam(kFakeUrl, "test", data);
-    EXPECT_EQ(data, http::GetAsString(url, transport, nullptr));
-  }
-}
-
-TEST(HttpUtils, Head) {
-  auto HeadHandler = [](const fake::ServerRequest& request,
-                        fake::ServerResponse* response) {
-    EXPECT_EQ(request_type::kHead, request.GetMethod());
-    EXPECT_EQ("0", request.GetHeader(request_header::kContentLength));
-    EXPECT_EQ("", request.GetHeader(request_header::kContentType));
-    response->ReplyText(status_code::Ok, "blah",
-                        chromeos::mime::text::kPlain);
-  };
-
-  std::shared_ptr<fake::Transport> transport(new fake::Transport);
-  transport->AddHandler(kFakeUrl, request_type::kHead, base::Bind(HeadHandler));
-
-  auto response = http::Head(kFakeUrl, transport, nullptr);
-  EXPECT_TRUE(response->IsSuccessful());
-  EXPECT_EQ(chromeos::mime::text::kPlain, response->GetContentType());
-  EXPECT_EQ("", response->GetDataAsString());  // Must not have actual body.
-  EXPECT_EQ("4", response->GetHeader(request_header::kContentLength));
-}
-
-TEST(HttpUtils, PostBinary) {
-  auto Handler = [](const fake::ServerRequest& request,
-                    fake::ServerResponse* response) {
-    EXPECT_EQ(request_type::kPost, request.GetMethod());
-    EXPECT_EQ("256", request.GetHeader(request_header::kContentLength));
-    EXPECT_EQ(chromeos::mime::application::kOctet_stream,
-              request.GetHeader(request_header::kContentType));
-    const auto& data = request.GetData();
-    EXPECT_EQ(256, data.size());
-
-    // Sum up all the bytes.
-    int sum = std::accumulate(data.begin(), data.end(), 0);
-    EXPECT_EQ(32640, sum);  // sum(i, i => [0, 255]) = 32640.
-    response->ReplyText(status_code::Ok, "", chromeos::mime::text::kPlain);
-  };
-
-  std::shared_ptr<fake::Transport> transport(new fake::Transport);
-  transport->AddHandler(kFakeUrl, request_type::kPost, base::Bind(Handler));
-
-  /// Fill the data buffer with bytes from 0x00 to 0xFF.
-  std::vector<unsigned char> data(256);
-  std::iota(data.begin(), data.end(), 0);
-
-  auto response = http::PostBinary(kFakeUrl, data.data(), data.size(),
-                                   transport, nullptr);
-  EXPECT_TRUE(response->IsSuccessful());
-}
-
-TEST(HttpUtils, PostText) {
-  std::string fake_data = "Some data";
-  auto PostHandler = [fake_data](const fake::ServerRequest& request,
-                                 fake::ServerResponse* response) {
-    EXPECT_EQ(request_type::kPost, request.GetMethod());
-    EXPECT_EQ(fake_data.size(),
-              std::stoul(request.GetHeader(request_header::kContentLength)));
-    EXPECT_EQ(chromeos::mime::text::kPlain,
-              request.GetHeader(request_header::kContentType));
-    response->ReplyText(status_code::Ok, request.GetDataAsString(),
-                       chromeos::mime::text::kPlain);
-  };
-
-  std::shared_ptr<fake::Transport> transport(new fake::Transport);
-  transport->AddHandler(kFakeUrl, request_type::kPost, base::Bind(PostHandler));
-
-  auto response = http::PostText(kFakeUrl, fake_data.c_str(),
-                                 chromeos::mime::text::kPlain,
-                                 transport, nullptr);
-  EXPECT_TRUE(response->IsSuccessful());
-  EXPECT_EQ(chromeos::mime::text::kPlain, response->GetContentType());
-  EXPECT_EQ(fake_data, response->GetDataAsString());
-}
-
-TEST(HttpUtils, PostFormData) {
-  std::shared_ptr<fake::Transport> transport(new fake::Transport);
-  transport->AddHandler(kFakeUrl, request_type::kPost,
-                        base::Bind(EchoDataHandler));
-
-  auto response = http::PostFormData(kFakeUrl, {
-                      {"key", "value"},
-                      {"field", "field value"},
-                  }, transport, nullptr);
-  EXPECT_TRUE(response->IsSuccessful());
-  EXPECT_EQ(chromeos::mime::application::kWwwFormUrlEncoded,
-            response->GetContentType());
-  EXPECT_EQ("key=value&field=field+value", response->GetDataAsString());
-}
-
-TEST(HttpUtils, PostPatchJson) {
-  auto JsonHandler = [](const fake::ServerRequest& request,
-                        fake::ServerResponse* response) {
-    auto mime_type = chromeos::mime::RemoveParameters(
-        request.GetHeader(request_header::kContentType));
-    EXPECT_EQ(chromeos::mime::application::kJson, mime_type);
-    response->ReplyJson(status_code::Ok, {
-      {"method", request.GetMethod()},
-      {"data", request.GetDataAsString()},
-    });
-  };
-  std::shared_ptr<fake::Transport> transport(new fake::Transport);
-  transport->AddHandler(kFakeUrl, "*", base::Bind(JsonHandler));
-
-  base::DictionaryValue json;
-  json.SetString("key1", "val1");
-  json.SetString("key2", "val2");
-  std::string value;
-
-  // Test POST
-  auto response = http::PostJson(kFakeUrl, &json, transport, nullptr);
-  auto resp_json = http::ParseJsonResponse(response.get(), nullptr, nullptr);
-  EXPECT_NE(nullptr, resp_json.get());
-  EXPECT_TRUE(resp_json->GetString("method", &value));
-  EXPECT_EQ(request_type::kPost, value);
-  EXPECT_TRUE(resp_json->GetString("data", &value));
-  EXPECT_EQ("{\"key1\":\"val1\",\"key2\":\"val2\"}", value);
-
-  // Test PATCH
-  response = http::PatchJson(kFakeUrl, &json, transport, nullptr);
-  resp_json = http::ParseJsonResponse(response.get(), nullptr, nullptr);
-  EXPECT_NE(nullptr, resp_json.get());
-  EXPECT_TRUE(resp_json->GetString("method", &value));
-  EXPECT_EQ(request_type::kPatch, value);
-  EXPECT_TRUE(resp_json->GetString("data", &value));
-  EXPECT_EQ("{\"key1\":\"val1\",\"key2\":\"val2\"}", value);
-}
-
-TEST(HttpUtils, ParseJsonResponse) {
-  auto JsonHandler = [](const fake::ServerRequest& request,
-                        fake::ServerResponse* response) {
-    int status_code = std::stoi(request.GetFormField("code"));
-    response->ReplyJson(status_code, {{"data", request.GetFormField("value")}});
-  };
-  std::shared_ptr<fake::Transport> transport(new fake::Transport);
-  transport->AddHandler(kFakeUrl, request_type::kPost, base::Bind(JsonHandler));
-
-  // Test valid JSON responses (with success or error codes).
-  for (auto item : {"200;data", "400;wrong", "500;Internal Server error"}) {
-    auto pair = chromeos::string_utils::SplitAtFirst(item, ';');
-    auto response = http::PostFormData(kFakeUrl, {
-                      {"code", pair.first},
-                      {"value", pair.second},
-                    }, transport, nullptr);
-    int code = 0;
-    auto json = http::ParseJsonResponse(response.get(), &code, nullptr);
-    EXPECT_NE(nullptr, json.get());
-    std::string value;
-    EXPECT_TRUE(json->GetString("data", &value));
-    EXPECT_EQ(pair.first, chromeos::string_utils::ToString(code));
-    EXPECT_EQ(pair.second, value);
-  }
-
-  // Test invalid (non-JSON) response.
-  auto response = http::Get("http://bad.url", transport, nullptr);
-  EXPECT_EQ(status_code::NotFound, response->GetStatusCode());
-  EXPECT_EQ(chromeos::mime::text::kHtml, response->GetContentType());
-  int code = 0;
-  auto json = http::ParseJsonResponse(response.get(), &code, nullptr);
-  EXPECT_EQ(nullptr, json.get());
-  EXPECT_EQ(status_code::NotFound, code);
-}
-