Clang format slam.

net/tools/quic/spdy_utils.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/tools/quic/spdy_utils.h"
 
 #include <string>
 
 #include "base/memory/scoped_ptr.h"
 #include "base/strings/string_number_conversions.h"
@@ skipping 16 matching lines @@
 const char* const kV3Path = ":path";
 const char* const kV3Scheme = ":scheme";
 const char* const kV3Status = ":status";
 const char* const kV3Method = ":method";
 const char* const kV3Version = ":version";
 
 void PopulateSpdyHeaderBlock(const BalsaHeaders& headers,
                              SpdyHeaderBlock* block,
                              bool allow_empty_values) {
   for (BalsaHeaders::const_header_lines_iterator hi =
-       headers.header_lines_begin();
+           headers.header_lines_begin();
        hi != headers.header_lines_end();
        ++hi) {
     if ((hi->second.length() == 0) && !allow_empty_values) {
       DVLOG(1) << "Dropping empty header " << hi->first.as_string()
                << " from headers";
       continue;
     }
 
     // This unfortunately involves loads of copying, but its the simplest way
     // to sort the headers and leverage the framer.
@@ skipping 34 matching lines @@
     (*block)[kV3Version] = headers.request_version().as_string();
   }
 }
 
 void PopulateSpdyResponseHeaderBlock(const BalsaHeaders& headers,
                                      SpdyHeaderBlock* block) {
   string status = headers.response_code().as_string();
   status.append(" ");
   status.append(headers.response_reason_phrase().as_string());
   (*block)[kV3Status] = status;
-  (*block)[kV3Version] =
-      headers.response_version().as_string();
+  (*block)[kV3Version] = headers.response_version().as_string();
 
   // Empty header values are only allowed because this is spdy3.
   PopulateSpdyHeaderBlock(headers, block, true);
 }
 
 // static
 SpdyHeaderBlock SpdyUtils::RequestHeadersToSpdyHeaders(
     const BalsaHeaders& request_headers) {
   string scheme;
   string host_and_port;
@@ skipping 54 matching lines @@
 // static
 string SpdyUtils::SerializeUncompressedHeaders(const SpdyHeaderBlock& headers) {
   int length = SpdyFramer::GetSerializedLength(SPDY3, &headers);
   SpdyFrameBuilder builder(length, SPDY3);
   SpdyFramer::WriteHeaderBlock(&builder, SPDY3, &headers);
   scoped_ptr<SpdyFrame> block(builder.take());
   return string(block->data(), length);
 }
 
 bool IsSpecialSpdyHeader(SpdyHeaderBlock::const_iterator header,
-                            BalsaHeaders* headers) {
+                         BalsaHeaders* headers) {
   if (header->first.empty() || header->second.empty()) {
     return true;
   }
   const string& header_name = header->first;
   return header_name.c_str()[0] == ':';
 }
 
-bool SpdyUtils::FillBalsaRequestHeaders(
-    const SpdyHeaderBlock& header_block,
-    BalsaHeaders* request_headers) {
+bool SpdyUtils::FillBalsaRequestHeaders(const SpdyHeaderBlock& header_block,
+                                        BalsaHeaders* request_headers) {
   typedef SpdyHeaderBlock::const_iterator BlockIt;
 
   BlockIt host_it = header_block.find(kV3Host);
   BlockIt path_it = header_block.find(kV3Path);
   BlockIt scheme_it = header_block.find(kV3Scheme);
   BlockIt method_it = header_block.find(kV3Method);
   BlockIt end_it = header_block.end();
   if (host_it == end_it || path_it == end_it || scheme_it == end_it ||
       method_it == end_it) {
     return false;
   }
   string url = scheme_it->second;
   url.append("://");
   url.append(host_it->second);
   url.append(path_it->second);
   request_headers->SetRequestUri(url);
   request_headers->SetRequestMethod(method_it->second);
 
   BlockIt cl_it = header_block.find("content-length");
   if (cl_it != header_block.end()) {
     int content_length;
     if (!base::StringToInt(cl_it->second, &content_length)) {
       return false;
     }
     request_headers->SetContentLength(content_length);
   }
 
   for (BlockIt it = header_block.begin(); it != header_block.end(); ++it) {
-   if (!IsSpecialSpdyHeader(it, request_headers)) {
-     request_headers->AppendHeader(it->first, it->second);
-   }
+    if (!IsSpecialSpdyHeader(it, request_headers)) {
+      request_headers->AppendHeader(it->first, it->second);
+    }
   }
 
   return true;
 }
 
 // The reason phrase should match regexp [\d\d\d [^\r\n]+].  If not, we will
 // fail to parse it.
 bool ParseReasonAndStatus(StringPiece status_and_reason,
                           BalsaHeaders* headers) {
   if (status_and_reason.size() < 5)
@@ skipping 11 matching lines @@
   headers->SetResponseCode(status_str);
   headers->set_parsed_response_code(status);
 
   StringPiece reason(status_and_reason.data() + 4,
                      status_and_reason.length() - 4);
 
   headers->SetResponseReasonPhrase(reason);
   return true;
 }
 
-bool SpdyUtils::FillBalsaResponseHeaders(
-    const SpdyHeaderBlock& header_block,
-    BalsaHeaders* request_headers) {
+bool SpdyUtils::FillBalsaResponseHeaders(const SpdyHeaderBlock& header_block,
+                                         BalsaHeaders* request_headers) {
   typedef SpdyHeaderBlock::const_iterator BlockIt;
 
   BlockIt status_it = header_block.find(kV3Status);
   BlockIt version_it = header_block.find(kV3Version);
   BlockIt end_it = header_block.end();
   if (status_it == end_it || version_it == end_it) {
     return false;
   }
 
   if (!ParseReasonAndStatus(status_it->second, request_headers)) {
     return false;
   }
   request_headers->SetResponseVersion(version_it->second);
   for (BlockIt it = header_block.begin(); it != header_block.end(); ++it) {
-   if (!IsSpecialSpdyHeader(it, request_headers)) {
-     request_headers->AppendHeader(it->first, it->second);
-   }
+    if (!IsSpecialSpdyHeader(it, request_headers)) {
+      request_headers->AppendHeader(it->first, it->second);
+    }
   }
   return true;
 }
 
 }  // namespace tools
 }  // namespace net