Clang format slam.

net/url_request/url_request.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_URL_REQUEST_URL_REQUEST_H_
 #define NET_URL_REQUEST_URL_REQUEST_H_
 
 #include <string>
 #include <vector>
 
@@ skipping 74 matching lines @@
 //
 // NOTE: All usage of all instances of this class should be on the same thread.
 //
 class NET_EXPORT URLRequest : NON_EXPORTED_BASE(public base::NonThreadSafe),
                               public base::SupportsUserData {
  public:
   // Callback function implemented by protocol handlers to create new jobs.
   // The factory may return NULL to indicate an error, which will cause other
   // factories to be queried.  If no factory handles the request, then the
   // default job will be used.
-  typedef URLRequestJob* (ProtocolFactory)(URLRequest* request,
-                                           NetworkDelegate* network_delegate,
-                                           const std::string& scheme);
+  typedef URLRequestJob*(ProtocolFactory)(URLRequest* request,
+                                          NetworkDelegate* network_delegate,
+                                          const std::string& scheme);
 
   // HTTP request/response header IDs (via some preprocessor fun) for use with
   // SetRequestHeaderById and GetResponseHeaderById.
   enum {
-#define HTTP_ATOM(x) HTTP_ ## x,
+#define HTTP_ATOM(x) HTTP_##x,
 #include "net/http/http_atom_list.h"
 #undef HTTP_ATOM
   };
 
   // Referrer policies (see set_referrer_policy): During server redirects, the
   // referrer header might be cleared, if the protocol changes from HTTPS to
   // HTTP. This is the default behavior of URLRequest, corresponding to
   // CLEAR_REFERRER_ON_TRANSITION_FROM_SECURE_TO_INSECURE. Alternatively, the
   // referrer policy can be set to never change the referrer header. This
   // behavior corresponds to NEVER_CLEAR_REFERRER. Embedders will want to use
   // NEVER_CLEAR_REFERRER when implementing the meta-referrer support
   // (http://wiki.whatwg.org/wiki/Meta_referrer) and sending requests with a
   // non-default referrer policy. Only the default referrer policy requires
   // the referrer to be cleared on transitions from HTTPS to HTTP.
   enum ReferrerPolicy {
     CLEAR_REFERRER_ON_TRANSITION_FROM_SECURE_TO_INSECURE,
     NEVER_CLEAR_REFERRER,
   };
 
   // This class handles network interception.  Use with
   // (Un)RegisterRequestInterceptor.
   class NET_EXPORT Interceptor {
-  public:
+   public:
     virtual ~Interceptor() {}
 
     // Called for every request made.  Should return a new job to handle the
     // request if it should be intercepted, or NULL to allow the request to
     // be handled in the normal manner.
     virtual URLRequestJob* MaybeIntercept(
-        URLRequest* request, NetworkDelegate* network_delegate) = 0;
+        URLRequest* request,
+        NetworkDelegate* network_delegate) = 0;
 
     // Called after having received a redirect response, but prior to the
     // the request delegate being informed of the redirect. Can return a new
     // job to replace the existing job if it should be intercepted, or NULL
     // to allow the normal handling to continue. If a new job is provided,
     // the delegate never sees the original redirect response, instead the
     // response produced by the intercept job will be returned.
     virtual URLRequestJob* MaybeInterceptRedirect(
         URLRequest* request,
         NetworkDelegate* network_delegate,
         const GURL& location);
 
     // Called after having received a final response, but prior to the
     // the request delegate being informed of the response. This is also
     // called when there is no server response at all to allow interception
     // on dns or network errors. Can return a new job to replace the existing
     // job if it should be intercepted, or NULL to allow the normal handling to
     // continue. If a new job is provided, the delegate never sees the original
     // response, instead the response produced by the intercept job will be
     // returned.
     virtual URLRequestJob* MaybeInterceptResponse(
-        URLRequest* request, NetworkDelegate* network_delegate);
+        URLRequest* request,
+        NetworkDelegate* network_delegate);
   };
 
   // Deprecated interfaces in net::URLRequest. They have been moved to
   // URLRequest's private section to prevent new uses. Existing uses are
   // explicitly friended here and should be removed over time.
   class NET_EXPORT Deprecated {
    private:
     // TODO(willchan): Kill off these friend declarations.
     friend class ::ChildProcessSecurityPolicyTest;
     friend class TestInterceptor;
@@ skipping 70 matching lines @@
     // When it does so, the request will be reissued, restarting the sequence
     // of On* callbacks.
     virtual void OnAuthRequired(URLRequest* request,
                                 AuthChallengeInfo* auth_info);
 
     // Called when we receive an SSL CertificateRequest message for client
     // authentication.  The delegate should call
     // request->ContinueWithCertificate() with the client certificate the user
     // selected, or request->ContinueWithCertificate(NULL) to continue the SSL
     // handshake without a client certificate.
-    virtual void OnCertificateRequested(
-        URLRequest* request,
-        SSLCertRequestInfo* cert_request_info);
+    virtual void OnCertificateRequested(URLRequest* request,
+                                        SSLCertRequestInfo* cert_request_info);
 
     // Called when using SSL and the server responds with a certificate with
     // an error, for example, whose common name does not match the common name
     // we were expecting for that host.  The delegate should either do the
     // safe thing and Cancel() the request or decide to proceed by calling
     // ContinueDespiteLastError().  cert_error is a ERR_* error code
     // indicating what's wrong with the certificate.
     // If |fatal| is true then the host in question demands a higher level
     // of security (due e.g. to HTTP Strict Transport Security, user
     // preference, or built-in policy). In this case, errors must not be
@@ skipping 140 matching lines @@
 
   // Gets the upload data.
   const UploadDataStream* get_upload() const;
 
   // Returns true if the request has a non-empty message body to upload.
   bool has_upload() const;
 
   // Set an extra request header by ID or name, or remove one by name.  These
   // methods may only be called before Start() is called, or before a new
   // redirect in the request chain.
-  void SetExtraRequestHeaderById(int header_id, const std::string& value,
+  void SetExtraRequestHeaderById(int header_id,
+                                 const std::string& value,
                                  bool overwrite);
   void SetExtraRequestHeaderByName(const std::string& name,
-                                   const std::string& value, bool overwrite);
+                                   const std::string& value,
+                                   bool overwrite);
   void RemoveRequestHeaderByName(const std::string& name);
 
   // Sets all extra request headers.  Any extra request headers set by other
   // methods are overwritten by this method.  This method may only be called
   // before Start() is called.  It is an error to call it later.
   void SetExtraRequestHeaders(const HttpRequestHeaders& headers);
 
   const HttpRequestHeaders& extra_request_headers() const {
     return extra_request_headers_;
   }
@@ skipping 58 matching lines @@
 
   // Get all response headers, \n-delimited and \n\0-terminated.  This includes
   // the response status line.  Restrictions on GetResponseHeaders apply.
   void GetAllResponseHeaders(std::string* headers);
 
   // The time when |this| was constructed.
   base::TimeTicks creation_time() const { return creation_time_; }
 
   // The time at which the returned response was requested.  For cached
   // responses, this is the last time the cache entry was validated.
-  const base::Time& request_time() const {
-    return response_info_.request_time;
-  }
+  const base::Time& request_time() const { return response_info_.request_time; }
 
   // The time at which the returned response was generated.  For cached
   // responses, this is the last time the cache entry was validated.
   const base::Time& response_time() const {
     return response_info_.response_time;
   }
 
   // Indicate if this response was fetched from disk cache.
   bool was_cached() const { return response_info_.was_cached; }
 
   // Returns true if the URLRequest was delivered through a proxy.
   bool was_fetched_via_proxy() const {
     return response_info_.was_fetched_via_proxy;
   }
 
   // Returns true if the URLRequest was delivered over SPDY.
   bool was_fetched_via_spdy() const {
     return response_info_.was_fetched_via_spdy;
   }
 
   // Returns the host and port that the content was fetched from.  See
   // http_response_info.h for caveats relating to cached content.
   HostPortPair GetSocketAddress() const;
 
   // Get all response headers, as a HttpResponseHeaders object.  See comments
   // in HttpResponseHeaders class as to the format of the data.
   HttpResponseHeaders* response_headers() const;
 
   // Get the SSL connection info.
-  const SSLInfo& ssl_info() const {
-    return response_info_.ssl_info;
-  }
+  const SSLInfo& ssl_info() const { return response_info_.ssl_info; }
 
   // Gets timing information related to the request.  Events that have not yet
   // occurred are left uninitialized.  After a second request starts, due to
   // a redirect or authentication, values will be reset.
   //
   // LoadTimingInfo only contains ConnectTiming information and socket IDs for
   // non-cached HTTP responses.
   void GetLoadTimingInfo(LoadTimingInfo* load_timing_info) const;
 
   // Returns the cookie values included in the response, if the request is one
@@ skipping 378 matching lines @@
 
   // The cookie store to be used for this request.
   scoped_refptr<CookieStore> cookie_store_;
 
   DISALLOW_COPY_AND_ASSIGN(URLRequest);
 };
 
 }  // namespace net
 
 #endif  // NET_URL_REQUEST_URL_REQUEST_H_