Clang format slam.

net/http/http_request_headers.cc

 // Copyright (c) 2012 The Chromium 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 "net/http/http_request_headers.h"
 
 #include "base/logging.h"
 #include "base/strings/string_split.h"
 #include "base/strings/string_util.h"
 #include "base/strings/stringprintf.h"
@@ skipping 23 matching lines @@
 const char HttpRequestHeaders::kProxyConnection[] = "Proxy-Connection";
 const char HttpRequestHeaders::kRange[] = "Range";
 const char HttpRequestHeaders::kReferer[] = "Referer";
 const char HttpRequestHeaders::kUserAgent[] = "User-Agent";
 const char HttpRequestHeaders::kTransferEncoding[] = "Transfer-Encoding";
 
 HttpRequestHeaders::HeaderKeyValuePair::HeaderKeyValuePair() {
 }
 
 HttpRequestHeaders::HeaderKeyValuePair::HeaderKeyValuePair(
-    const base::StringPiece& key, const base::StringPiece& value)
+    const base::StringPiece& key,
+    const base::StringPiece& value)
     : key(key.data(), key.size()), value(value.data(), value.size()) {
 }
 
-
 HttpRequestHeaders::Iterator::Iterator(const HttpRequestHeaders& headers)
     : started_(false),
       curr_(headers.headers_.begin()),
-      end_(headers.headers_.end()) {}
+      end_(headers.headers_.end()) {
+}
 
-HttpRequestHeaders::Iterator::~Iterator() {}
+HttpRequestHeaders::Iterator::~Iterator() {
+}
 
 bool HttpRequestHeaders::Iterator::GetNext() {
   if (!started_) {
     started_ = true;
     return curr_ != end_;
   }
 
   if (curr_ == end_)
     return false;
 
   ++curr_;
   return curr_ != end_;
 }
 
-HttpRequestHeaders::HttpRequestHeaders() {}
-HttpRequestHeaders::~HttpRequestHeaders() {}
+HttpRequestHeaders::HttpRequestHeaders() {
+}
+HttpRequestHeaders::~HttpRequestHeaders() {
+}
 
 bool HttpRequestHeaders::GetHeader(const base::StringPiece& key,
                                    std::string* out) const {
   HeaderVector::const_iterator it = FindHeader(key);
   if (it == headers_.end())
     return false;
   out->assign(it->value);
   return true;
 }
 
