Auto-format style pass over files.

net/http/http_util.cc

 // Copyright (c) 2006-2008 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 parsing content-types were borrowed from Firefox:
 // http://lxr.mozilla.org/mozilla/source/netwerk/base/src/nsURLHelper.cpp#834
 
 #include "net/http/http_util.h"
 
 #include <algorithm>
@@ skipping 94 matching lines @@
   // Iterate over parameters
   bool type_has_charset = false;
   size_t param_start = content_type_str.find_first_of(';', type_end);
   if (param_start != string::npos) {
     // We have parameters.  Iterate over them.
     size_t cur_param_start = param_start + 1;
     do {
       size_t cur_param_end =
           FindDelimiter(content_type_str, cur_param_start, ';');
 
-      size_t param_name_start = content_type_str.find_first_not_of(HTTP_LWS,
-          cur_param_start);
+      size_t param_name_start = content_type_str.find_first_not_of(
+          HTTP_LWS, cur_param_start);
       param_name_start = std::min(param_name_start, cur_param_end);
 
       static const char charset_str[] = "charset=";
-      size_t charset_end_offset = std::min(param_name_start +
-          sizeof(charset_str) - 1, cur_param_end);
-      if (LowerCaseEqualsASCII(content_type_str.begin() + param_name_start,
-          content_type_str.begin() + charset_end_offset, charset_str)) {
+      size_t charset_end_offset = std::min(
+          param_name_start + sizeof(charset_str) - 1, cur_param_end);
+      if (LowerCaseEqualsASCII(
+              content_type_str.begin() + param_name_start,
+              content_type_str.begin() + charset_end_offset, charset_str)) {
         charset_val = param_name_start + sizeof(charset_str) - 1;
         charset_end = cur_param_end;
         type_has_charset = true;
       }
 
       cur_param_start = cur_param_end + 1;
     } while (cur_param_start < content_type_str.length());
   }
 
   if (type_has_charset) {
@@ skipping 19 matching lines @@
   // charset.  however, if charset is empty and mime_type hasn't
   // changed, then don't wipe-out an existing charset.  We
   // also want to reject a mime-type if it does not include a slash.
   // some servers give junk after the charset parameter, which may
   // include a comma, so this check makes us a bit more tolerant.
   if (content_type_str.length() != 0 &&
       content_type_str != "*/*" &&
       content_type_str.find_first_of('/') != string::npos) {
     // Common case here is that mime_type is empty
     bool eq = !mime_type->empty() &&
-        LowerCaseEqualsASCII(content_type_str.begin() + type_val,
-                             content_type_str.begin() + type_end,
-                             mime_type->data());
+              LowerCaseEqualsASCII(content_type_str.begin() + type_val,
+                                   content_type_str.begin() + type_end,
+                                   mime_type->data());
     if (!eq) {
       mime_type->assign(content_type_str.begin() + type_val,
                         content_type_str.begin() + type_end);
       StringToLowerASCII(mime_type);
     }
     if ((!eq && *had_charset) || type_has_charset) {
       *had_charset = true;
       charset->assign(content_type_str.begin() + charset_val,
                       content_type_str.begin() + charset_end);
       StringToLowerASCII(charset);
@@ skipping 59 matching lines @@
     std::string::const_iterator first_byte_pos_begin =
         byte_range_set_iterator.value_begin();
     std::string::const_iterator first_byte_pos_end =
         first_byte_pos_begin +  minus_char_offset;
     TrimLWS(&first_byte_pos_begin, &first_byte_pos_end);
     std::string first_byte_pos(first_byte_pos_begin, first_byte_pos_end);
 
     HttpByteRange range;
     // Try to obtain first-byte-pos.
     if (!first_byte_pos.empty()) {
-        int64 first_byte_position = -1;
-        if (!StringToInt64(first_byte_pos, &first_byte_position))
-          return false;
-        range.set_first_byte_position(first_byte_position);
-      }
+      int64 first_byte_position = -1;
+      if (!StringToInt64(first_byte_pos, &first_byte_position))
+        return false;
+      range.set_first_byte_position(first_byte_position);
+    }
 
     std::string::const_iterator last_byte_pos_begin =
         byte_range_set_iterator.value_begin() + minus_char_offset + 1;
     std::string::const_iterator last_byte_pos_end =
         byte_range_set_iterator.value_end();
     TrimLWS(&last_byte_pos_begin, &last_byte_pos_end);
     std::string last_byte_pos(last_byte_pos_begin, last_byte_pos_end);
 
     // We have last-byte-pos or suffix-byte-range-spec in this case.
     if (!last_byte_pos.empty()) {
@@ skipping 427 matching lines @@
     TrimLWS(&value_begin_, &value_end_);
 
     // bypass empty values.
     if (value_begin_ != value_end_)
       return true;
   }
   return false;
 }
 
 }  // namespace net