Clang format slam.

net/http/http_response_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.
 
 // The rules for header parsing were borrowed from Firefox:
 // http://lxr.mozilla.org/seamonkey/source/netwerk/protocol/http/src/nsHttpResponseHead.cpp
 // The rules for parsing content-types were also borrowed from Firefox:
 // http://lxr.mozilla.org/mozilla/source/netwerk/base/src/nsURLHelper.cpp#834
 
 #include "net/http/http_response_headers.h"
@@ skipping 26 matching lines @@
 
 namespace net {
 
 //-----------------------------------------------------------------------------
 
 namespace {
 
 // These headers are RFC 2616 hop-by-hop headers;
 // not to be stored by caches.
 const char* const kHopByHopResponseHeaders[] = {
-  "connection",
-  "proxy-connection",
-  "keep-alive",
-  "trailer",
-  "transfer-encoding",
-  "upgrade"
-};
+    "connection", "proxy-connection",  "keep-alive",
+    "trailer",    "transfer-encoding", "upgrade"};
 
 // These headers are challenge response headers;
 // not to be stored by caches.
-const char* const kChallengeResponseHeaders[] = {
-  "www-authenticate",
-  "proxy-authenticate"
-};
+const char* const kChallengeResponseHeaders[] = {"www-authenticate",
+                                                 "proxy-authenticate"};
 
 // These headers are cookie setting headers;
 // not to be stored by caches or disclosed otherwise.
-const char* const kCookieResponseHeaders[] = {
-  "set-cookie",
-  "set-cookie2"
-};
+const char* const kCookieResponseHeaders[] = {"set-cookie", "set-cookie2"};
 
 // By default, do not cache Strict-Transport-Security or Public-Key-Pins.
 // This avoids erroneously re-processing them on page loads from cache ---
 // they are defined to be valid only on live and error-free HTTPS
 // connections.
-const char* const kSecurityStateHeaders[] = {
-  "strict-transport-security",
-  "public-key-pins"
-};
+const char* const kSecurityStateHeaders[] = {"strict-transport-security",
+                                             "public-key-pins"};
 
 // These response headers are not copied from a 304/206 response to the cached
 // response headers.  This list is based on Mozilla's nsHttpResponseHead.cpp.
 const char* const kNonUpdatedHeaders[] = {
-  "connection",
-  "proxy-connection",
-  "keep-alive",
-  "www-authenticate",
-  "proxy-authenticate",
-  "trailer",
-  "transfer-encoding",
-  "upgrade",
-  "etag",
-  "x-frame-options",
-  "x-xss-protection",
+    "connection",        "proxy-connection",   "keep-alive",
+    "www-authenticate",  "proxy-authenticate", "trailer",
+    "transfer-encoding", "upgrade",            "etag",
+    "x-frame-options",   "x-xss-protection",
 };
 
 // Some header prefixes mean "Don't copy this header from a 304 response.".
 // Rather than listing all the relevant headers, we can consolidate them into
 // this list:
-const char* const kNonUpdatedHeaderPrefixes[] = {
-  "content-",
-  "x-content-",
-  "x-webkit-"
-};
+const char* const kNonUpdatedHeaderPrefixes[] = {"content-", "x-content-",
+                                                 "x-webkit-"};
 
 bool ShouldUpdateHeader(const std::string::const_iterator& name_begin,
                         const std::string::const_iterator& name_end) {
   for (size_t i = 0; i < arraysize(kNonUpdatedHeaders); ++i) {
     if (LowerCaseEqualsASCII(name_begin, name_end, kNonUpdatedHeaders[i]))
       return false;
   }
   for (size_t i = 0; i < arraysize(kNonUpdatedHeaderPrefixes); ++i) {
     if (StartsWithASCII(std::string(name_begin, name_end),
-                        kNonUpdatedHeaderPrefixes[i], false))
+                        kNonUpdatedHeaderPrefixes[i],
+                        false))
       return false;
   }
   return true;
 }
 
 void CheckDoesNotHaveEmbededNulls(const std::string& str) {
   // Care needs to be taken when adding values to the raw headers string to
   // make sure it does not contain embeded NULLs. Any embeded '\0' may be
   // understood as line terminators and change how header lines get tokenized.
   CHECK(str.find('\0') == std::string::npos);
@@ skipping 23 matching lines @@
   // The most important thing to do with this histogram is find out
   // the existence of unusual HTTP status codes.  As it happens
   // right now, there aren't double-constructions of response headers
   // using this constructor, so our counts should also be accurate,
   // without instantiating the histogram in two places.  It is also
   // important that this histogram not collect data in the other
   // constructor, which rebuilds an histogram from a pickle, since
   // that would actually create a double call between the original
   // HttpResponseHeader that was serialized, and initialization of the
   // new object from that pickle.
-  UMA_HISTOGRAM_CUSTOM_ENUMERATION("Net.HttpResponseCode",
-                                   HttpUtil::MapStatusCodeForHistogram(
-                                       response_code_),
-                                   // Note the third argument is only
-                                   // evaluated once, see macro
-                                   // definition for details.
-                                   HttpUtil::GetStatusCodesForHistogram());
+  UMA_HISTOGRAM_CUSTOM_ENUMERATION(
+      "Net.HttpResponseCode",
+      HttpUtil::MapStatusCodeForHistogram(response_code_),
+      // Note the third argument is only
+      // evaluated once, see macro
+      // definition for details.
+      HttpUtil::GetStatusCodesForHistogram());
 }
 
 HttpResponseHeaders::HttpResponseHeaders(const Pickle& pickle,
                                          PickleIterator* iter)
     : response_code_(-1) {
   std::string raw_input;
   if (pickle.ReadString(iter, &raw_input))
     Parse(raw_input);
 }
 
