Clang format slam.

net/url_request/test_url_fetcher_factory.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_TEST_URL_FETCHER_FACTORY_H_
 #define NET_URL_REQUEST_TEST_URL_FETCHER_FACTORY_H_
 
 #include <list>
 #include <map>
 #include <string>
@@ skipping 63 matching lines @@
     virtual void OnRequestStart(int fetcher_id) = 0;
 
     // Callback issued correspondingly to the call to |AppendChunkToUpload|.
     // Uploaded chunks can be retrieved with the |upload_chunks()| getter.
     virtual void OnChunkUpload(int fetcher_id) = 0;
 
     // Callback issued correspondingly to the destructor.
     virtual void OnRequestEnd(int fetcher_id) = 0;
   };
 
-  TestURLFetcher(int id,
-                 const GURL& url,
-                 URLFetcherDelegate* d);
+  TestURLFetcher(int id, const GURL& url, URLFetcherDelegate* d);
   virtual ~TestURLFetcher();
 
   // URLFetcher implementation
   virtual void SetUploadData(const std::string& upload_content_type,
                              const std::string& upload_content) OVERRIDE;
   virtual void SetUploadFilePath(
       const std::string& upload_content_type,
       const base::FilePath& file_path,
       uint64 range_offset,
       uint64 range_length,
@@ skipping 43 matching lines @@
   virtual const GURL& GetOriginalURL() const OVERRIDE;
   virtual const GURL& GetURL() const OVERRIDE;
   virtual const URLRequestStatus& GetStatus() const OVERRIDE;
   virtual int GetResponseCode() const OVERRIDE;
   virtual const ResponseCookies& GetCookies() const OVERRIDE;
   virtual void ReceivedContentWasMalformed() OVERRIDE;
   // Override response access functions to return fake data.
   virtual bool GetResponseAsString(
       std::string* out_response_string) const OVERRIDE;
   virtual bool GetResponseAsFilePath(
-      bool take_ownership, base::FilePath* out_response_path) const OVERRIDE;
+      bool take_ownership,
+      base::FilePath* out_response_path) const OVERRIDE;
 
   void GetExtraRequestHeaders(HttpRequestHeaders* headers) const;
 
   // Sets owner of this class.  Set it to a non-NULL value if you want
   // to automatically unregister this fetcher from the owning factory
   // upon destruction.
   void set_owner(TestURLFetcherFactory* owner) { owner_ = owner; }
 
   // Unique ID in our factory.
   int id() const { return id_; }
@@ skipping 23 matching lines @@
   void SetDelegateForTests(DelegateForTests* delegate_for_tests);
 
   // Set string data.
   void SetResponseString(const std::string& response);
 
   // Set File data.
   void SetResponseFilePath(const base::FilePath& path);
 
  private:
   enum ResponseDestinationType {
-    STRING,  // Default: In a std::string
+    STRING,    // Default: In a std::string
     TEMP_FILE  // Write to a temp file
   };
 
   TestURLFetcherFactory* owner_;
   const int id_;
   const GURL original_url_;
   URLFetcherDelegate* delegate_;
   DelegateForTests* delegate_for_tests_;
   std::string upload_data_;
   base::FilePath upload_file_path_;
@@ skipping 27 matching lines @@
 // Simple URLFetcherFactory method that creates TestURLFetchers. All fetchers
 // are registered in a map by the id passed to the create method.
 // Optionally, a fetcher may be automatically unregistered from the map upon
 // its destruction.
 class TestURLFetcherFactory : public URLFetcherFactory,
                               public ScopedURLFetcherFactory {
  public:
   TestURLFetcherFactory();
   virtual ~TestURLFetcherFactory();
 
-  virtual URLFetcher* CreateURLFetcher(
-      int id,
-      const GURL& url,
-      URLFetcher::RequestType request_type,
-      URLFetcherDelegate* d) OVERRIDE;
+  virtual URLFetcher* CreateURLFetcher(int id,
+                                       const GURL& url,
+                                       URLFetcher::RequestType request_type,
+                                       URLFetcherDelegate* d) OVERRIDE;
   TestURLFetcher* GetFetcherByID(int id) const;
   void RemoveFetcherFromMap(int id);
   void SetDelegateForTests(TestURLFetcherDelegateForTests* delegate_for_tests);
   void set_remove_fetcher_on_delete(bool remove_fetcher_on_delete) {
     remove_fetcher_on_delete_ = remove_fetcher_on_delete;
   }
 
  private:
   // Maps from id passed to create to the returned URLFetcher.
   typedef std::map<int, TestURLFetcher*> Fetchers;
@@ skipping 47 matching lines @@
  private:
   // This is the method which actually calls the delegate that is passed in the
   // constructor.
   void RunDelegate();
 
   base::WeakPtrFactory<FakeURLFetcher> weak_factory_;
 
   DISALLOW_COPY_AND_ASSIGN(FakeURLFetcher);
 };
 
