Auto-format style pass over files.

net/http/http_response_headers.cc

 // Copyright (c) 2006-2009 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 256 matching lines @@
 
 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 =
       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);
 
   if (line_end == raw_input.end()) {
     raw_headers_.push_back('\0');
     return;
   }
 
   // Including a terminating null byte.
   size_t status_line_len = raw_headers_.size();
 
@@ skipping 823 matching lines @@
       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 = StringToInt64(
           std::string(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;
+          byte_range_resp_spec.begin() + minus_position + 1;
       std::string::const_iterator last_byte_pos_end =
-           byte_range_resp_spec.end();
+          byte_range_resp_spec.end();
       HttpUtil::TrimLWS(&last_byte_pos_begin, &last_byte_pos_end);
 
       ok &= StringToInt64(
           std::string(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();
   HttpUtil::TrimLWS(&instance_length_begin, &instance_length_end);
 
   if (LowerCaseEqualsASCII(instance_length_begin, instance_length_end, "*")) {
     return false;
   } else if (!StringToInt64(
-                 std::string(instance_length_begin, instance_length_end),
-                 instance_length)) {
+      std::string(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;
 }
 
 }  // namespace net