diff --git a/buffet/buffet_client.cc b/buffet/buffet_client.cc
old mode 100755
new mode 100644
diff --git a/buffet/data_encoding.cc b/buffet/data_encoding.cc
index 1c0013a..0049193 100644
--- a/buffet/data_encoding.cc
+++ b/buffet/data_encoding.cc
@@ -29,7 +29,7 @@
 namespace chromeos {
 namespace data_encoding {
 
-std::string UrlEncode(char const* data, bool encodeSpaceAsPlus) {
+std::string UrlEncode(const char* data, bool encodeSpaceAsPlus) {
   std::string result;
 
   while(*data) {
@@ -53,7 +53,7 @@
   return result;
 }
 
-std::string UrlDecode(char const* data) {
+std::string UrlDecode(const char* data) {
   std::string result;
   while (*data) {
     char c = *data++;
@@ -72,11 +72,11 @@
   return result;
 }
 
-std::string WebParamsEncode(WebParamList const& params,
+std::string WebParamsEncode(const WebParamList& params,
                             bool encodeSpaceAsPlus) {
   std::vector<std::string> pairs;
   pairs.reserve(params.size());
-  for (auto const& p : params) {
+  for (auto&& p : params) {
     std::string key = UrlEncode(p.first.c_str(), encodeSpaceAsPlus);
     std::string value = UrlEncode(p.second.c_str(), encodeSpaceAsPlus);
     pairs.push_back(string_utils::Join('=', key, value));
@@ -85,7 +85,7 @@
   return string_utils::Join('&', pairs);
 }
 
-WebParamList WebParamsDecode(std::string const& data) {
+WebParamList WebParamsDecode(const std::string& data) {
   WebParamList result;
   std::vector<std::string> params = string_utils::Split(data, '&');
   for (auto p : params) {
diff --git a/buffet/data_encoding.h b/buffet/data_encoding.h
index 7a4eda0..b7223bd 100644
--- a/buffet/data_encoding.h
+++ b/buffet/data_encoding.h
@@ -16,28 +16,28 @@
 // Encode/escape string to be used in the query portion of a URL.
 // If |encodeSpaceAsPlus| is set to true, spaces are encoded as '+' instead
 // of "%20"
-std::string UrlEncode(char const* data, bool encodeSpaceAsPlus);
+std::string UrlEncode(const char* data, bool encodeSpaceAsPlus);
 
-inline std::string UrlEncode(char const* data) {
+inline std::string UrlEncode(const char* data) {
   return UrlEncode(data, true);
 }
 
 // Decodes/unescapes a URL. Replaces all %XX sequences with actual characters.
 // Also replaces '+' with spaces.
-std::string UrlDecode(char const* data);
+std::string UrlDecode(const char* data);
 
 // Converts a list of key-value pairs into a string compatible with
 // 'application/x-www-form-urlencoded' content encoding.
-std::string WebParamsEncode(WebParamList const& params, bool encodeSpaceAsPlus);
+std::string WebParamsEncode(const WebParamList& params, bool encodeSpaceAsPlus);
 
-inline std::string WebParamsEncode(WebParamList const& params) {
+inline std::string WebParamsEncode(const WebParamList& params) {
   return WebParamsEncode(params, true);
 }
 
 // Parses a string of '&'-delimited key-value pairs (separated by '=') and
 // encoded in a way compatible with 'application/x-www-form-urlencoded'
 // content encoding.
-WebParamList WebParamsDecode(std::string const& data);
+WebParamList WebParamsDecode(const std::string& data);
 
 } // namespace data_encoding
 } // namespace chromeos
diff --git a/buffet/http_request.cc b/buffet/http_request.cc
index 3e9ec71..db1ecb9 100644
--- a/buffet/http_request.cc
+++ b/buffet/http_request.cc
@@ -98,11 +98,11 @@
 //**************************************************************************
 //********************** Request Class **********************
 //**************************************************************************
-Request::Request(std::string const& url, char const* method) :
+Request::Request(const std::string& url, const char* method) :
   transport_(new curl::Transport(url, method)) {
 }
 
-Request::Request(std::string const& url) :
+Request::Request(const std::string& url) :
   transport_(new curl::Transport(url, nullptr)) {
 }
 
@@ -133,7 +133,7 @@
   return std::unique_ptr<Response>();
 }
 
-void Request::SetAccept(char const* accept_mime_types) {
+void Request::SetAccept(const char* accept_mime_types) {
   if (transport_)
     transport_->SetAccept(accept_mime_types);
 }
@@ -146,7 +146,7 @@
   return transport_ ? transport_->GetRequestURL() : std::string();
 }
 
-void Request::SetContentType(char const* contentType) {
+void Request::SetContentType(const char* contentType) {
   if (transport_)
     transport_->SetContentType(contentType);
 }
@@ -155,21 +155,21 @@
   return transport_ ? transport_->GetContentType() : std::string();
 }
 
-void Request::AddHeader(char const* header, char const* value) {
+void Request::AddHeader(const char* header, const char* value) {
   if (transport_)
     transport_->AddHeader(header, value);
 }
 
-void Request::AddHeaders(HeaderList const& headers) {
+void Request::AddHeaders(const HeaderList& headers) {
   for (auto&& pair : headers)
     AddHeader(pair.first.c_str(), pair.second.c_str());
 }
 
-bool Request::AddRequestBody(void const* data, size_t size) {
+bool Request::AddRequestBody(const void* data, size_t size) {
   return transport_ && transport_->AddRequestBody(data, size);
 }
 
-void Request::SetMethod(char const* method) {
+void Request::SetMethod(const char* method) {
   if (transport_)
     transport_->SetMethod(method);
 }
@@ -178,7 +178,7 @@
   return transport_ ? transport_->GetMethod() : std::string();
 }
 
-void Request::SetReferer(char const* referer) {
+void Request::SetReferer(const char* referer) {
   if (transport_)
     transport_->SetReferer(referer);
 }
@@ -187,7 +187,7 @@
   return transport_ ? transport_->GetReferer() : std::string();
 }
 
-void Request::SetUserAgent(char const* user_agent) {
+void Request::SetUserAgent(const char* user_agent) {
   if (transport_)
     transport_->SetUserAgent(user_agent);
 }
@@ -249,14 +249,14 @@
 std::string Response::GetDataAsString() const {
   if (transport_) {
     auto data = transport_->GetResponseData();
-    char const* data_buf = reinterpret_cast<char const*>(data.data());
+    const char* data_buf = reinterpret_cast<const char*>(data.data());
     return std::string(data_buf, data_buf + data.size());
   }
 
   return std::string();
 }
 
-std::string Response::GetHeader(char const* header_name) const {
+std::string Response::GetHeader(const char* header_name) const {
   if (transport_)
     return transport_->GetResponseHeader(header_name);
 
diff --git a/buffet/http_request.h b/buffet/http_request.h
index fcdc9bd..185c84e 100644
--- a/buffet/http_request.h
+++ b/buffet/http_request.h
@@ -210,30 +210,30 @@
   // to send the request to. Optional |method| is the HTTP request verb. If
   // omitted, "GET" is used.
   // Uses the default libcurl-based implementation of TransportInterface
-  Request(std::string const& url, char const* method);
-  Request(std::string const& url);
+  Request(const std::string& url, const char* method);
+  Request(const std::string& url);
 
   // Custom constructor that allows non-default implementations
   // of TransportInterface to be used.
   Request(std::shared_ptr<TransportInterface> transport);
 
   // Gets/Sets "Accept:" header value. The default value is "*/*" if not set.
-  void SetAccept(char const* accept_mime_types);
+  void SetAccept(const char* accept_mime_types);
   std::string GetAccept() const;
 
   // Gets/Sets "Content-Type:" header value
-  void SetContentType(char const* content_type);
+  void SetContentType(const char* content_type);
   std::string GetContentType() const;
 
   // Adds additional HTTP request header
-  void AddHeader(char const* header, char const* value);
-  void AddHeaders(HeaderList const& headers);
+  void AddHeader(const char* header, const char* value);
+  void AddHeaders(const HeaderList& headers);
 
   // Removes HTTP request header
-  void RemoveHeader(char const* header);
+  void RemoveHeader(const char* header);
 
   // Adds a request body. This is not to be used with GET method
-  bool AddRequestBody(void const* data, size_t size);
+  bool AddRequestBody(const void* data, size_t size);
 
   // 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
@@ -248,18 +248,18 @@
   void AddRange(uint64_t from_byte, uint64_t to_byte);
 
   // Gets/Sets an HTTP request verb to be used with request
-  void SetMethod(char const* method);
+  void SetMethod(const char* method);
   std::string GetMethod() const;
 
   // Returns the request URL
   std::string GetRequestURL() const;
 
   // Gets/Sets a request referer URL (sent as "Referer:" request header).
-  void SetReferer(char const* referer);
+  void SetReferer(const char* referer);
   std::string GetReferer() const;
 
   // Gets/Sets a user agent string (sent as "User-Agent:" request header).
-  void SetUserAgent(char const* user_agent);
+  void SetUserAgent(const char* user_agent);
   std::string GetUserAgent() const;
 
   // Sends the request to the server and returns the response object.
@@ -305,7 +305,7 @@
   std::string GetDataAsString() const;
 
   // Returns a value of a given response HTTP header.
-  std::string GetHeader(char const* header_name) const;
+  std::string GetHeader(const char* header_name) const;
 
  private:
   std::shared_ptr<TransportInterface> transport_;
diff --git a/buffet/http_transport_curl.cc b/buffet/http_transport_curl.cc
index 6cb9c16..2a9c228 100644
--- a/buffet/http_transport_curl.cc
+++ b/buffet/http_transport_curl.cc
@@ -52,7 +52,7 @@
 }
 #endif
 
-Transport::Transport(std::string const& url, char const* method) :
+Transport::Transport(const std::string& url, const char* method) :
     request_url_(url),
     method_(method ? method : request_type::kGet) {
   stage_ = Stage::initialized;
@@ -106,15 +106,15 @@
   return headers;
 }
 
-void Transport::AddHeader(char const* header, char const* value) {
+void Transport::AddHeader(const char* header, const char* value) {
   headers_[header] = value;
 }
 
-void Transport::RemoveHeader(char const* header) {
+void Transport::RemoveHeader(const char* header) {
   AddHeader(header, "");
 }
 
-bool Transport::AddRequestBody(void const* data, size_t size) {
+bool Transport::AddRequestBody(const void* data, size_t size) {
   if (size == 0)
     return true;
 
@@ -123,7 +123,7 @@
     return false;
   }
 
-  unsigned char const* data_ptr = reinterpret_cast<unsigned char const*>(data);
+  const unsigned char* data_ptr = reinterpret_cast<const unsigned char*>(data);
   request_data_.insert(request_data_.end(), data_ptr, data_ptr + size);
   return true;
 }
@@ -187,8 +187,8 @@
 
   VLOG_IF(2, !request_data_.empty()) << "Request data ("
       << request_data_.size() << "): "
-      << std::string(reinterpret_cast<char const*>(request_data_.data()),
-      request_data_.size());
+      << std::string(reinterpret_cast<const char*>(request_data_.data()),
+                                                   request_data_.size());
 
   // Setup HTTP response data.
   if (method_ != request_type::kHead) {
@@ -234,7 +234,7 @@
     LOG(INFO) << "Response: " << GetResponseStatusCode() << " ("
               << GetResponseStatusText() << ")";
     VLOG(2) << "Response data (" << response_data_.size() << "): "
-        << std::string(reinterpret_cast<char const*>(response_data_.data()),
+        << std::string(reinterpret_cast<const char*>(response_data_.data()),
                        response_data_.size());
   }
   return (ret == CURLE_OK);
@@ -248,12 +248,12 @@
   return status_code;
 }
 
-std::string Transport::GetResponseHeader(char const* headerName) const {
+std::string Transport::GetResponseHeader(const char* headerName) const {
   auto p = headers_.find(headerName);
   return p != headers_.end() ? p->second : std::string();
 }
 
-std::vector<unsigned char> const& Transport::GetResponseData() const {
+const std::vector<unsigned char>& Transport::GetResponseData() const {
   return response_data_;
 }
 
diff --git a/buffet/http_transport_curl.h b/buffet/http_transport_curl.h
index 5ef533e..9778b94 100644
--- a/buffet/http_transport_curl.h
+++ b/buffet/http_transport_curl.h
@@ -26,7 +26,7 @@
   // schema, host address, resource path as well as optional query parameters
   // and/or user name/password. |method| is one of HTTP request verbs such as
   // "GET", "POST", etc. If nullptr is specified, "GET" is assumed.
-  Transport(std::string const& url, char const* method);
+  Transport(const std::string& url, const char* method);
   ~Transport();
 
   // Returns the current request/response stage.
@@ -37,7 +37,7 @@
   virtual void AddRange(uint64_t from_byte, uint64_t to_byte) override;
 
   // Implementation of Request::SetAccept/Request::GetAccept.
-  virtual void SetAccept(char const* acceptMimeTypes) override {
+  virtual void SetAccept(const char* acceptMimeTypes) override {
     accept_ = acceptMimeTypes;
   }
   virtual std::string GetAccept() const override;
@@ -46,30 +46,30 @@
   virtual std::string GetRequestURL() const override { return request_url_; }
 
   // Implementation of Request::SetContentType/Request::GetContentType.
-  virtual void SetContentType(char const* content_type) override {
+  virtual void SetContentType(const char* content_type) override {
     content_type_ = content_type;
   }
   virtual std::string GetContentType() const override { return content_type_; }
 
   // Implementation of Request::AddHeader.
-  virtual void AddHeader(char const* header, char const* value) override;
+  virtual void AddHeader(const char* header, const char* value) override;
 
   // Implementation of Request::RemoveHeader.
-  virtual void RemoveHeader(char const* header) override;
+  virtual void RemoveHeader(const char* header) override;
 
   // Implementation of Request::AddRequestBody.
-  virtual bool AddRequestBody(void const* data, size_t size) override;
+  virtual bool AddRequestBody(const void* data, size_t size) override;
 
   // Implementation of Request::SetMethod/Request::GetMethod.
-  virtual void SetMethod(char const* method) override { method_ = method; }
+  virtual void SetMethod(const char* method) override { method_ = method; }
   virtual std::string GetMethod() const override { return method_; }
 
   // Implementation of Request::SetReferer/Request::GetReferer.
-  virtual void SetReferer(char const* referer) override { referer_ = referer; }
+  virtual void SetReferer(const char* referer) override { referer_ = referer; }
   virtual std::string GetReferer() const override { return referer_; }
 
   // Implementation of Request::SetUserAgent/Request::GetUserAgent.
-  virtual void SetUserAgent(char const* user_agent) override {
+  virtual void SetUserAgent(const char* user_agent) override {
     user_agent_ = user_agent;
   }
   virtual std::string GetUserAgent() const override { return user_agent_; }
@@ -86,10 +86,10 @@
   }
 
   // Implementation of Response::GetHeader.
-  virtual std::string GetResponseHeader(char const* header_name) const override;
+  virtual std::string GetResponseHeader(const char* header_name) const override;
 
   // Implementation of Response::GetData.
-  virtual std::vector<unsigned char> const& GetResponseData() const override;
+  virtual const std::vector<unsigned char>& GetResponseData() const override;
 
   // Implementation of Response::GetErrorMessage.
   virtual std::string GetErrorMessage() const override { return error_; }
diff --git a/buffet/http_utils.cc b/buffet/http_utils.cc
index 9db6b1c..7529796 100644
--- a/buffet/http_utils.cc
+++ b/buffet/http_utils.cc
@@ -16,25 +16,25 @@
 namespace chromeos {
 namespace http {
 
-std::unique_ptr<Response> Get(std::string const& url) {
+std::unique_ptr<Response> Get(const std::string& url) {
   Request request(url);
   return request.GetResponse();
 }
 
-std::string GetAsString(std::string const& url) {
+std::string GetAsString(const std::string& url) {
   auto resp = Get(url);
   return resp ? resp->GetDataAsString() : std::string();
 }
 
-std::unique_ptr<Response> Head(std::string const& url) {
+std::unique_ptr<Response> Head(const std::string& url) {
   Request request(url, request_type::kHead);
   return request.GetResponse();
 }
 
-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) {
   if (mime_type == nullptr) {
     mime_type = chromeos::mime::application::kWwwFormUrlEncoded;
   }
@@ -42,12 +42,12 @@
   return PostBinary(url, data, strlen(data), mime_type, headers);
 }
 
-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) {
   Request request(url, method);
   request.AddHeaders(headers);
   if (data_size > 0) {
@@ -60,25 +60,25 @@
   return request.GetResponse();
 }
 
-std::unique_ptr<Response> PostBinary(std::string const& url, void const* data,
-                                     size_t data_size, char const* mime_type,
-                                     HeaderList const& headers) {
+std::unique_ptr<Response> PostBinary(const std::string & url, const void* data,
+                                     size_t data_size, const char* mime_type,
+                                     const HeaderList& headers) {
   return SendRequest(request_type::kPost, url,
                      data, data_size, mime_type, headers);
 }
 
-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) {
   std::string encoded_data = chromeos::data_encoding::WebParamsEncode(data);
   return PostBinary(url, encoded_data.c_str(), encoded_data.size(),
                     chromeos::mime::application::kWwwFormUrlEncoded, headers);
 }
 
 
-std::unique_ptr<Response> PostJson(std::string const& url,
-                                   base::Value const* json,
-                                   HeaderList const& headers) {
+std::unique_ptr<Response> PostJson(const std::string& url,
+                                   const base::Value* json,
+                                   const HeaderList& headers) {
   std::string data;
   if (json)
     base::JSONWriter::Write(json, &data);
@@ -86,9 +86,9 @@
                     mime::application::kJson, headers);
 }
 
-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) {
   std::string data;
   if (json)
     base::JSONWriter::Write(json, &data);
@@ -97,7 +97,7 @@
 }
 
 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) {
   std::unique_ptr<base::DictionaryValue> dict;
   if (response) {
     if (status_code)
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
diff --git a/buffet/map_utils.h b/buffet/map_utils.h
index 676c558..c67fa3e 100644
--- a/buffet/map_utils.h
+++ b/buffet/map_utils.h
@@ -12,7 +12,7 @@
 
 // Given an STL map returns a vector containing all keys from the map
 template<typename T>
-std::vector<typename T::key_type> GetMapKeys(T const& map) {
+std::vector<typename T::key_type> GetMapKeys(const T& map) {
   std::vector<typename T::key_type> keys;
   keys.reserve(map.size());
   for (auto&& pair : map)
@@ -22,7 +22,7 @@
 
 // Given an STL map returns a vector containing all values from the map
 template<typename T>
-std::vector<typename T::mapped_type> GetMapValues(T const& map) {
+std::vector<typename T::mapped_type> GetMapValues(const T& map) {
   std::vector<typename T::mapped_type> values;
   values.reserve(map.size());
   for (auto&& pair : map)
@@ -33,7 +33,7 @@
 // Given an STL map returns a vector of key-value pairs from the map
 template<typename T>
 std::vector<std::pair<typename T::key_type,
-                      typename T::mapped_type>> MapToVector(T const& map) {
+                      typename T::mapped_type>> MapToVector(const T& map) {
   std::vector<std::pair<typename T::key_type, typename T::mapped_type>> vector;
   vector.reserve(map.size());
   for (auto&& pair : map)
diff --git a/buffet/mime_utils.cc b/buffet/mime_utils.cc
index a4f29ca..c35d3c0 100644
--- a/buffet/mime_utils.cc
+++ b/buffet/mime_utils.cc
@@ -42,7 +42,7 @@
 //***************************************************************************
 //**************************** Utility Functions ****************************
 //***************************************************************************
-static std::string EncodeParam(std::string const& param) {
+static std::string EncodeParam(const std::string& param) {
   // If the string contains one of "tspecials" characters as
   // specified in RFC 1521, enclose it in quotes.
   if (param.find_first_of("()<>@,;:\\\"/[]?=") != std::string::npos) {
@@ -51,7 +51,7 @@
   return param;
 }
 
-static std::string DecodeParam(std::string const& param) {
+static std::string DecodeParam(const std::string& param) {
   if (param.size() > 1 && param.front() == '"' && param.back() == '"') {
     return param.substr(1, param.size() - 2);
   }
@@ -62,7 +62,7 @@
 //******************** Main MIME manipulation functions *********************
 //***************************************************************************
 
-bool mime::Split(std::string const& mime_string,
+bool mime::Split(const std::string& mime_string,
                  std::string* type, std::string* subtype,
                  mime::Parameters* parameters) {
   std::vector<std::string> parts = string_utils::Split(mime_string, ';');
@@ -84,7 +84,7 @@
   return true;
 }
 
-bool mime::Split(std::string const& mime_string,
+bool mime::Split(const std::string& mime_string,
                  std::string* type, std::string* subtype) {
   std::string mime = mime::RemoveParameters(mime_string);
   auto types = string_utils::SplitAtFirst(mime, '/');
@@ -98,28 +98,28 @@
   return !types.first.empty() && !types.second.empty();
 }
 
-std::string mime::Combine(std::string const& type, std::string const& subtype,
-                          mime::Parameters const& parameters) {
+std::string mime::Combine(const std::string& type, const std::string& subtype,
+                          const mime::Parameters& parameters) {
   std::vector<std::string> parts;
   parts.push_back(string_utils::Join('/', type, subtype));
-  for (std::pair<std::string, std::string> const& pair : parameters) {
+  for (auto&& pair : parameters) {
     parts.push_back(string_utils::Join('=', pair.first,
                                        EncodeParam(pair.second)));
   }
   return string_utils::Join("; ", parts);
 }
 
-std::string mime::GetType(std::string const& mime_string) {
+std::string mime::GetType(const std::string& mime_string) {
   std::string mime = mime::RemoveParameters(mime_string);
   return string_utils::SplitAtFirst(mime, '/').first;
 }
 
-std::string mime::GetSubtype(std::string const& mime_string) {
+std::string mime::GetSubtype(const std::string& mime_string) {
   std::string mime = mime::RemoveParameters(mime_string);
   return string_utils::SplitAtFirst(mime, '/').second;
 }
 
-mime::Parameters mime::GetParameters(std::string const& mime_string) {
+mime::Parameters mime::GetParameters(const std::string& mime_string) {
   std::string type;
   std::string subtype;
   mime::Parameters parameters;
@@ -130,23 +130,23 @@
   return mime::Parameters();
 }
 
-std::string mime::RemoveParameters(std::string const& mime_string) {
+std::string mime::RemoveParameters(const std::string& mime_string) {
   return string_utils::SplitAtFirst(mime_string, ';').first;
 }
 
-std::string mime::AppendParameter(std::string const& mime_string,
-                                  std::string const& paramName,
-                                  std::string const& paramValue) {
+std::string mime::AppendParameter(const std::string& mime_string,
+                                  const std::string& paramName,
+                                  const std::string& paramValue) {
   std::string mime(mime_string);
   mime += "; ";
   mime += string_utils::Join('=', paramName, EncodeParam(paramValue));
   return mime;
 }
 
-std::string mime::GetParameterValue(std::string const& mime_string,
-                                    std::string const& paramName) {
+std::string mime::GetParameterValue(const std::string& mime_string,
+                                    const std::string& paramName) {
   mime::Parameters params = mime::GetParameters(mime_string);
-  for(auto const& pair : params) {
+  for(auto&& pair : params) {
     if (base::strcasecmp(pair.first.c_str(), paramName.c_str()) == 0)
       return pair.second;
   }
diff --git a/buffet/mime_utils.h b/buffet/mime_utils.h
index e1dc7da..31a7687 100644
--- a/buffet/mime_utils.h
+++ b/buffet/mime_utils.h
@@ -56,45 +56,45 @@
 // Combine a MIME type, subtype and parameters into a MIME string.
 // e.g. Combine("text", "plain", {{"charset", "utf-8"}}) will give:
 //      "text/plain; charset=utf-8"
-std::string Combine(std::string const& type, std::string const& subtype,
-                    Parameters const& parameters = Parameters());
+std::string Combine(const std::string& type, const std::string& subtype,
+                    const Parameters& parameters = {});
 
 // Splits a MIME string into type and subtype.
 // "text/plain;charset=utf-8" => ("text", "plain")
-bool Split(std::string const& mime_string,
+bool Split(const std::string& mime_string,
            std::string* type, std::string* subtype);
 
 // Splits a MIME string into type, subtype, and parameters.
 // "text/plain;charset=utf-8" => ("text", "plain", {{"charset","utf-8"}})
-bool Split(std::string const& mime_string,
+bool Split(const std::string& mime_string,
            std::string* type, std::string* subtype, Parameters* parameters);
 
 // Returns the MIME type from MIME string.
 // "text/plain;charset=utf-8" => "text"
-std::string GetType(std::string const& mime_string);
+std::string GetType(const std::string& mime_string);
 
 // Returns the MIME sub-type from MIME string.
 // "text/plain;charset=utf-8" => "plain"
-std::string GetSubtype(std::string const& mime_string);
+std::string GetSubtype(const std::string& mime_string);
 
 // Returns the MIME parameters from MIME string.
 // "text/plain;charset=utf-8" => {{"charset","utf-8"}}
-Parameters GetParameters(std::string const& mime_string);
+Parameters GetParameters(const std::string& mime_string);
 
 // Removes parameters from a MIME string
 // "text/plain;charset=utf-8" => "text/plain"
-std::string RemoveParameters(std::string const& mime_string);
+std::string RemoveParameters(const std::string& mime_string);
 
 // Appends a parameter to a MIME string.
 // "text/plain" => "text/plain; charset=utf-8"
-std::string AppendParameter(std::string const& mime_string,
-                            std::string const& paramName,
-                            std::string const& paramValue);
+std::string AppendParameter(const std::string& mime_string,
+                            const std::string& paramName,
+                            const std::string& paramValue);
 
 // Returns the value of a parameter on a MIME string (empty string if missing).
 // ("text/plain;charset=utf-8","charset") => "utf-8"
-std::string GetParameterValue(std::string const& mime_string,
-                              std::string const& paramName);
+std::string GetParameterValue(const std::string& mime_string,
+                              const std::string& paramName);
 
 } // namespace mime
 } // namespace chromeos
diff --git a/buffet/string_utils.cc b/buffet/string_utils.cc
index 49a7d84..c5d06eb 100644
--- a/buffet/string_utils.cc
+++ b/buffet/string_utils.cc
@@ -11,7 +11,7 @@
 namespace chromeos {
 namespace string_utils {
 
-std::vector<std::string> Split(std::string const& str,
+std::vector<std::string> Split(const std::string& str,
                                char delimiter,
                                bool trim_whitespaces,
                                bool purge_empty_strings) {
@@ -19,9 +19,9 @@
   if (delimiter == 0)
     return tokens;
 
-  char const* sz = str.c_str();
+  const char* sz = str.c_str();
   if (sz) {
-    char const* szNext = strchr(sz, delimiter);
+    const char* szNext = strchr(sz, delimiter);
     while (szNext) {
       if (szNext != sz || !purge_empty_strings)
         tokens.emplace_back(sz, szNext - sz);
@@ -40,15 +40,15 @@
   return tokens;
 }
 
-std::pair<std::string, std::string> SplitAtFirst(std::string const& str,
+std::pair<std::string, std::string> SplitAtFirst(const std::string& str,
                                                  char delimiter,
                                                  bool trim_whitespaces) {
   std::pair<std::string, std::string> pair;
   if (delimiter == 0)
     return pair;
 
-  char const* sz = str.c_str();
-  char const* szNext = strchr(sz, delimiter);
+  const char* sz = str.c_str();
+  const char* szNext = strchr(sz, delimiter);
   if (szNext) {
     pair.first = std::string(sz, szNext);
     pair.second = std::string(szNext + 1);
@@ -64,22 +64,22 @@
   return pair;
 }
 
-std::string Join(char delimiter, std::vector<std::string> const& strings) {
+std::string Join(char delimiter, const std::vector<std::string>& strings) {
   return JoinString(strings, delimiter);
 }
 
-std::string Join(std::string const& delimiter,
-                 std::vector<std::string> const& strings) {
+std::string Join(const std::string& delimiter,
+                 const std::vector<std::string>& strings) {
   return JoinString(strings, delimiter);
 }
 
 std::string Join(char delimiter,
-                 std::string const& str1, std::string const& str2) {
+                 const std::string& str1, const std::string& str2) {
   return str1 + delimiter + str2;
 }
 
-std::string Join(std::string const& delimiter,
-                 std::string const& str1, std::string const& str2) {
+std::string Join(const std::string& delimiter,
+                 const std::string& str1, const std::string& str2) {
   return str1 + delimiter + str2;
 }
 
diff --git a/buffet/string_utils.h b/buffet/string_utils.h
index bad62f3..3fad204 100644
--- a/buffet/string_utils.h
+++ b/buffet/string_utils.h
@@ -15,25 +15,25 @@
 // of original elements of the list.
 // By default, empty elements from the original string are omitted and
 // each element has all whitespaces trimmed off.
-std::vector<std::string> Split(std::string const& str,
+std::vector<std::string> Split(const std::string& str,
                                char delimiter,
                                bool trim_whitespaces = true,
                                bool purge_empty_strings = true);
 
 // Splits the string into two pieces at the first position of the specified
 // delimiter. By default, each part has all whitespaces trimmed off.
-std::pair<std::string, std::string> SplitAtFirst(std::string const& str,
+std::pair<std::string, std::string> SplitAtFirst(const std::string& str,
                                                  char delimiter,
                                                  bool trim_whitespaces = true);
 
 // Joins an array of strings into a single string separated by |delimiter|.
-std::string Join(char delimiter, std::vector<std::string> const& strings);
-std::string Join(std::string const& delimiter,
-                 std::vector<std::string> const& strings);
+std::string Join(char delimiter, const std::vector<std::string>& strings);
+std::string Join(const std::string& delimiter,
+                 const std::vector<std::string>& strings);
 std::string Join(char delimiter,
-                 std::string const& str1, std::string const& str2);
-std::string Join(std::string const& delimiter,
-                 std::string const& str1, std::string const& str2);
+                 const std::string& str1, const std::string& str2);
+std::string Join(const std::string& delimiter,
+                 const std::string& str1, const std::string& str2);
 
 } // namespace string_utils
 } // namespace chromeos
diff --git a/buffet/transport_interface.h b/buffet/transport_interface.h
index 0f9363b..e833239 100644
--- a/buffet/transport_interface.h
+++ b/buffet/transport_interface.h
@@ -37,26 +37,26 @@
   virtual void AddRange(int64_t bytes) = 0;
   virtual void AddRange(uint64_t from_byte, uint64_t to_byte) = 0;
 
-  virtual void SetAccept(char const* accept_mime_types) = 0;
+  virtual void SetAccept(const char* accept_mime_types) = 0;
   virtual std::string GetAccept() const = 0;
 
   virtual std::string GetRequestURL() const = 0;
 
-  virtual void SetContentType(char const* content_type) = 0;
+  virtual void SetContentType(const char* content_type) = 0;
   virtual std::string GetContentType() const = 0;
 
-  virtual void AddHeader(char const* header, char const* value) = 0;
-  virtual void RemoveHeader(char const* header) = 0;
+  virtual void AddHeader(const char* header, const char* value) = 0;
+  virtual void RemoveHeader(const char* header) = 0;
 
-  virtual bool AddRequestBody(void const* data, size_t size) = 0;
+  virtual bool AddRequestBody(const void* data, size_t size) = 0;
 
-  virtual void SetMethod(char const* method) = 0;
+  virtual void SetMethod(const char* method) = 0;
   virtual std::string GetMethod() const = 0;
 
-  virtual void SetReferer(char const* referer) = 0;
+  virtual void SetReferer(const char* referer) = 0;
   virtual std::string GetReferer() const = 0;
 
-  virtual void SetUserAgent(char const* user_agent) = 0;
+  virtual void SetUserAgent(const char* user_agent) = 0;
   virtual std::string GetUserAgent() const = 0;
 
   virtual bool Perform() = 0;
@@ -64,8 +64,8 @@
   virtual int GetResponseStatusCode() const = 0;
   virtual std::string GetResponseStatusText() const = 0;
 
-  virtual std::string GetResponseHeader(char const* header_name) const = 0;
-  virtual std::vector<unsigned char> const& GetResponseData() const = 0;
+  virtual std::string GetResponseHeader(const char* header_name) const = 0;
+  virtual const std::vector<unsigned char>& GetResponseData() const = 0;
   virtual std::string GetErrorMessage() const = 0;
 
   virtual void Close() = 0;