-
 // FakeURLFetcherFactory is a factory for FakeURLFetcher objects. When
 // instantiated, it sets itself up as the default URLFetcherFactory. Fake
 // responses for given URLs can be set using SetFakeResponse.
 //
 // This class is not thread-safe.  You should not call SetFakeResponse or
 // ClearFakeResponse at the same time you call CreateURLFetcher.  However, it is
 // OK to start URLFetcher objects while setting or clearing fake responses
 // since already created URLFetcher objects will not be affected by any changes
 // made to the fake responses (once a URLFetcher object is created you cannot
 // change its fake response).
@@ skipping 37 matching lines @@
   // Parameters to FakeURLFetcherCreator: url, delegate, response_data,
   //                                      response_code
   // |url| URL for instantiated FakeURLFetcher
   // |delegate| Delegate for FakeURLFetcher
   // |response_data| response data for FakeURLFetcher
   // |response_code| response code for FakeURLFetcher
   // |status| URL fetch status for FakeURLFetcher
   // These arguments should by default be used in instantiating FakeURLFetcher
   // like so:
   // new FakeURLFetcher(url, delegate, response_data, response_code, status)
-  typedef base::Callback<scoped_ptr<FakeURLFetcher>(
-      const GURL&,
-      URLFetcherDelegate*,
-      const std::string&,
-      HttpStatusCode,
-      URLRequestStatus::Status)> FakeURLFetcherCreator;
+  typedef base::Callback<scoped_ptr<FakeURLFetcher>(const GURL&,
+                                                    URLFetcherDelegate*,
+                                                    const std::string&,
+                                                    HttpStatusCode,
+                                                    URLRequestStatus::Status)>
+      FakeURLFetcherCreator;
 
   // |default_factory|, which can be NULL, is a URLFetcherFactory that
   // will be used to construct a URLFetcher in case the URL being created
   // has no pre-baked response. If it is NULL, a URLFetcherImpl will be
   // created in this case.
   explicit FakeURLFetcherFactory(URLFetcherFactory* default_factory);
 
   // |default_factory|, which can be NULL, is a URLFetcherFactory that
   // will be used to construct a URLFetcher in case the URL being created
   // has no pre-baked response. If it is NULL, a URLFetcherImpl will be
   // created in this case.
   // |creator| is a callback that returns will be called to create a
   // FakeURLFetcher if a response is found to a given URL. It can be
   // set to MakeFakeURLFetcher.
   FakeURLFetcherFactory(URLFetcherFactory* default_factory,
                         const FakeURLFetcherCreator& creator);
 
   virtual ~FakeURLFetcherFactory();
 
   // If no fake response is set for the given URL this method will delegate the
   // call to |default_factory_| if it is not NULL, or return NULL if it is
   // NULL.
   // Otherwise, it will return a URLFetcher object which will respond with the
   // pre-baked response that the client has set by calling SetFakeResponse().
-  virtual URLFetcher* CreateURLFetcher(
-      int id,
-      const GURL& url,
-      URLFetcher::RequestType request_type,
-      URLFetcherDelegate* d) OVERRIDE;
+  virtual URLFetcher* CreateURLFetcher(int id,
+                                       const GURL& url,
+                                       URLFetcher::RequestType request_type,
+                                       URLFetcherDelegate* d) OVERRIDE;
 
   // Sets the fake response for a given URL. The |response_data| may be empty.
   // The |response_code| may be any HttpStatusCode. For instance, HTTP_OK will
   // return an HTTP/200 and HTTP_INTERNAL_SERVER_ERROR will return an HTTP/500.
   // The |status| argument may be any URLRequestStatus::Status value. Typically,
   // requests that return a valid HttpStatusCode have the SUCCESS status, while
   // requests that indicate a failure to connect to the server have the FAILED
   // status.
   void SetFakeResponse(const GURL& url,
                        const std::string& response_data,
@@ skipping 28 matching lines @@
 // This is an implementation of URLFetcherFactory that will create a
 // URLFetcherImpl. It can be use in conjunction with a FakeURLFetcherFactory in
 // integration tests to control the behavior of some requests but execute
 // all the other ones.
 class URLFetcherImplFactory : public URLFetcherFactory {
  public:
   URLFetcherImplFactory();
   virtual ~URLFetcherImplFactory();
 
   // This method will create a real URLFetcher.
-  virtual URLFetcher* CreateURLFetcher(
-      int id,
-      const GURL& url,
-      URLFetcher::RequestType request_type,
-      URLFetcherDelegate* d) OVERRIDE;
-
+  virtual URLFetcher* CreateURLFetcher(int id,
+                                       const GURL& url,
+                                       URLFetcher::RequestType request_type,
+                                       URLFetcherDelegate* d) OVERRIDE;
 };
 
 }  // namespace net
 
 #endif  // NET_URL_REQUEST_TEST_URL_FETCHER_FACTORY_H_