Clang format slam.

net/spdy/spdy_http_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/spdy/spdy_http_utils.h"
 
 #include <string>
 
 #include "base/strings/string_number_conversions.h"
 #include "base/strings/string_util.h"
@@ skipping 70 matching lines @@
   response->headers = new HttpResponseHeaders(raw_headers);
   response->was_fetched_via_spdy = true;
   return true;
 }
 
 void CreateSpdyHeadersFromHttpRequest(const HttpRequestInfo& info,
                                       const HttpRequestHeaders& request_headers,
                                       SpdyHeaderBlock* headers,
                                       SpdyMajorVersion protocol_version,
                                       bool direct) {
-
   HttpRequestHeaders::Iterator it(request_headers);
   while (it.GetNext()) {
     std::string name = StringToLowerASCII(it.name());
     if (name == "connection" || name == "proxy-connection" ||
         name == "transfer-encoding" || name == "host") {
       continue;
     }
     if (headers->find(name) == headers->end()) {
       (*headers)[name] = it.value();
     } else {
@@ skipping 20 matching lines @@
       (*headers)[":host"] = GetHostAndOptionalPort(info.url);
     } else {
       (*headers)[":authority"] = GetHostAndOptionalPort(info.url);
     }
     (*headers)[":method"] = info.method;
     (*headers)[":scheme"] = info.url.scheme();
     (*headers)[":path"] = HttpUtil::PathForRequest(info.url);
   }
 }
 
-COMPILE_ASSERT(HIGHEST - LOWEST < 4 &&
-               HIGHEST - MINIMUM_PRIORITY < 5,
+COMPILE_ASSERT(HIGHEST - LOWEST < 4 && HIGHEST - MINIMUM_PRIORITY < 5,
                request_priority_incompatible_with_spdy);
 
 SpdyPriority ConvertRequestPriorityToSpdyPriority(
     const RequestPriority priority,
     SpdyMajorVersion protocol_version) {
   DCHECK_GE(priority, MINIMUM_PRIORITY);
   DCHECK_LE(priority, MAXIMUM_PRIORITY);
   if (protocol_version == SPDY2) {
     // SPDY 2 only has 2 bits of priority, but we have 5 RequestPriorities.
     // Map IDLE => 3, LOWEST => 2, LOW => 2, MEDIUM => 1, HIGHEST => 0.
     if (priority > LOWEST) {
       return static_cast<SpdyPriority>(HIGHEST - priority);
     } else {
       return static_cast<SpdyPriority>(HIGHEST - priority - 1);
     }
   } else {
     return static_cast<SpdyPriority>(HIGHEST - priority);
   }
 }
 
-NET_EXPORT_PRIVATE RequestPriority ConvertSpdyPriorityToRequestPriority(
-    SpdyPriority priority,
-    SpdyMajorVersion protocol_version) {
+NET_EXPORT_PRIVATE RequestPriority
+ConvertSpdyPriorityToRequestPriority(SpdyPriority priority,
+                                     SpdyMajorVersion protocol_version) {
   // Handle invalid values gracefully, and pick LOW to map 2 back
   // to for SPDY/2.
   SpdyPriority idle_cutoff = (protocol_version == SPDY2) ? 3 : 5;
-  return (priority >= idle_cutoff) ?
-      IDLE : static_cast<RequestPriority>(HIGHEST - priority);
+  return (priority >= idle_cutoff)
+             ? IDLE
+             : static_cast<RequestPriority>(HIGHEST - priority);
 }
 
 GURL GetUrlFromHeaderBlock(const SpdyHeaderBlock& headers,
                            SpdyMajorVersion protocol_version,
                            bool pushed) {
   // SPDY 2 server push urls are specified in a single "url" header.
   if (pushed && protocol_version == SPDY2) {
-      std::string url;
-      SpdyHeaderBlock::const_iterator it;
-      it = headers.find("url");
-      if (it != headers.end())
-        url = it->second;
-      return GURL(url);
+    std::string url;
+    SpdyHeaderBlock::const_iterator it;
+    it = headers.find("url");
+    if (it != headers.end())
+      url = it->second;
+    return GURL(url);
   }
 
   const char* scheme_header = protocol_version >= SPDY3 ? ":scheme" : "scheme";
-  const char* host_header = protocol_version >= SPDY4 ? ":authority" :
-      (protocol_version >= SPDY3 ? ":host" : "host");
+  const char* host_header =
+      protocol_version >= SPDY4
+          ? ":authority"
+          : (protocol_version >= SPDY3 ? ":host" : "host");
   const char* path_header = protocol_version >= SPDY3 ? ":path" : "url";
 
   std::string scheme;
   std::string host_port;
   std::string path;
   SpdyHeaderBlock::const_iterator it;
   it = headers.find(scheme_header);
   if (it != headers.end())
     scheme = it->second;
   it = headers.find(host_header);
   if (it != headers.end())
     host_port = it->second;
   it = headers.find(path_header);
   if (it != headers.end())
     path = it->second;
 
   std::string url = (scheme.empty() || host_port.empty() || path.empty())
                         ? std::string()
                         : scheme + "://" + host_port + path;
   return GURL(url);
 }
 
 }  // namespace net