Clang format slam.

net/http/http_chunked_decoder.cc

 // Copyright (c) 2011 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.
 
 // Derived from:
 //   mozilla/netwerk/protocol/http/src/nsHttpChunkedDecoder.cpp
 // The license block is:
 /* ***** BEGIN LICENSE BLOCK *****
  * Version: MPL 1.1/GPL 2.0/LGPL 2.1
  *
@@ skipping 72 matching lines @@
       if (!chunk_remaining_)
         chunk_terminator_remaining_ = true;
       continue;
     } else if (reached_eof_) {
       bytes_after_eof_ += buf_len;
       break;  // Done!
     }
 
     int bytes_consumed = ScanForChunkRemaining(buf, buf_len);
     if (bytes_consumed < 0)
-      return bytes_consumed; // Error
+      return bytes_consumed;  // Error
 
     buf_len -= bytes_consumed;
     if (buf_len)
       memmove(buf, buf + bytes_consumed, buf_len);
   }
 
   return result;
 }
 
 int HttpChunkedDecoder::ScanForChunkRemaining(const char* buf, int buf_len) {
@@ skipping 27 matching lines @@
         return ERR_INVALID_CHUNKED_ENCODING;
       }
       chunk_terminator_remaining_ = false;
     } else if (buf_len) {
       // Ignore any chunk-extensions.
       size_t index_of_semicolon = base::StringPiece(buf, buf_len).find(';');
       if (index_of_semicolon != base::StringPiece::npos)
         buf_len = static_cast<int>(index_of_semicolon);
 
       if (!ParseChunkSize(buf, buf_len, &chunk_remaining_)) {
-        DLOG(ERROR) << "Failed parsing HEX from: " <<
-            std::string(buf, buf_len);
+        DLOG(ERROR) << "Failed parsing HEX from: " << std::string(buf, buf_len);
         return ERR_INVALID_CHUNKED_ENCODING;
       }
 
       if (chunk_remaining_ == 0)
         reached_last_chunk_ = true;
     } else {
       DLOG(ERROR) << "missing chunk-size";
       return ERR_INVALID_CHUNKED_ENCODING;
     }
     line_buf_.clear();
   } else {
     // Save the partial line; wait for more data.
     bytes_consumed = buf_len;
 
     // Ignore a trailing CR
     if (buf[buf_len - 1] == '\r')
       buf_len--;
 
     if (line_buf_.length() + buf_len > kMaxLineBufLen) {
       DLOG(ERROR) << "Chunked line length too long";
       return ERR_INVALID_CHUNKED_ENCODING;
     }
 
     line_buf_.append(buf, buf_len);
   }
   return bytes_consumed;
 }
 
-
 // While the HTTP 1.1 specification defines chunk-size as 1*HEX
 // some sites rely on more lenient parsing.
 // http://www.yahoo.com/, for example, pads chunk-size with trailing spaces
 // (0x20) to be 7 characters long, such as "819b   ".
 //
 // A comparison of browsers running on WindowsXP shows that
 // they will parse the following inputs (egrep syntax):
 //
 // Let \X be the character class for a hex digit: [0-9a-fA-F]
 //
@@ skipping 10 matching lines @@
 bool HttpChunkedDecoder::ParseChunkSize(const char* start, int len, int* out) {
   DCHECK_GE(len, 0);
 
   // Strip trailing spaces
   while (len && start[len - 1] == ' ')
     len--;
 
   // Be more restrictive than HexStringToInt;
   // don't allow inputs with leading "-", "+", "0x", "0X"
   base::StringPiece chunk_size(start, len);
-  if (chunk_size.find_first_not_of("0123456789abcdefABCDEF")
-      != base::StringPiece::npos) {
+  if (chunk_size.find_first_not_of("0123456789abcdefABCDEF") !=
+      base::StringPiece::npos) {
     return false;
   }
 
   int parsed_number;
   bool ok = base::HexStringToInt(chunk_size, &parsed_number);
   if (ok && parsed_number >= 0) {
     *out = parsed_number;
     return true;
   }
   return false;
 }
 
 }  // namespace net