diff --git a/buffet/http_utils.h b/buffet/http_utils.h
index 724f118..91e12b5 100644
--- a/buffet/http_utils.h
+++ b/buffet/http_utils.h
@@ -29,45 +29,45 @@
 // returned data and additional information (such as returned HTTP headers)
 // can be obtained from the returned Response object.
 // If data MIME type is not specified, "application/octet-stream" is assumed.
-std::unique_ptr<Response> SendRequest(char const* method,
-                                      std::string const& url,
-                                      void const* data,
+std::unique_ptr<Response> SendRequest(const char* method,
+                                      const std::string& url,
+                                      const void* data,
                                       size_t data_size,
-                                      char const* mime_type,
-                                      HeaderList const& headers);
+                                      const char* mime_type,
+                                      const HeaderList& headers);
 
 // Performs a simple GET request and returns the data as a string.
-std::string GetAsString(std::string const& url);
+std::string GetAsString(const std::string& url);
 
 // Performs a GET request. Success status, returned data and additional
 // information (such as returned HTTP headers) can be obtained from
 // the returned Response object.
-std::unique_ptr<Response> Get(std::string const& url);
+std::unique_ptr<Response> Get(const std::string& url);
 
 // Performs a HEAD request. Success status and additional
 // information (such as returned HTTP headers) can be obtained from
 // the returned Response object.
-std::unique_ptr<Response> Head(std::string const& url);
+std::unique_ptr<Response> Head(const std::string& url);
 
 // Performs a POST request with binary data. Success status, returned data
 // and additional information (such as returned HTTP headers) can be obtained
 // from the returned Response object.
 // If data MIME type is not specified, "application/octet-stream" is assumed
-std::unique_ptr<Response> PostBinary(std::string const& url,
-                                     void const* data,
+std::unique_ptr<Response> PostBinary(const std::string& url,
+                                     const void* data,
                                      size_t data_size,
-                                     char const* mime_type,
-                                     HeaderList const& headers);
+                                     const char* mime_type,
+                                     const HeaderList& headers);
 
-inline std::unique_ptr<Response> PostBinary(std::string const& url,
-                                            void const* data,
+inline std::unique_ptr<Response> PostBinary(const std::string& url,
+                                            const void* data,
                                             size_t data_size,
-                                            char const* mime_type) {
+                                            const char* mime_type) {
   return PostBinary(url, data, data_size, mime_type, HeaderList());
 }
 
-inline std::unique_ptr<Response> PostBinary(std::string const& url,
-                                            void const* data,
+inline std::unique_ptr<Response> PostBinary(const std::string& url,
+                                            const void* data,
                                             size_t data_size) {
   return PostBinary(url, data, data_size, nullptr);
 }
@@ -77,19 +77,19 @@
 // from the returned Response object.
 // If data MIME type is not specified, "application/x-www-form-urlencoded"
 // is assumed.
-std::unique_ptr<Response> PostText(std::string const& url,
-                                   char const* data,
-                                   char const* mime_type,
-                                   HeaderList const& headers);
+std::unique_ptr<Response> PostText(const std::string& url,
+                                   const char* data,
+                                   const char* mime_type,
+                                   const HeaderList& headers);
 
-inline std::unique_ptr<Response> PostText(std::string const& url,
-                                          char const* data,
-                                          char const* mime_type) {
+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(std::string const& url,
-                                          char const* data) {
+inline std::unique_ptr<Response> PostText(const std::string& url,
+                                          const char* data) {
   return PostText(url, data, nullptr);
 }
 
@@ -97,12 +97,12 @@
 // and additional information (such as returned HTTP headers) can be obtained
 // from the returned Response object. The form data is a list of key/value
 // pairs. The data is posed as "application/x-www-form-urlencoded".
-std::unique_ptr<Response> PostFormData(std::string const& url,
-                                       FormFieldList const& data,
-                                       HeaderList const& headers);
+std::unique_ptr<Response> PostFormData(const std::string& url,
+                                       const FormFieldList& data,
+                                       const HeaderList& headers);
 
-inline std::unique_ptr<Response> PostFormData(std::string const& url,
-                                              FormFieldList const& data) {
+inline std::unique_ptr<Response> PostFormData(const std::string& url,
+                                              const FormFieldList& data) {
   return PostFormData(url, data, HeaderList());
 }
 
@@ -110,12 +110,12 @@
 // 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(std::string const& url,
-                                   base::Value const* json,
-                                   HeaderList const& headers);
+std::unique_ptr<Response> PostJson(const std::string& url,
+                                   const base::Value* json,
+                                   const HeaderList& headers);
 
-inline std::unique_ptr<Response> PostJson(std::string const& url,
-                                          base::Value const* json) {
+inline std::unique_ptr<Response> PostJson(const std::string& url,
+                                          const base::Value* json) {
   return PostJson(url, json, HeaderList());
 }
 
@@ -123,12 +123,12 @@
 // and additional information (such as returned HTTP headers) can be obtained
 // from the returned Response object. If a JSON response is expected,
 // use ParseJsonResponse() method on the returned Response object.
-std::unique_ptr<Response> PatchJson(std::string const& url,
-                                    base::Value const* json,
-                                    HeaderList const& headers);
+std::unique_ptr<Response> PatchJson(const std::string& url,
+                                    const base::Value* json,
+                                    const HeaderList& headers);
 
-inline std::unique_ptr<Response> PatchJson(std::string const& url,
-                                           base::Value const* json) {
+inline std::unique_ptr<Response> PatchJson(const std::string& url,
+                                           const base::Value* json) {
   return PatchJson(url, json, HeaderList());
 }
 
@@ -136,7 +136,7 @@
 // Returns null if failed. Optional |error_message| can be passed in to
 // get the extended error information as to why the parse failed.
 std::unique_ptr<base::DictionaryValue> ParseJsonResponse(
-    Response const* response, int* status_code, std::string* error_message);
+    const Response* response, int* status_code, std::string* error_message);
 
 } // namespace http
 } // namespace chromeos