@@ skipping 30 matching lines @@
   // This copies the status line w/ terminator null.
   // Note raw_headers_ has embedded nulls instead of \n,
   // so this just copies the first header line.
   blob.assign(raw_headers_.c_str(), strlen(raw_headers_.c_str()) + 1);
 
   for (size_t i = 0; i < parsed_.size(); ++i) {
     DCHECK(!parsed_[i].is_continuation());
 
     // Locate the start of the next header.
     size_t k = i;
-    while (++k < parsed_.size() && parsed_[k].is_continuation()) {}
+    while (++k < parsed_.size() && parsed_[k].is_continuation()) {
+    }
     --k;
 
     std::string header_name(parsed_[i].name_begin, parsed_[i].name_end);
     StringToLowerASCII(&header_name);
 
     if (filter_headers.find(header_name) == filter_headers.end()) {
       // Make sure there is a null after the value.
       blob.append(parsed_[i].name_begin, parsed_[k].value_end);
       blob.push_back('\0');
     }
@@ skipping 19 matching lines @@
   // order should not matter.
 
   // Figure out which headers we want to take from new_headers:
   for (size_t i = 0; i < new_headers.parsed_.size(); ++i) {
     const HeaderList& new_parsed = new_headers.parsed_;
 
     DCHECK(!new_parsed[i].is_continuation());
 
     // Locate the start of the next header.
     size_t k = i;
-    while (++k < new_parsed.size() && new_parsed[k].is_continuation()) {}
+    while (++k < new_parsed.size() && new_parsed[k].is_continuation()) {
+    }
     --k;
 
     const std::string::const_iterator& name_begin = new_parsed[i].name_begin;
     const std::string::const_iterator& name_end = new_parsed[i].name_end;
     if (ShouldUpdateHeader(name_begin, name_end)) {
       std::string name(name_begin, name_end);
       StringToLowerASCII(&name);
       updated_headers.insert(name);
 
       // Preserve this header line in the merged result, making sure there is
@@ skipping 10 matching lines @@
 }
 
 void HttpResponseHeaders::MergeWithHeaders(const std::string& raw_headers,
                                            const HeaderSet& headers_to_remove) {
   std::string new_raw_headers(raw_headers);
   for (size_t i = 0; i < parsed_.size(); ++i) {
     DCHECK(!parsed_[i].is_continuation());
 
     // Locate the start of the next header.
     size_t k = i;
-    while (++k < parsed_.size() && parsed_[k].is_continuation()) {}
+    while (++k < parsed_.size() && parsed_[k].is_continuation()) {
+    }
     --k;
 
     std::string name(parsed_[i].name_begin, parsed_[i].name_end);
     StringToLowerASCII(&name);
     if (headers_to_remove.find(name) == headers_to_remove.end()) {
       // It's ok to preserve this header in the final result.
       new_raw_headers.append(parsed_[i].name_begin, parsed_[k].value_end);
       new_raw_headers.push_back('\0');
     }
 
@@ skipping 73 matching lines @@
 void HttpResponseHeaders::ReplaceStatusLine(const std::string& new_status) {
   CheckDoesNotHaveEmbededNulls(new_status);
   // Copy up to the null byte.  This just copies the status line.
   std::string new_raw_headers(new_status);
   new_raw_headers.push_back('\0');
 
   HeaderSet empty_to_remove;
   MergeWithHeaders(new_raw_headers, empty_to_remove);
 }
 
-void HttpResponseHeaders::UpdateWithNewRange(
-    const HttpByteRange& byte_range,
-    int64 resource_size,
-    bool replace_status_line) {
+void HttpResponseHeaders::UpdateWithNewRange(const HttpByteRange& byte_range,
+                                             int64 resource_size,
+                                             bool replace_status_line) {
   DCHECK(byte_range.IsValid());
   DCHECK(byte_range.HasFirstBytePosition());
   DCHECK(byte_range.HasLastBytePosition());
 
   const char kLengthHeader[] = "Content-Length";
   const char kRangeHeader[] = "Content-Range";
 
   RemoveHeader(kLengthHeader);
   RemoveHeader(kRangeHeader);
 
   int64 start = byte_range.first_byte_position();
   int64 end = byte_range.last_byte_position();
   int64 range_len = end - start + 1;
 
   if (replace_status_line)
     ReplaceStatusLine("HTTP/1.1 206 Partial Content");
 
   AddHeader(base::StringPrintf("%s: bytes %" PRId64 "-%" PRId64 "/%" PRId64,
-                               kRangeHeader, start, end, resource_size));
+                               kRangeHeader,
+                               start,
+                               end,
+                               resource_size));
   AddHeader(base::StringPrintf("%s: %" PRId64, kLengthHeader, range_len));
 }
 
 void HttpResponseHeaders::Parse(const std::string& raw_input) {
   raw_headers_.reserve(raw_input.size());
 
   // ParseStatusLine adds a normalized status line to raw_headers_
   std::string::const_iterator line_begin = raw_input.begin();
   std::string::const_iterator line_end =
       std::find(line_begin, raw_input.end(), '\0');
   // has_headers = true, if there is any data following the status line.
   // Used by ParseStatusLine() to decide if a HTTP/0.9 is really a HTTP/1.0.
-  bool has_headers = (line_end != raw_input.end() &&
-                      (line_end + 1) != raw_input.end() &&
-                      *(line_end + 1) != '\0');
+  bool has_headers =
+      (line_end != raw_input.end() && (line_end + 1) != raw_input.end() &&
+       *(line_end + 1) != '\0');
   ParseStatusLine(line_begin, line_end, has_headers);
   raw_headers_.push_back('\0');  // Terminate status line with a null.
 
   if (line_end == raw_input.end()) {
     raw_headers_.push_back('\0');  // Ensure the headers end with a double null.
 
     DCHECK_EQ('\0', raw_headers_[raw_headers_.size() - 2]);
     DCHECK_EQ('\0', raw_headers_[raw_headers_.size() - 1]);
     return;
   }
 
   // Including a terminating null byte.
   size_t status_line_len = raw_headers_.size();
 
   // Now, we add the rest of the raw headers to raw_headers_, and begin parsing
   // it (to populate our parsed_ vector).
   raw_headers_.append(line_end + 1, raw_input.end());
 
   // Ensure the headers end with a double null.
   while (raw_headers_.size() < 2 ||
          raw_headers_[raw_headers_.size() - 2] != '\0' ||
          raw_headers_[raw_headers_.size() - 1] != '\0') {
     raw_headers_.push_back('\0');
   }
 
   // Adjust to point at the null byte following the status line
   line_end = raw_headers_.begin() + status_line_len - 1;
 
-  HttpUtil::HeadersIterator headers(line_end + 1, raw_headers_.end(),
-                                    std::string(1, '\0'));
+  HttpUtil::HeadersIterator headers(
+      line_end + 1, raw_headers_.end(), std::string(1, '\0'));
   while (headers.GetNext()) {
     AddHeader(headers.name_begin(),
               headers.name_end(),
               headers.values_begin(),
               headers.values_end());
   }
 
   DCHECK_EQ('\0', raw_headers_[raw_headers_.size() - 2]);
   DCHECK_EQ('\0', raw_headers_[raw_headers_.size() - 1]);
 }
@@ skipping 21 matching lines @@
   std::vector<std::string> headers;
 
   for (size_t i = 0; i < parsed_.size(); ++i) {
     DCHECK(!parsed_[i].is_continuation());
 
     std::string name(parsed_[i].name_begin, parsed_[i].name_end);
     std::string lower_name = StringToLowerASCII(name);
 
     iter = headers_map.find(lower_name);
     if (iter == headers_map.end()) {
-      iter = headers_map.insert(
-          HeadersMap::value_type(lower_name, headers.size())).first;
+      iter = headers_map.insert(HeadersMap::value_type(lower_name,
+                                                       headers.size())).first;
       headers.push_back(name + ": ");
     } else {
       headers[iter->second].append(", ");
     }
 
     std::string::const_iterator value_begin = parsed_[i].value_begin;
     std::string::const_iterator value_end = parsed_[i].value_end;
     while (++i < parsed_.size() && parsed_[i].is_continuation())
       value_end = parsed_[i].value_end;
     --i;
@@ skipping 103 matching lines @@
 }
 
 bool HttpResponseHeaders::HasHeaderValue(const base::StringPiece& name,
                                          const base::StringPiece& value) const {
   // The value has to be an exact match.  This is important since
   // 'cache-control: no-cache' != 'cache-control: no-cache="foo"'
   void* iter = NULL;
   std::string temp;
   while (EnumerateHeader(&iter, name, &temp)) {
     if (value.size() == temp.size() &&
-        std::equal(temp.begin(), temp.end(), value.begin(),
+        std::equal(temp.begin(),
+                   temp.end(),
+                   value.begin(),
                    base::CaseInsensitiveCompare<char>()))
       return true;
   }
   return false;
 }
 
 bool HttpResponseHeaders::HasHeader(const base::StringPiece& name) const {
   return FindHeader(0, name) != std::string::npos;
 }
 
@@ skipping 26 matching lines @@
     DVLOG(1) << "missing version";
     return HttpVersion();
   }
 
   std::string::const_iterator dot = std::find(p, line_end, '.');
   if (dot == line_end) {
     DVLOG(1) << "malformed version";
     return HttpVersion();
   }
 
-  ++p;  // from / to first digit.
+  ++p;    // from / to first digit.
   ++dot;  // from . to second digit.
 
   if (!(*p >= '0' && *p <= '9' && *dot >= '0' && *dot <= '9')) {
     DVLOG(1) << "malformed version number";
     return HttpVersion();
   }
 
   uint16 major = *p - '0';
   uint16 minor = *dot - '0';
 
@@ skipping 74 matching lines @@
 }
 
 size_t HttpResponseHeaders::FindHeader(size_t from,
                                        const base::StringPiece& search) const {
   for (size_t i = from; i < parsed_.size(); ++i) {
     if (parsed_[i].is_continuation())
       continue;
     const std::string::const_iterator& name_begin = parsed_[i].name_begin;
     const std::string::const_iterator& name_end = parsed_[i].name_end;
     if (static_cast<size_t>(name_end - name_begin) == search.size() &&
-        std::equal(name_begin, name_end, search.begin(),
+        std::equal(name_begin,
+                   name_end,
+                   search.begin(),
                    base::CaseInsensitiveCompare<char>()))
       return i;
   }
 
   return std::string::npos;
 }
 
 void HttpResponseHeaders::AddHeader(std::string::const_iterator name_begin,
                                     std::string::const_iterator name_end,
                                     std::string::const_iterator values_begin,
@@ skipping 35 matching lines @@
   std::string value;
   void* iter = NULL;
   while (EnumerateHeader(&iter, kCacheControl, &value)) {
     // If the value is smaller than the prefix and a terminal quote, skip
     // it.
     if (value.size() <= kPrefixLen ||
         value.compare(0, kPrefixLen, kPrefix) != 0) {
       continue;
     }
     // if it doesn't end with a quote, then treat as malformed
-    if (value[value.size()-1] != '\"')
+    if (value[value.size() - 1] != '\"')
       continue;
 
     // process the value as a comma-separated list of items. Each
     // item can be wrapped by linear white space.
     std::string::const_iterator item = value.begin() + kPrefixLen;
     std::string::const_iterator end = value.end() - 1;
     while (item != end) {
       // Find the comma to compute the length of the current item,
       // and the position of the next one.
       std::string::const_iterator item_next = std::find(item, end, ',');
@@ skipping 92 matching lines @@
         std::string(parsed_[i].value_begin, parsed_[i].value_end));
   }
 
   return true;
 }
 
 // static
 bool HttpResponseHeaders::IsRedirectResponseCode(int response_code) {
   // Users probably want to see 300 (multiple choice) pages, so we don't count
   // them as redirects that need to be followed.
-  return (response_code == 301 ||
-          response_code == 302 ||
-          response_code == 303 ||
-          response_code == 307 ||
-          response_code == 308);
+  return (response_code == 301 || response_code == 302 ||
+          response_code == 303 || response_code == 307 || response_code == 308);
 }
 
 // From RFC 2616 section 13.2.4:
 //
 // The calculation to determine if a response has expired is quite simple:
 //
 //   response_is_fresh = (freshness_lifetime > current_age)
 //
 // Of course, there are other factors that can force a response to always be
 // validated or re-fetched.
 //
 bool HttpResponseHeaders::RequiresValidation(const Time& request_time,
                                              const Time& response_time,
                                              const Time& current_time) const {
-  TimeDelta lifetime =
-      GetFreshnessLifetime(response_time);
+  TimeDelta lifetime = GetFreshnessLifetime(response_time);
   if (lifetime == TimeDelta())
     return true;
 
   return lifetime <= GetCurrentAge(request_time, response_time, current_time);
 }
 
 // From RFC 2616 section 13.2.4:
 //
 // The max-age directive takes priority over Expires, so if max-age is present
 // in a response, the calculation is simply:
@@ skipping 15 matching lines @@
 //
 TimeDelta HttpResponseHeaders::GetFreshnessLifetime(
     const Time& response_time) const {
   // Check for headers that force a response to never be fresh.  For backwards
   // compat, we treat "Pragma: no-cache" as a synonym for "Cache-Control:
   // no-cache" even though RFC 2616 does not specify it.
   if (HasHeaderValue("cache-control", "no-cache") ||
       HasHeaderValue("cache-control", "no-store") ||
       HasHeaderValue("pragma", "no-cache") ||
       HasHeaderValue("vary", "*"))  // see RFC 2616 section 13.6
-    return TimeDelta();  // not fresh
+    return TimeDelta();             // not fresh
 
   // NOTE: "Cache-Control: max-age" overrides Expires, so we only check the
   // Expires header after checking for max-age in GetFreshnessLifetime.  This
   // is important since "Expires: <date in the past>" means not fresh, but
   // it should not trump a max-age value.
 
   TimeDelta max_age_value;
   if (GetMaxAgeValue(&max_age_value))
     return max_age_value;
 
@@ skipping 110 matching lines @@
 bool HttpResponseHeaders::GetMaxAgeValue(TimeDelta* result) const {
   std::string name = "cache-control";
   std::string value;
 
   const char kMaxAgePrefix[] = "max-age=";
   const size_t kMaxAgePrefixLen = arraysize(kMaxAgePrefix) - 1;
 
   void* iter = NULL;
   while (EnumerateHeader(&iter, name, &value)) {
     if (value.size() > kMaxAgePrefixLen) {
-      if (LowerCaseEqualsASCII(value.begin(),
-                               value.begin() + kMaxAgePrefixLen,
-                               kMaxAgePrefix)) {
+      if (LowerCaseEqualsASCII(
+              value.begin(), value.begin() + kMaxAgePrefixLen, kMaxAgePrefix)) {
         int64 seconds;
-        base::StringToInt64(StringPiece(value.begin() + kMaxAgePrefixLen,
-                                        value.end()),
-                            &seconds);
+        base::StringToInt64(
+            StringPiece(value.begin() + kMaxAgePrefixLen, value.end()),
+            &seconds);
         *result = TimeDelta::FromSeconds(seconds);
         return true;
       }
     }
   }
 
   return false;
 }
 
 bool HttpResponseHeaders::GetAgeValue(TimeDelta* result) const {
@@ skipping 63 matching lines @@
   return keep_alive;
 }
 
 bool HttpResponseHeaders::HasStrongValidators() const {
   std::string etag_header;
   EnumerateHeader(NULL, "etag", &etag_header);
   std::string last_modified_header;
   EnumerateHeader(NULL, "Last-Modified", &last_modified_header);
   std::string date_header;
   EnumerateHeader(NULL, "Date", &date_header);
-  return HttpUtil::HasStrongValidators(GetHttpVersion(),
-                                       etag_header,
-                                       last_modified_header,
-                                       date_header);
+  return HttpUtil::HasStrongValidators(
+      GetHttpVersion(), etag_header, last_modified_header, date_header);
 }
 
 // From RFC 2616:
 // Content-Length = "Content-Length" ":" 1*DIGIT
 int64 HttpResponseHeaders::GetContentLength() const {
   return GetInt64HeaderValue("content-length");
 }
 
 int64 HttpResponseHeaders::GetInt64HeaderValue(
     const std::string& header) const {
@@ skipping 38 matching lines @@
   size_t space_position = content_range_spec.find(' ');
   if (space_position == std::string::npos)
     return false;
 
   // Invalid header if it doesn't contain "bytes-unit".
   std::string::const_iterator content_range_spec_begin =
       content_range_spec.begin();
   std::string::const_iterator content_range_spec_end =
       content_range_spec.begin() + space_position;
   HttpUtil::TrimLWS(&content_range_spec_begin, &content_range_spec_end);
-  if (!LowerCaseEqualsASCII(content_range_spec_begin,
-                            content_range_spec_end,
-                            "bytes")) {
+  if (!LowerCaseEqualsASCII(
+          content_range_spec_begin, content_range_spec_end, "bytes")) {
     return false;
   }
 
   size_t slash_position = content_range_spec.find('/', space_position + 1);
   if (slash_position == std::string::npos)
     return false;
 
   // Obtain the part behind the space and before slash.
   std::string::const_iterator byte_range_resp_spec_begin =
       content_range_spec.begin() + space_position + 1;
   std::string::const_iterator byte_range_resp_spec_end =
       content_range_spec.begin() + slash_position;
   HttpUtil::TrimLWS(&byte_range_resp_spec_begin, &byte_range_resp_spec_end);
 
   // Parse the byte-range-resp-spec part.
   std::string byte_range_resp_spec(byte_range_resp_spec_begin,
                                    byte_range_resp_spec_end);
   // If byte-range-resp-spec != "*".
   if (!LowerCaseEqualsASCII(byte_range_resp_spec, "*")) {
     size_t minus_position = byte_range_resp_spec.find('-');
     if (minus_position != std::string::npos) {
       // Obtain first-byte-pos.
       std::string::const_iterator first_byte_pos_begin =
           byte_range_resp_spec.begin();
       std::string::const_iterator first_byte_pos_end =
           byte_range_resp_spec.begin() + minus_position;
       HttpUtil::TrimLWS(&first_byte_pos_begin, &first_byte_pos_end);
 
-      bool ok = base::StringToInt64(StringPiece(first_byte_pos_begin,
-                                                first_byte_pos_end),
-                                    first_byte_position);
+      bool ok = base::StringToInt64(
+          StringPiece(first_byte_pos_begin, first_byte_pos_end),
+          first_byte_position);
 
       // Obtain last-byte-pos.
       std::string::const_iterator last_byte_pos_begin =
           byte_range_resp_spec.begin() + minus_position + 1;
       std::string::const_iterator last_byte_pos_end =
           byte_range_resp_spec.end();
       HttpUtil::TrimLWS(&last_byte_pos_begin, &last_byte_pos_end);
 
-      ok &= base::StringToInt64(StringPiece(last_byte_pos_begin,
-                                            last_byte_pos_end),
-                                last_byte_position);
+      ok &= base::StringToInt64(
+          StringPiece(last_byte_pos_begin, last_byte_pos_end),
+          last_byte_position);
       if (!ok) {
         *first_byte_position = *last_byte_position = -1;
         return false;
       }
       if (*first_byte_position < 0 || *last_byte_position < 0 ||
           *first_byte_position > *last_byte_position)
         return false;
     } else {
       return false;
     }
   }
 
   // Parse the instance-length part.
   // If instance-length == "*".
   std::string::const_iterator instance_length_begin =
       content_range_spec.begin() + slash_position + 1;
-  std::string::const_iterator instance_length_end =
-      content_range_spec.end();
+  std::string::const_iterator instance_length_end = content_range_spec.end();
   HttpUtil::TrimLWS(&instance_length_begin, &instance_length_end);
 
   if (LowerCaseEqualsASCII(instance_length_begin, instance_length_end, "*")) {
     return false;
-  } else if (!base::StringToInt64(StringPiece(instance_length_begin,
-                                              instance_length_end),
-                                  instance_length)) {
+  } else if (!base::StringToInt64(
+                 StringPiece(instance_length_begin, instance_length_end),
+                 instance_length)) {
     *instance_length = -1;
     return false;
   }
 
   // We have all the values; let's verify that they make sense for a 206
   // response.
   if (*first_byte_position < 0 || *last_byte_position < 0 ||
       *instance_length < 0 || *instance_length - 1 < *last_byte_position)
     return false;
 
   return true;
 }
 
 base::Value* HttpResponseHeaders::NetLogCallback(
     NetLog::LogLevel log_level) const {
   base::DictionaryValue* dict = new base::DictionaryValue();
   base::ListValue* headers = new base::ListValue();
   headers->Append(new base::StringValue(GetStatusLine()));
   void* iterator = NULL;
   std::string name;
   std::string value;
   while (EnumerateHeaderLines(&iterator, &name, &value)) {
     std::string log_value = ElideHeaderValueForNetLog(log_level, name, value);
-    headers->Append(
-      new base::StringValue(
-          base::StringPrintf("%s: %s", name.c_str(), log_value.c_str())));
+    headers->Append(new base::StringValue(
+        base::StringPrintf("%s: %s", name.c_str(), log_value.c_str())));
   }
   dict->Set("headers", headers);
   return dict;
 }
 
 // static
 bool HttpResponseHeaders::FromNetLogParam(
     const base::Value* event_param,
     scoped_refptr<HttpResponseHeaders>* http_response_headers) {
   *http_response_headers = NULL;
 
   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)) {
     return false;
   }
 
   std::string raw_headers;
   for (base::ListValue::const_iterator it = header_list->begin();
        it != header_list->end();
        ++it) {
     std::string header_line;
     if (!(*it)->GetAsString(&header_line))
       return false;
 
     raw_headers.append(header_line);
     raw_headers.push_back('\0');
   }
   raw_headers.push_back('\0');
   *http_response_headers = new HttpResponseHeaders(raw_headers);
   return true;
 }
 
 bool HttpResponseHeaders::IsChunkEncoded() const {
   // Ignore spurious chunked responses from HTTP/1.0 servers and proxies.
   return GetHttpVersion() >= HttpVersion(1, 1) &&
-      HasHeaderValue("Transfer-Encoding", "chunked");
+         HasHeaderValue("Transfer-Encoding", "chunked");
 }
 
 #if defined(SPDY_PROXY_AUTH_ORIGIN)
 bool HttpResponseHeaders::GetDataReductionProxyBypassDuration(
     const std::string& action_prefix,
     base::TimeDelta* duration) const {
   void* iter = NULL;
   std::string value;
   std::string name = "chrome-proxy";
 
   while (EnumerateHeader(&iter, name, &value)) {
     if (value.size() > action_prefix.size()) {
       if (LowerCaseEqualsASCII(value.begin(),
                                value.begin() + action_prefix.size(),
                                action_prefix.c_str())) {
         int64 seconds;
         if (!base::StringToInt64(
                 StringPiece(value.begin() + action_prefix.size(), value.end()),
-                &seconds) || seconds < 0) {
+                &seconds) ||
+            seconds < 0) {
           continue;  // In case there is a well formed instruction.
         }
         *duration = TimeDelta::FromSeconds(seconds);
         return true;
       }
     }
   }
   return false;
 }
 
 bool HttpResponseHeaders::GetDataReductionProxyInfo(
     DataReductionProxyInfo* proxy_info) const {
   DCHECK(proxy_info);
   proxy_info->bypass_all = false;
   proxy_info->bypass_duration = base::TimeDelta();
   // Support header of the form Chrome-Proxy: bypass|block=<duration>, where
   // <duration> is the number of seconds to wait before retrying
   // the proxy. If the duration is 0, then the default proxy retry delay
   // (specified in |ProxyList::UpdateRetryInfoOnFallback|) will be used.
   // 'bypass' instructs Chrome to bypass the currently connected data reduction
   // proxy, whereas 'block' instructs Chrome to bypass all available data
   // reduction proxies.
 
   // 'block' takes precedence over 'bypass', so look for it first.
   // TODO(bengr): Reduce checks for 'block' and 'bypass' to a single loop.
-  if (GetDataReductionProxyBypassDuration(
-      "block=", &proxy_info->bypass_duration)) {
+  if (GetDataReductionProxyBypassDuration("block=",
+                                          &proxy_info->bypass_duration)) {
     proxy_info->bypass_all = true;
     return true;
   }
 
   // Next, look for 'bypass'.
-  if (GetDataReductionProxyBypassDuration(
-      "bypass=", &proxy_info->bypass_duration)) {
+  if (GetDataReductionProxyBypassDuration("bypass=",
+                                          &proxy_info->bypass_duration)) {
     return true;
   }
   return false;
 }
 
 bool HttpResponseHeaders::IsDataReductionProxyResponse() const {
   const size_t kVersionSize = 4;
   const char kDataReductionProxyViaValue[] = "Chrome-Compression-Proxy";
   size_t value_len = strlen(kDataReductionProxyViaValue);
   void* iter = NULL;
@@ skipping 43 matching lines @@
     // should not generate representation metadata other than Cache-Control,
     // Content-Location, Date, ETag, Expires, and Vary.
     return ProxyService::MISSING_VIA_HEADER;
   }
   // There is no bypass event.
   return ProxyService::BYPASS_EVENT_TYPE_MAX;
 }
 #endif  // defined(SPDY_PROXY_AUTH_ORIGIN)
 
 }  // namespace net