Clang format slam.

net/url_request/url_fetcher_core.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_FETCHER_CORE_H_
 #define NET_URL_REQUEST_URL_FETCHER_CORE_H_
 
 #include <set>
 #include <string>
 
@@ skipping 18 matching lines @@
 
 namespace net {
 class DrainableIOBuffer;
 class HttpResponseHeaders;
 class IOBuffer;
 class URLFetcherDelegate;
 class URLFetcherResponseWriter;
 class URLRequestContextGetter;
 class URLRequestThrottlerEntryInterface;
 
-class URLFetcherCore
-    : public base::RefCountedThreadSafe<URLFetcherCore>,
-      public URLRequest::Delegate {
+class URLFetcherCore : public base::RefCountedThreadSafe<URLFetcherCore>,
+                       public URLRequest::Delegate {
  public:
   URLFetcherCore(URLFetcher* fetcher,
                  const GURL& original_url,
                  URLFetcher::RequestType request_type,
                  URLFetcherDelegate* d);
 
   // Starts the load.  It's important that this not happen in the constructor
   // because it causes the IO thread to begin AddRef()ing and Release()ing
   // us.  If our caller hasn't had time to fully construct us and take a
   // reference, the IO thread could interrupt things, run a task, Release()
@@ skipping 67 matching lines @@
   void ReceivedContentWasMalformed();
   bool GetResponseAsString(std::string* out_response_string) const;
   bool GetResponseAsFilePath(bool take_ownership,
                              base::FilePath* out_response_path);
 
   // Overridden from URLRequest::Delegate:
   virtual void OnReceivedRedirect(URLRequest* request,
                                   const GURL& new_url,
                                   bool* defer_redirect) OVERRIDE;
   virtual void OnResponseStarted(URLRequest* request) OVERRIDE;
-  virtual void OnReadCompleted(URLRequest* request,
-                               int bytes_read) OVERRIDE;
+  virtual void OnReadCompleted(URLRequest* request, int bytes_read) OVERRIDE;
   virtual void OnCertificateRequested(
       URLRequest* request,
       SSLCertRequestInfo* cert_request_info) OVERRIDE;
 
   URLFetcherDelegate* delegate() const { return delegate_; }
   static void CancelAll();
   static int GetNumFetcherCores();
   static void SetEnableInterceptionForTests(bool enabled);
   static void SetIgnoreCertificateRequests(bool ignored);
 
  private:
   friend class base::RefCountedThreadSafe<URLFetcherCore>;
 
   class Registry {
    public:
     Registry();
     ~Registry();
 
     void AddURLFetcherCore(URLFetcherCore* core);
     void RemoveURLFetcherCore(URLFetcherCore* core);
 
     void CancelAll();
 
-    int size() const {
-      return fetchers_.size();
-    }
+    int size() const { return fetchers_.size(); }
 
    private:
     std::set<URLFetcherCore*> fetchers_;
 
     DISALLOW_COPY_AND_ASSIGN(Registry);
   };
 
   virtual ~URLFetcherCore();
 
   // Wrapper functions that allow us to ensure actions happen on the right
@@ skipping 31 matching lines @@
   // Read response bytes from the request.
   void ReadResponse();
 
   // Notify Delegate about the progress of upload/download.
   void InformDelegateUploadProgress();
   void InformDelegateUploadProgressInDelegateThread(int64 current, int64 total);
   void InformDelegateDownloadProgress();
   void InformDelegateDownloadProgressInDelegateThread(int64 current,
                                                       int64 total);
 
-  URLFetcher* fetcher_;              // Corresponding fetcher object
-  GURL original_url_;                // The URL we were asked to fetch
-  GURL url_;                         // The URL we eventually wound up at
+  URLFetcher* fetcher_;                   // Corresponding fetcher object
+  GURL original_url_;                     // The URL we were asked to fetch
+  GURL url_;                              // The URL we eventually wound up at
   URLFetcher::RequestType request_type_;  // What type of request is this?
-  URLRequestStatus status_;          // Status of the request
-  URLFetcherDelegate* delegate_;     // Object to notify on completion
+  URLRequestStatus status_;               // Status of the request
+  URLFetcherDelegate* delegate_;          // Object to notify on completion
   // Task runner for the creating thread. Used to interact with the delegate.
   scoped_refptr<base::SingleThreadTaskRunner> delegate_task_runner_;
   // Task runner for network operations.
   scoped_refptr<base::SingleThreadTaskRunner> network_task_runner_;
   // Task runner for upload file access.
   scoped_refptr<base::TaskRunner> upload_file_task_runner_;
-  scoped_ptr<URLRequest> request_;   // The actual request this wraps
-  int load_flags_;                   // Flags for the load operation
-  int response_code_;                // HTTP status code for the request
+  scoped_ptr<URLRequest> request_;  // The actual request this wraps
+  int load_flags_;                  // Flags for the load operation
+  int response_code_;               // HTTP status code for the request
   scoped_refptr<IOBuffer> buffer_;
-                                     // Read buffer
+  // Read buffer
   scoped_refptr<URLRequestContextGetter> request_context_getter_;
-                                     // Cookie/cache info for the request
-  GURL first_party_for_cookies_;     // The first party URL for the request
+  // Cookie/cache info for the request
+  GURL first_party_for_cookies_;  // The first party URL for the request
   // The user data to add to each newly-created URLRequest.
   const void* url_request_data_key_;
   URLFetcher::CreateDataCallback url_request_create_data_callback_;
-  ResponseCookies cookies_;          // Response cookies
+  ResponseCookies cookies_;  // Response cookies
   HttpRequestHeaders extra_request_headers_;
   scoped_refptr<HttpResponseHeaders> response_headers_;
   bool was_fetched_via_proxy_;
   HostPortPair socket_address_;
 
   bool upload_content_set_;          // SetUploadData has been called
   std::string upload_content_;       // HTTP POST payload
   base::FilePath upload_file_path_;  // Path to file containing POST payload
   uint64 upload_range_offset_;       // Offset from the beginning of the file
                                      // to be uploaded.
   uint64 upload_range_length_;       // The length of the part of file to be
                                      // uploaded.
   std::string upload_content_type_;  // MIME type of POST payload
   std::string referrer_;             // HTTP Referer header value and policy
   URLRequest::ReferrerPolicy referrer_policy_;
-  bool is_chunked_upload_;           // True if using chunked transfer encoding
+  bool is_chunked_upload_;  // True if using chunked transfer encoding
 
   // Used to determine how long to wait before making a request or doing a
   // retry.
   //
   // Both of them can only be accessed on the IO thread.
   //
   // We need not only the throttler entry for |original_URL|, but also
   // the one for |url|. For example, consider the case that URL A
   // redirects to URL B, for which the server returns a 500
   // response. In this case, the exponential back-off release time of
@@ skipping 58 matching lines @@
   base::debug::StackTrace stack_trace_;
 
   static base::LazyInstance<Registry> g_registry;
 
   DISALLOW_COPY_AND_ASSIGN(URLFetcherCore);
 };
 
 }  // namespace net
 
 #endif  // NET_URL_REQUEST_URL_FETCHER_CORE_H_