@@ skipping 18 matching lines @@
 }
 
 void HttpRequestHeaders::RemoveHeader(const base::StringPiece& key) {
   HeaderVector::iterator it = FindHeader(key);
   if (it != headers_.end())
     headers_.erase(it);
 }
 
 void HttpRequestHeaders::AddHeaderFromString(
     const base::StringPiece& header_line) {
-  DCHECK_EQ(std::string::npos, header_line.find("\r\n"))
-      << "\"" << header_line << "\" contains CRLF.";
+  DCHECK_EQ(std::string::npos, header_line.find("\r\n")) << "\"" << header_line
+                                                         << "\" contains CRLF.";
 
   const std::string::size_type key_end_index = header_line.find(":");
   if (key_end_index == std::string::npos) {
     LOG(DFATAL) << "\"" << header_line << "\" is missing colon delimiter.";
     return;
   }
 
   if (key_end_index == 0) {
     LOG(DFATAL) << "\"" << header_line << "\" is missing header key.";
     return;
   }
 
   const base::StringPiece header_key(header_line.data(), key_end_index);
 
   const std::string::size_type value_index = key_end_index + 1;
 
   if (value_index < header_line.size()) {
     std::string header_value(header_line.data() + value_index,
                              header_line.size() - value_index);
-    std::string::const_iterator header_value_begin =
-        header_value.begin();
-    std::string::const_iterator header_value_end =
-        header_value.end();
+    std::string::const_iterator header_value_begin = header_value.begin();
+    std::string::const_iterator header_value_end = header_value.end();
     HttpUtil::TrimLWS(&header_value_begin, &header_value_end);
 
     if (header_value_begin == header_value_end) {
       // Value was all LWS.
       SetHeader(header_key, "");
     } else {
       SetHeader(header_key,
                 base::StringPiece(&*header_value_begin,
                                   header_value_end - header_value_begin));
     }
   } else if (value_index == header_line.size()) {
     SetHeader(header_key, "");
   } else {
     NOTREACHED();
   }
 }
 
 void HttpRequestHeaders::AddHeadersFromString(
     const base::StringPiece& headers) {
   // TODO(willchan): Consider adding more StringPiece support in string_util.h
   // to eliminate copies.
   std::vector<std::string> header_line_vector;
-  base::SplitStringUsingSubstr(headers.as_string(), "\r\n",
-                               &header_line_vector);
+  base::SplitStringUsingSubstr(
+      headers.as_string(), "\r\n", &header_line_vector);
   for (std::vector<std::string>::const_iterator it = header_line_vector.begin();
-       it != header_line_vector.end(); ++it) {
+       it != header_line_vector.end();
+       ++it) {
     if (!it->empty())
       AddHeaderFromString(*it);
   }
 }
 
 void HttpRequestHeaders::MergeFrom(const HttpRequestHeaders& other) {
   for (HeaderVector::const_iterator it = other.headers_.begin();
-       it != other.headers_.end(); ++it ) {
+       it != other.headers_.end();
+       ++it) {
     SetHeader(it->key, it->value);
   }
 }
 
 std::string HttpRequestHeaders::ToString() const {
   std::string output;
-  for (HeaderVector::const_iterator it = headers_.begin();
-       it != headers_.end(); ++it) {
+  for (HeaderVector::const_iterator it = headers_.begin(); it != headers_.end();
+       ++it) {
     if (!it->value.empty()) {
-      base::StringAppendF(&output, "%s: %s\r\n",
-                          it->key.c_str(), it->value.c_str());
+      base::StringAppendF(
+          &output, "%s: %s\r\n", it->key.c_str(), it->value.c_str());
     } else {
       base::StringAppendF(&output, "%s:\r\n", it->key.c_str());
     }
   }
   output.append("\r\n");
   return output;
 }
 
 base::Value* HttpRequestHeaders::NetLogCallback(
     const std::string* request_line,
     NetLog::LogLevel log_level) const {
   base::DictionaryValue* dict = new base::DictionaryValue();
   dict->SetString("line", *request_line);
   base::ListValue* headers = new base::ListValue();
-  for (HeaderVector::const_iterator it = headers_.begin();
-       it != headers_.end(); ++it) {
-    std::string log_value = ElideHeaderValueForNetLog(
-        log_level, it->key, it->value);
+  for (HeaderVector::const_iterator it = headers_.begin(); it != headers_.end();
+       ++it) {
+    std::string log_value =
+        ElideHeaderValueForNetLog(log_level, it->key, it->value);
     headers->Append(new base::StringValue(
-        base::StringPrintf("%s: %s",
-                           it->key.c_str(), log_value.c_str())));
+        base::StringPrintf("%s: %s", it->key.c_str(), log_value.c_str())));
   }
   dict->Set("headers", headers);
   return dict;
 }
 
 // static
 bool HttpRequestHeaders::FromNetLogParam(const base::Value* event_param,
                                          HttpRequestHeaders* headers,
                                          std::string* request_line) {
   headers->Clear();
   *request_line = "";
 
   const base::DictionaryValue* dict = NULL;
   const base::ListValue* header_list = NULL;
 
-  if (!event_param ||
-      !event_param->GetAsDictionary(&dict) ||
+  if (!event_param || !event_param->GetAsDictionary(&dict) ||
       !dict->GetList("headers", &header_list) ||
       !dict->GetString("line", request_line)) {
     return false;
   }
 
   for (base::ListValue::const_iterator it = header_list->begin();
        it != header_list->end();
        ++it) {
     std::string header_line;
     if (!(*it)->GetAsString(&header_line)) {
       headers->Clear();
       *request_line = "";
       return false;
     }
     headers->AddHeaderFromString(header_line);
   }
   return true;
 }
 
-HttpRequestHeaders::HeaderVector::iterator
-HttpRequestHeaders::FindHeader(const base::StringPiece& key) {
-  for (HeaderVector::iterator it = headers_.begin();
-       it != headers_.end(); ++it) {
+HttpRequestHeaders::HeaderVector::iterator HttpRequestHeaders::FindHeader(
+    const base::StringPiece& key) {
+  for (HeaderVector::iterator it = headers_.begin(); it != headers_.end();
+       ++it) {
     if (key.length() == it->key.length() &&
         !base::strncasecmp(key.data(), it->key.data(), key.length()))
       return it;
   }
 
   return headers_.end();
 }
 
-HttpRequestHeaders::HeaderVector::const_iterator
-HttpRequestHeaders::FindHeader(const base::StringPiece& key) const {
-  for (HeaderVector::const_iterator it = headers_.begin();
-       it != headers_.end(); ++it) {
+HttpRequestHeaders::HeaderVector::const_iterator HttpRequestHeaders::FindHeader(
+    const base::StringPiece& key) const {
+  for (HeaderVector::const_iterator it = headers_.begin(); it != headers_.end();
+       ++it) {
     if (key.length() == it->key.length() &&
         !base::strncasecmp(key.data(), it->key.data(), key.length()))
       return it;
   }
 
   return headers_.end();
 }
 
 }  // namespace net