diff --git a/buffet/http_utils.h b/buffet/http_utils.h
index 2979ed3..c10805a 100644
--- a/buffet/http_utils.h
+++ b/buffet/http_utils.h
@@ -29,32 +29,35 @@
 // 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::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);
 
 // Performs a simple GET request and returns the data as a string.
-std::string GetAsString(const std::string& url, const HeaderList& headers);
-inline std::string GetAsString(const std::string& url) {
-  return GetAsString(url, HeaderList());
+std::string GetAsString(const std::string& url, const HeaderList& headers,
+                        std::shared_ptr<Transport> transport);
+inline std::string GetAsString(const std::string& url,
+                               std::shared_ptr<Transport> transport) {
+  return GetAsString(url, HeaderList(), transport);
 }
 
 // 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);
-inline std::unique_ptr<Response> Get(const std::string& url) {
-  return Get(url, HeaderList());
+                              const HeaderList& headers,
+                              std::shared_ptr<Transport> transport);
+inline std::unique_ptr<Response> Get(
+    const std::string& url, std::shared_ptr<Transport> transport) {
+  return Get(url, HeaderList(), transport);
 }
 
 // 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::unique_ptr<Response> Head(const std::string& url,
+                               std::shared_ptr<Transport> transport);
 
 // Performs a POST request with binary data. Success status, returned data
 // and additional information (such as returned HTTP headers) can be obtained
@@ -64,19 +67,19 @@
                                      const void* data,
                                      size_t data_size,
                                      const char* mime_type,
-                                     const HeaderList& headers);
+                                     const HeaderList& headers,
+                                     std::shared_ptr<Transport> transport);
 
-inline std::unique_ptr<Response> PostBinary(const std::string& url,
-                                            const void* data,
-                                            size_t data_size,
-                                            const char* mime_type) {
-  return PostBinary(url, data, data_size, mime_type, HeaderList());
+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) {
+  return PostBinary(url, data, data_size, mime_type, HeaderList(), transport);
 }
 
-inline std::unique_ptr<Response> PostBinary(const std::string& url,
-                                            const void* data,
-                                            size_t data_size) {
-  return PostBinary(url, data, data_size, nullptr);
+inline std::unique_ptr<Response> PostBinary(
+    const std::string& url, const void* data, size_t data_size,
+    std::shared_ptr<Transport> transport) {
+  return PostBinary(url, data, data_size, nullptr, transport);
 }
 
 // Performs a POST request with text data. Success status, returned data
@@ -87,30 +90,33 @@
 std::unique_ptr<Response> PostText(const std::string& url,
                                    const char* data,
                                    const char* mime_type,
-                                   const HeaderList& headers);
+                                   const HeaderList& headers,
+                                   std::shared_ptr<Transport> transport);
 
-inline std::unique_ptr<Response> PostText(const std::string& url,
-                                          const char* data,
-                                          const char* mime_type) {
-  return PostText(url, data, mime_type, HeaderList());
+inline std::unique_ptr<Response> PostText(
+    const std::string& url, const char* data, const char* mime_type,
+    std::shared_ptr<Transport> transport) {
+  return PostText(url, data, mime_type, HeaderList(), transport);
 }
 
-inline std::unique_ptr<Response> PostText(const std::string& url,
-                                          const char* data) {
-  return PostText(url, data, nullptr);
+inline std::unique_ptr<Response> PostText(
+    const std::string& url, const char* data,
+    std::shared_ptr<Transport> transport) {
+  return PostText(url, data, nullptr, transport);
 }
 
 // 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::unique_ptr<Response> PostFormData(
+    const std::string& url, const FormFieldList& data,
+    const HeaderList& headers, std::shared_ptr<Transport> transport);
 
-inline std::unique_ptr<Response> PostFormData(const std::string& url,
-                                              const FormFieldList& data) {
-  return PostFormData(url, data, HeaderList());
+inline std::unique_ptr<Response> PostFormData(
+    const std::string& url, const FormFieldList& data,
+    std::shared_ptr<Transport> transport) {
+  return PostFormData(url, data, HeaderList(), transport);
 }
 
 // Performs a POST request with JSON data. Success status, returned data
@@ -119,11 +125,13 @@
 // use ParseJsonResponse() method on the returned Response object.
 std::unique_ptr<Response> PostJson(const std::string& url,
                                    const base::Value* json,
-                                   const HeaderList& headers);
+                                   const HeaderList& headers,
+                                   std::shared_ptr<Transport> transport);
 
-inline std::unique_ptr<Response> PostJson(const std::string& url,
-                                          const base::Value* json) {
-  return PostJson(url, json, HeaderList());
+inline std::unique_ptr<Response> PostJson(
+    const std::string& url, const base::Value* json,
+    std::shared_ptr<Transport> transport) {
+  return PostJson(url, json, HeaderList(), transport);
 }
 
 // Performs a PATCH request with JSON data. Success status, returned data
@@ -132,11 +140,13 @@
 // use ParseJsonResponse() method on the returned Response object.
 std::unique_ptr<Response> PatchJson(const std::string& url,
                                     const base::Value* json,
-                                    const HeaderList& headers);
+                                    const HeaderList& headers,
+                                    std::shared_ptr<Transport> transport);
 
-inline std::unique_ptr<Response> PatchJson(const std::string& url,
-                                           const base::Value* json) {
-  return PatchJson(url, json, HeaderList());
+inline std::unique_ptr<Response> PatchJson(
+    const std::string& url, const base::Value* json,
+    std::shared_ptr<Transport> transport) {
+  return PatchJson(url, json, HeaderList(), transport);
 }
 
 // Given an http::Response object, parse the body data into Json object.