Clang format slam.

net/http/http_response_headers.h

 // 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.
 
 #ifndef NET_HTTP_HTTP_RESPONSE_HEADERS_H_
 #define NET_HTTP_HTTP_RESPONSE_HEADERS_H_
 
 #include <string>
 #include <vector>
 
@@ skipping 21 matching lines @@
 
 class HttpByteRange;
 
 // HttpResponseHeaders: parses and holds HTTP response headers.
 class NET_EXPORT HttpResponseHeaders
     : public base::RefCountedThreadSafe<HttpResponseHeaders> {
  public:
   // Persist options.
   typedef int PersistOptions;
   static const PersistOptions PERSIST_RAW = -1;  // Raw, unparsed headers.
-  static const PersistOptions PERSIST_ALL = 0;  // Parsed headers.
+  static const PersistOptions PERSIST_ALL = 0;   // Parsed headers.
   static const PersistOptions PERSIST_SANS_COOKIES = 1 << 0;
   static const PersistOptions PERSIST_SANS_CHALLENGES = 1 << 1;
   static const PersistOptions PERSIST_SANS_HOP_BY_HOP = 1 << 2;
   static const PersistOptions PERSIST_SANS_NON_CACHEABLE = 1 << 3;
   static const PersistOptions PERSIST_SANS_RANGES = 1 << 4;
   static const PersistOptions PERSIST_SANS_SECURITY_STATE = 1 << 5;
 
   static const char kContentRange[];
 
   // Parses the given raw_headers.  raw_headers should be formatted thus:
@@ skipping 80 matching lines @@
   // TODO(darin): remove this method
   //
   bool GetNormalizedHeader(const std::string& name, std::string* value) const;
 
   // Returns the normalized status line.  For HTTP/0.9 responses (i.e.,
   // responses that lack a status line), this is the manufactured string
   // "HTTP/0.9 200 OK".
   std::string GetStatusLine() const;
 
   // Get the HTTP version of the normalized status line.
-  HttpVersion GetHttpVersion() const {
-    return http_version_;
-  }
+  HttpVersion GetHttpVersion() const { return http_version_; }
 
   // Get the HTTP version determined while parsing; or (0,0) if parsing failed
-  HttpVersion GetParsedHttpVersion() const {
-    return parsed_http_version_;
-  }
+  HttpVersion GetParsedHttpVersion() const { return parsed_http_version_; }
 
   // Get the HTTP status text of the normalized status line.
   std::string GetStatusText() const;
 
   // Enumerate the "lines" of the response headers.  This skips over the status
   // line.  Use GetStatusLine if you are interested in that.  Note that this
   // method returns the un-coalesced response header lines, so if a response
   // header appears on multiple lines, then it will appear multiple times in
   // this enumeration (in the order the header lines were received from the
   // server).  Also, a given header might have an empty value.  Initialize a
@@ skipping 99 matching lines @@
   // |*last_byte_position| = inclusive position of the last byte of the range
   // |*instance_length| = size in bytes of the object requested
   // If any of the above values is unknown, its value will be -1.
   bool GetContentRange(int64* first_byte_position,
                        int64* last_byte_position,
                        int64* instance_length) const;
 
   // Returns true if the response is chunk-encoded.
   bool IsChunkEncoded() const;
 
-#if defined (SPDY_PROXY_AUTH_ORIGIN)
+#if defined(SPDY_PROXY_AUTH_ORIGIN)
   // Contains instructions contained in the Chrome-Proxy header.
   struct DataReductionProxyInfo {
     DataReductionProxyInfo() : bypass_all(false) {}
 
     // True if Chrome should bypass all available data reduction proxies. False
     // if only the currently connected data reduction proxy should be bypassed.
     bool bypass_all;
 
     // Amount of time to bypass the data reduction proxy or proxies.
     base::TimeDelta bypass_duration;
   };
 
   // Returns true if the Chrome-Proxy header is present and contains a bypass
   // delay. Sets |proxy_info->bypass_duration| to the specified delay if greater
   // than 0, and to 0 otherwise to indicate that the default proxy delay
   // (as specified in |ProxyList::UpdateRetryInfoOnFallback|) should be used.
   // If all available data reduction proxies should by bypassed, |bypass_all| is
   // set to true. |proxy_info| must be non-NULL.
   bool GetDataReductionProxyInfo(DataReductionProxyInfo* proxy_info) const;
 
   // Returns the reason why the Chrome proxy should be bypassed or not, and
   // populates |proxy_info| with information on how long to bypass if
   // applicable.
   ProxyService::DataReductionProxyBypassEventType
-  GetDataReductionProxyBypassEventType(
-      DataReductionProxyInfo* proxy_info) const;
+      GetDataReductionProxyBypassEventType(
+          DataReductionProxyInfo* proxy_info) const;
 
   // Returns true if response headers contain the data reduction proxy Via
   // header value.
   bool IsDataReductionProxyResponse() const;
 #endif
 
   // Creates a Value for use with the NetLog containing the response headers.
   base::Value* NetLogCallback(NetLog::LogLevel log_level) const;
 
   // Takes in a Value created by the above function, and attempts to create a
@@ skipping 118 matching lines @@
 
   // The parsed http version number (not normalized).
   HttpVersion parsed_http_version_;
 
   DISALLOW_COPY_AND_ASSIGN(HttpResponseHeaders);
 };
 
 }  // namespace net
 
 #endif  // NET_HTTP_HTTP_RESPONSE_HEADERS_H_