Clang format slam.

net/url_request/url_fetcher_impl_unittest.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/url_request/url_fetcher_impl.h"
 
 #include <algorithm>
 #include <string>
 
 #include "base/bind.h"
@@ skipping 45 matching lines @@
   URLRequestThrottlerManager throttler_manager_;
 };
 
 class ThrottlingTestURLRequestContextGetter
     : public TestURLRequestContextGetter {
  public:
   ThrottlingTestURLRequestContextGetter(
       base::MessageLoopProxy* io_message_loop_proxy,
       TestURLRequestContext* request_context)
       : TestURLRequestContextGetter(io_message_loop_proxy),
-        context_(request_context) {
-  }
+        context_(request_context) {}
 
   // TestURLRequestContextGetter:
   virtual TestURLRequestContext* GetURLRequestContext() OVERRIDE {
     return context_;
   }
 
  protected:
   virtual ~ThrottlingTestURLRequestContextGetter() {}
 
   TestURLRequestContext* const context_;
 };
 
 }  // namespace
 
-class URLFetcherTest : public testing::Test,
-                       public URLFetcherDelegate {
+class URLFetcherTest : public testing::Test, public URLFetcherDelegate {
  public:
   URLFetcherTest() : fetcher_(NULL) {}
 
   static int GetNumFetcherCores() {
     return URLFetcherImpl::GetNumFetcherCores();
   }
 
   // Creates a URLFetcher, using the program's main thread to do IO.
   virtual void CreateFetcher(const GURL& url);
 
   // URLFetcherDelegate:
   // Subclasses that override this should either call this function or
   // CleanupAfterFetchComplete() at the end of their processing, depending on
   // whether they want to check for a non-empty HTTP 200 response or not.
   virtual void OnURLFetchComplete(const URLFetcher* source) OVERRIDE;
 
   // Deletes |fetcher| and terminates the message loop.
   void CleanupAfterFetchComplete();
 
   scoped_refptr<base::MessageLoopProxy> io_message_loop_proxy() {
     return io_message_loop_proxy_;
   }
 
-  TestURLRequestContext* request_context() {
-    return context_.get();
-  }
+  TestURLRequestContext* request_context() { return context_.get(); }
 
  protected:
   // testing::Test:
   virtual void SetUp() OVERRIDE {
     testing::Test::SetUp();
 
     context_.reset(new ThrottlingTestURLRequestContext());
     io_message_loop_proxy_ = base::MessageLoopProxy::current();
 
 #if defined(USE_NSS) || defined(OS_IOS)
@@ skipping 78 matching lines @@
   context_->Init();
 
   test_server_.reset(new SpawnedTestServer(SpawnedTestServer::TYPE_HTTP,
                                            SpawnedTestServer::kLocalhost,
                                            base::FilePath(kDocRoot)));
   ASSERT_TRUE(test_server_->Start());
 
   // test_server_.GetURL() returns a URL with 127.0.0.1 (kLocalhost), that is
   // immediately resolved by the MockHostResolver. Use a hostname instead to
   // trigger an async resolve.
-  test_url_ = GURL(
-      base::StringPrintf("http://example.com:%d/defaultresponse",
-      test_server_->host_port_pair().port()));
+  test_url_ = GURL(base::StringPrintf("http://example.com:%d/defaultresponse",
+                                      test_server_->host_port_pair().port()));
   ASSERT_TRUE(test_url_.is_valid());
 }
 
 void URLFetcherMockDnsTest::CreateFetcher(const GURL& url) {
   fetcher_ = new URLFetcherImpl(url, URLFetcher::GET, this);
   fetcher_->SetRequestContext(new ThrottlingTestURLRequestContextGetter(
       io_message_loop_proxy().get(), request_context()));
 }
 
 void URLFetcherMockDnsTest::OnURLFetchComplete(const URLFetcher* source) {
@@ skipping 46 matching lines @@
   virtual void CreateFetcher(const GURL& url) OVERRIDE;
 
   // URLFetcherDelegate:
   virtual void OnURLFetchComplete(const URLFetcher* source) OVERRIDE;
 };
 
 // Version of URLFetcherTest that tests download progress reports.
 class URLFetcherDownloadProgressTest : public URLFetcherTest {
  public:
   URLFetcherDownloadProgressTest()
-      : previous_progress_(0),
-        expected_total_(0) {
-  }
+      : previous_progress_(0), expected_total_(0) {}
 
   // URLFetcherTest:
   virtual void CreateFetcher(const GURL& url) OVERRIDE;
 
   // URLFetcherDelegate:
   virtual void OnURLFetchDownloadProgress(const URLFetcher* source,
                                           int64 current,
                                           int64 total) OVERRIDE;
 
  protected:
   // Download progress returned by the previous callback.
   int64 previous_progress_;
   // Size of the file being downloaded, known in advance (provided by each test
   // case).
   int64 expected_total_;
 };
 
 // Version of URLFetcherTest that tests progress reports at cancellation.
 class URLFetcherDownloadProgressCancelTest : public URLFetcherTest {
  public:
   // URLFetcherTest:
   virtual void CreateFetcher(const GURL& url) OVERRIDE;
 
   // URLFetcherDelegate:
   virtual void OnURLFetchComplete(const URLFetcher* source) OVERRIDE;
   virtual void OnURLFetchDownloadProgress(const URLFetcher* source,
                                           int64 current,
                                           int64 total) OVERRIDE;
+
  protected:
   bool cancelled_;
 };
 
 // Version of URLFetcherTest that tests upload progress reports.
 class URLFetcherUploadProgressTest : public URLFetcherTest {
  public:
   // URLFetcherTest:
   virtual void CreateFetcher(const GURL& url) OVERRIDE;
 
   // URLFetcherDelegate:
   virtual void OnURLFetchUploadProgress(const URLFetcher* source,
                                         int64 current,
                                         int64 total) OVERRIDE;
+
  protected:
   int64 previous_progress_;
   std::string chunk_;
   int64 number_of_chunks_added_;
 };
 
 // Version of URLFetcherTest that tests headers.
 class URLFetcherHeadersTest : public URLFetcherTest {
  public:
   // URLFetcherDelegate:
   virtual void OnURLFetchComplete(const URLFetcher* source) OVERRIDE;
 };
 
 // Version of URLFetcherTest that tests SocketAddress.
 class URLFetcherSocketAddressTest : public URLFetcherTest {
  public:
   // URLFetcherDelegate:
   virtual void OnURLFetchComplete(const URLFetcher* source) OVERRIDE;
+
  protected:
   std::string expected_host_;
   uint16 expected_port_;
 };
 
 // Version of URLFetcherTest that tests stopping on a redirect.
 class URLFetcherStopOnRedirectTest : public URLFetcherTest {
  public:
   URLFetcherStopOnRedirectTest();
   virtual ~URLFetcherStopOnRedirectTest();
@@ skipping 12 matching lines @@
 };
 
 // Version of URLFetcherTest that tests overload protection.
 class URLFetcherProtectTest : public URLFetcherTest {
  public:
   // URLFetcherTest:
   virtual void CreateFetcher(const GURL& url) OVERRIDE;
 
   // URLFetcherDelegate:
   virtual void OnURLFetchComplete(const URLFetcher* source) OVERRIDE;
+
  private:
   Time start_time_;
 };
 
 // Version of URLFetcherTest that tests overload protection, when responses
 // passed through.
 class URLFetcherProtectTestPassedThrough : public URLFetcherTest {
  public:
   // URLFetcherTest:
   virtual void CreateFetcher(const GURL& url) OVERRIDE;
 
   // URLFetcherDelegate:
   virtual void OnURLFetchComplete(const URLFetcher* source) OVERRIDE;
+
  private:
   Time start_time_;
 };
 
 // Version of URLFetcherTest that tests bad HTTPS requests.
 class URLFetcherBadHTTPSTest : public URLFetcherTest {
  public:
   URLFetcherBadHTTPSTest();
 
   // URLFetcherDelegate:
@@ skipping 12 matching lines @@
   // URLFetcherDelegate:
   virtual void OnURLFetchComplete(const URLFetcher* source) OVERRIDE;
 
   void CancelRequest();
 };
 
 // Version of TestURLRequestContext that posts a Quit task to the IO
 // thread once it is deleted.
 class CancelTestURLRequestContext : public ThrottlingTestURLRequestContext {
  public:
-  explicit CancelTestURLRequestContext() {
-  }
+  explicit CancelTestURLRequestContext() {}
 
  private:
   virtual ~CancelTestURLRequestContext() {
     // The d'tor should execute in the IO thread. Post the quit task to the
     // current thread.
     base::MessageLoop::current()->PostTask(FROM_HERE,
                                            base::MessageLoop::QuitClosure());
   }
 };
 
-class CancelTestURLRequestContextGetter
-    : public TestURLRequestContextGetter {
+class CancelTestURLRequestContextGetter : public TestURLRequestContextGetter {
  public:
   CancelTestURLRequestContextGetter(
       base::MessageLoopProxy* io_message_loop_proxy,
       const GURL& throttle_for_url)
       : TestURLRequestContextGetter(io_message_loop_proxy),
         io_message_loop_proxy_(io_message_loop_proxy),
         context_created_(false, false),
-        throttle_for_url_(throttle_for_url) {
-  }
+        throttle_for_url_(throttle_for_url) {}
 
   // TestURLRequestContextGetter:
   virtual TestURLRequestContext* GetURLRequestContext() OVERRIDE {
     if (!context_.get()) {
       context_.reset(new CancelTestURLRequestContext());
       DCHECK(context_->throttler_manager());
 
       // Registers an entry for test url. The backoff time is calculated by:
       //     new_backoff = 2.0 * old_backoff + 0
       // The initial backoff is 2 seconds and maximum backoff is 4 seconds.
       // Maximum retries allowed is set to 2.
       scoped_refptr<URLRequestThrottlerEntry> entry(
           new URLRequestThrottlerEntry(context_->throttler_manager(),
                                        std::string(),
                                        200,
                                        3,
                                        2000,
                                        2.0,
                                        0.0,
                                        4000));
-      context_->throttler_manager()
-          ->OverrideEntryForTests(throttle_for_url_, entry.get());
+      context_->throttler_manager()->OverrideEntryForTests(throttle_for_url_,
+                                                           entry.get());
 
       context_created_.Signal();
     }
     return context_.get();
   }
 
   virtual scoped_refptr<base::MessageLoopProxy> GetIOMessageLoopProxy() const {
     return io_message_loop_proxy_;
   }
 
-  void WaitForContextCreation() {
-    context_created_.Wait();
-  }
+  void WaitForContextCreation() { context_created_.Wait(); }
 
  protected:
   virtual ~CancelTestURLRequestContextGetter() {}
 
  private:
   scoped_ptr<TestURLRequestContext> context_;
   scoped_refptr<base::MessageLoopProxy> io_message_loop_proxy_;
   base::WaitableEvent context_created_;
   GURL throttle_for_url_;
 };
 
 // Version of URLFetcherTest that tests retying the same request twice.
 class URLFetcherMultipleAttemptTest : public URLFetcherTest {
  public:
   // URLFetcherDelegate:
   virtual void OnURLFetchComplete(const URLFetcher* source) OVERRIDE;
+
  private:
   std::string data_;
 };
 
 class URLFetcherFileTest : public URLFetcherTest {
  public:
-  URLFetcherFileTest() : take_ownership_of_file_(false),
-                         expected_file_error_(OK) {}
+  URLFetcherFileTest()
+      : take_ownership_of_file_(false), expected_file_error_(OK) {}
 
   void CreateFetcherForFile(const GURL& url, const base::FilePath& file_path);
   void CreateFetcherForTempFile(const GURL& url);
 
   // URLFetcherDelegate:
   virtual void OnURLFetchComplete(const URLFetcher* source) OVERRIDE;
 
  protected:
   base::FilePath expected_file_;
   base::FilePath file_path_;
@@ skipping 16 matching lines @@
 }
 
 void URLFetcherPostTest::OnURLFetchComplete(const URLFetcher* source) {
   std::string data;
   EXPECT_TRUE(source->GetResponseAsString(&data));
   EXPECT_EQ(std::string("bobsyeruncle"), data);
   URLFetcherTest::OnURLFetchComplete(source);
 }
 
 URLFetcherPostFileTest::URLFetcherPostFileTest()
-    : range_offset_(0),
-      range_length_(kuint64max) {
+    : range_offset_(0), range_length_(kuint64max) {
   PathService::Get(base::DIR_SOURCE_ROOT, &path_);
   path_ = path_.Append(FILE_PATH_LITERAL("net"));
   path_ = path_.Append(FILE_PATH_LITERAL("data"));
   path_ = path_.Append(FILE_PATH_LITERAL("url_request_unittest"));
   path_ = path_.Append(FILE_PATH_LITERAL("BullRunSpeech.txt"));
 }
 
 void URLFetcherPostFileTest::CreateFetcher(const GURL& url) {
   fetcher_ = new URLFetcherImpl(url, URLFetcher::POST, this);
   fetcher_->SetRequestContext(new ThrottlingTestURLRequestContextGetter(
@@ skipping 14 matching lines @@
       std::min(range_length_, expected.size() - range_offset_);
 
   std::string data;
   EXPECT_TRUE(source->GetResponseAsString(&data));
   EXPECT_EQ(expected.substr(range_offset_, expected_size), data);
   URLFetcherTest::OnURLFetchComplete(source);
 }
 
 void URLFetcherEmptyPostTest::CreateFetcher(const GURL& url) {
   fetcher_ = new URLFetcherImpl(url, URLFetcher::POST, this);
-  fetcher_->SetRequestContext(new TestURLRequestContextGetter(
-      io_message_loop_proxy()));
+  fetcher_->SetRequestContext(
+      new TestURLRequestContextGetter(io_message_loop_proxy()));
   fetcher_->SetUploadData("text/plain", std::string());
   fetcher_->Start();
 }
 
 void URLFetcherEmptyPostTest::OnURLFetchComplete(const URLFetcher* source) {
   EXPECT_TRUE(source->GetStatus().is_success());
   EXPECT_EQ(200, source->GetResponseCode());  // HTTP OK
 
   std::string data;
   EXPECT_TRUE(source->GetResponseAsString(&data));
   EXPECT_TRUE(data.empty());
 
   CleanupAfterFetchComplete();
   // Do not call the super class method URLFetcherTest::OnURLFetchComplete,
   // since it expects a non-empty response.
 }
 
 void URLFetcherDownloadProgressTest::CreateFetcher(const GURL& url) {
   fetcher_ = new URLFetcherImpl(url, URLFetcher::GET, this);
   fetcher_->SetRequestContext(new ThrottlingTestURLRequestContextGetter(
       io_message_loop_proxy().get(), request_context()));
   fetcher_->Start();
 }
 
 void URLFetcherDownloadProgressTest::OnURLFetchDownloadProgress(
-    const URLFetcher* source, int64 progress, int64 total) {
+    const URLFetcher* source,
+    int64 progress,
+    int64 total) {
   // Increasing between 0 and total.
   EXPECT_LE(0, progress);
   EXPECT_GE(total, progress);
   EXPECT_LE(previous_progress_, progress);
   EXPECT_EQ(expected_total_, total);
   previous_progress_ = progress;
 }
 
 void URLFetcherDownloadProgressCancelTest::CreateFetcher(const GURL& url) {
   fetcher_ = new URLFetcherImpl(url, URLFetcher::GET, this);
   fetcher_->SetRequestContext(new ThrottlingTestURLRequestContextGetter(
       io_message_loop_proxy().get(), request_context()));
   cancelled_ = false;
   fetcher_->Start();
 }
 
 void URLFetcherDownloadProgressCancelTest::OnURLFetchDownloadProgress(
-    const URLFetcher* source, int64 current, int64 total) {
+    const URLFetcher* source,
+    int64 current,
+    int64 total) {
   EXPECT_FALSE(cancelled_);
   if (!cancelled_) {
     cancelled_ = true;
     CleanupAfterFetchComplete();
   }
 }
 
 void URLFetcherDownloadProgressCancelTest::OnURLFetchComplete(
     const URLFetcher* source) {
   // Should have been cancelled.
   ADD_FAILURE();
   CleanupAfterFetchComplete();
 }
 
 void URLFetcherUploadProgressTest::CreateFetcher(const GURL& url) {
   fetcher_ = new URLFetcherImpl(url, URLFetcher::POST, this);
   fetcher_->SetRequestContext(new ThrottlingTestURLRequestContextGetter(
       io_message_loop_proxy().get(), request_context()));
   previous_progress_ = 0;
   // Large enough data to require more than one read from UploadDataStream.
-  chunk_.assign(1<<16, 'a');
+  chunk_.assign(1 << 16, 'a');
   // Use chunked upload to wait for a timer event of progress notification.
   fetcher_->SetChunkedUpload("application/x-www-form-urlencoded");
   fetcher_->Start();
   number_of_chunks_added_ = 1;
   fetcher_->AppendChunkToUpload(chunk_, false);
 }
 
 void URLFetcherUploadProgressTest::OnURLFetchUploadProgress(
-    const URLFetcher* source, int64 current, int64 total) {
+    const URLFetcher* source,
+    int64 current,
+    int64 total) {
   // Increasing between 0 and total.
   EXPECT_LE(0, current);
   EXPECT_GE(static_cast<int64>(chunk_.size()) * number_of_chunks_added_,
             current);
   EXPECT_LE(previous_progress_, current);
   previous_progress_ = current;
   EXPECT_EQ(-1, total);
 
   if (number_of_chunks_added_ < 2) {
     number_of_chunks_added_ += 1;
     fetcher_->AppendChunkToUpload(chunk_, true);
   }
 }
 
-void URLFetcherHeadersTest::OnURLFetchComplete(
-    const URLFetcher* source) {
+void URLFetcherHeadersTest::OnURLFetchComplete(const URLFetcher* source) {
   std::string header;
   EXPECT_TRUE(source->GetResponseHeaders()->GetNormalizedHeader("cache-control",
                                                                 &header));
   EXPECT_EQ("private", header);
   URLFetcherTest::OnURLFetchComplete(source);
 }
 
-void URLFetcherSocketAddressTest::OnURLFetchComplete(
-    const URLFetcher* source) {
+void URLFetcherSocketAddressTest::OnURLFetchComplete(const URLFetcher* source) {
   EXPECT_EQ("127.0.0.1", source->GetSocketAddress().host());
   EXPECT_EQ(expected_port_, source->GetSocketAddress().port());
   URLFetcherTest::OnURLFetchComplete(source);
 }
 
 // static
 const char* URLFetcherStopOnRedirectTest::kRedirectTarget =
     "http://redirect.target.com";
 
 URLFetcherStopOnRedirectTest::URLFetcherStopOnRedirectTest()
@@ skipping 83 matching lines @@
     EXPECT_TRUE(source->GetResponseAsString(&data));
     EXPECT_FALSE(data.empty());
   } else {
     // We should not get here!
     ADD_FAILURE();
   }
 
   CleanupAfterFetchComplete();
 }
 
-
 URLFetcherBadHTTPSTest::URLFetcherBadHTTPSTest() {
   PathService::Get(base::DIR_SOURCE_ROOT, &cert_dir_);
   cert_dir_ = cert_dir_.AppendASCII("chrome");
   cert_dir_ = cert_dir_.AppendASCII("test");
   cert_dir_ = cert_dir_.AppendASCII("data");
   cert_dir_ = cert_dir_.AppendASCII("ssl");
   cert_dir_ = cert_dir_.AppendASCII("certificates");
 }
 
 // The "server certificate expired" error should result in automatic
 // cancellation of the request by
 // URLRequest::Delegate::OnSSLCertificateError.
-void URLFetcherBadHTTPSTest::OnURLFetchComplete(
-    const URLFetcher* source) {
+void URLFetcherBadHTTPSTest::OnURLFetchComplete(const URLFetcher* source) {
   // This part is different from URLFetcherTest::OnURLFetchComplete
   // because this test expects the request to be cancelled.
   EXPECT_EQ(URLRequestStatus::CANCELED, source->GetStatus().status());
   EXPECT_EQ(ERR_ABORTED, source->GetStatus().error());
   EXPECT_EQ(-1, source->GetResponseCode());
   EXPECT_TRUE(source->GetCookies().empty());
   std::string data;
   EXPECT_TRUE(source->GetResponseAsString(&data));
   EXPECT_TRUE(data.empty());
   CleanupAfterFetchComplete();
 }
 
 void URLFetcherCancelTest::CreateFetcher(const GURL& url) {
   fetcher_ = new URLFetcherImpl(url, URLFetcher::GET, this);
   CancelTestURLRequestContextGetter* context_getter =
       new CancelTestURLRequestContextGetter(io_message_loop_proxy().get(), url);
   fetcher_->SetRequestContext(context_getter);
   fetcher_->SetMaxRetriesOn5xx(2);
   fetcher_->Start();
   // We need to wait for the creation of the URLRequestContext, since we
   // rely on it being destroyed as a signal to end the test.
   context_getter->WaitForContextCreation();
   CancelRequest();
 }
 
-void URLFetcherCancelTest::OnURLFetchComplete(
-    const URLFetcher* source) {
+void URLFetcherCancelTest::OnURLFetchComplete(const URLFetcher* source) {
   // We should have cancelled the request before completion.
   ADD_FAILURE();
   CleanupAfterFetchComplete();
 }
 
 void URLFetcherCancelTest::CancelRequest() {
   delete fetcher_;
   // The URLFetcher's test context will post a Quit task once it is
   // deleted. So if this test simply hangs, it means cancellation
   // did not work.
@@ skipping 37 matching lines @@
   fetcher_->SaveResponseToTemporaryFile(io_message_loop_proxy());
   fetcher_->Start();
 }
 
 void URLFetcherFileTest::OnURLFetchComplete(const URLFetcher* source) {
   if (expected_file_error_ == OK) {
     EXPECT_TRUE(source->GetStatus().is_success());
     EXPECT_EQ(OK, source->GetStatus().error());
     EXPECT_EQ(200, source->GetResponseCode());
 
-    EXPECT_TRUE(source->GetResponseAsFilePath(
-        take_ownership_of_file_, &file_path_));
+    EXPECT_TRUE(
+        source->GetResponseAsFilePath(take_ownership_of_file_, &file_path_));
 
     EXPECT_TRUE(base::ContentsEqual(expected_file_, file_path_));
   } else {
     EXPECT_FALSE(source->GetStatus().is_success());
     EXPECT_EQ(expected_file_error_, source->GetStatus().error());
   }
   CleanupAfterFetchComplete();
 }
 
 TEST_F(URLFetcherTest, SameThreadsTest) {
@@ skipping 16 matching lines @@
                                 base::FilePath(kDocRoot));
   ASSERT_TRUE(test_server.Start());
 
   // Create a separate thread that will create the URLFetcher.  The current
   // (main) thread will do the IO, and when the fetch is complete it will
   // terminate the main thread's message loop; then the other thread's
   // message loop will be shut down automatically as the thread goes out of
   // scope.
   base::Thread t("URLFetcher test thread");
   ASSERT_TRUE(t.Start());
-  t.message_loop()->PostTask(
-      FROM_HERE,
-      base::Bind(&URLFetcherTest::CreateFetcher,
-                 base::Unretained(this),
-                 test_server.GetURL("defaultresponse")));
+  t.message_loop()->PostTask(FROM_HERE,
+                             base::Bind(&URLFetcherTest::CreateFetcher,
+                                        base::Unretained(this),
+                                        test_server.GetURL("defaultresponse")));
 
   base::MessageLoop::current()->Run();
 }
 
 void CancelAllOnIO() {
   EXPECT_EQ(1, URLFetcherTest::GetNumFetcherCores());
   URLFetcherImpl::CancelAll();
   EXPECT_EQ(0, URLFetcherTest::GetNumFetcherCores());
 }
 
@@ skipping 181 matching lines @@
 
   // Get a file large enough to require more than one read into
   // URLFetcher::Core's IOBuffer.
   static const char kFileToFetch[] = "animate1.gif";
   // Hardcoded file size - it cannot be easily fetched when a remote http server
   // is used for testing.
   static const int64 kFileSize = 19021;
 
   expected_total_ = kFileSize;
 
-  CreateFetcher(test_server.GetURL(
-      std::string(kTestServerFilePrefix) + kFileToFetch));
+  CreateFetcher(
+      test_server.GetURL(std::string(kTestServerFilePrefix) + kFileToFetch));
 
   base::MessageLoop::current()->Run();
 }
 
 TEST_F(URLFetcherDownloadProgressCancelTest, CancelWhileProgressReport) {
   SpawnedTestServer test_server(SpawnedTestServer::TYPE_HTTP,
                                 SpawnedTestServer::kLocalhost,
                                 base::FilePath(kDocRoot));
   ASSERT_TRUE(test_server.Start());
 
   // Get a file large enough to require more than one read into
   // URLFetcher::Core's IOBuffer.
   static const char kFileToFetch[] = "animate1.gif";
-  CreateFetcher(test_server.GetURL(
-      std::string(kTestServerFilePrefix) + kFileToFetch));
+  CreateFetcher(
+      test_server.GetURL(std::string(kTestServerFilePrefix) + kFileToFetch));
 
   base::MessageLoop::current()->Run();
 }
 
 TEST_F(URLFetcherHeadersTest, Headers) {
   SpawnedTestServer test_server(
       SpawnedTestServer::TYPE_HTTP,
       SpawnedTestServer::kLocalhost,
       base::FilePath(FILE_PATH_LITERAL("net/data/url_request_unittest")));
   ASSERT_TRUE(test_server.Start());
@@ skipping 41 matching lines @@
   // in 200 milliseconds.
   scoped_refptr<URLRequestThrottlerEntry> entry(
       new URLRequestThrottlerEntry(request_context()->throttler_manager(),
                                    std::string(),
                                    200,
                                    3,
                                    1,
                                    2.0,
                                    0.0,
                                    256));
-  request_context()->throttler_manager()
-      ->OverrideEntryForTests(url, entry.get());
+  request_context()->throttler_manager()->OverrideEntryForTests(url,
+                                                                entry.get());
 
   CreateFetcher(url);
 
   base::MessageLoop::current()->Run();
 }
 
 TEST_F(URLFetcherProtectTest, ServerUnavailable) {
   SpawnedTestServer test_server(SpawnedTestServer::TYPE_HTTP,
                                 SpawnedTestServer::kLocalhost,
                                 base::FilePath(kDocRoot));
   ASSERT_TRUE(test_server.Start());
 
   GURL url(test_server.GetURL("files/server-unavailable.html"));
 
   // Registers an entry for test url. The backoff time is calculated by:
   //     new_backoff = 2.0 * old_backoff + 0
   // and maximum backoff time is 256 milliseconds.
   // Maximum retries allowed is set to 11.
   scoped_refptr<URLRequestThrottlerEntry> entry(
       new URLRequestThrottlerEntry(request_context()->throttler_manager(),
                                    std::string(),
                                    200,
                                    3,
                                    1,
                                    2.0,
                                    0.0,
                                    256));
-  request_context()->throttler_manager()
-      ->OverrideEntryForTests(url, entry.get());
+  request_context()->throttler_manager()->OverrideEntryForTests(url,
+                                                                entry.get());
 
   CreateFetcher(url);
 
   base::MessageLoop::current()->Run();
 }
 
 TEST_F(URLFetcherProtectTestPassedThrough, ServerUnavailablePropagateResponse) {
   SpawnedTestServer test_server(SpawnedTestServer::TYPE_HTTP,
                                 SpawnedTestServer::kLocalhost,
                                 base::FilePath(kDocRoot));
   ASSERT_TRUE(test_server.Start());
 
   GURL url(test_server.GetURL("files/server-unavailable.html"));
 
   // Registers an entry for test url. The backoff time is calculated by:
   //     new_backoff = 2.0 * old_backoff + 0
   // and maximum backoff time is 150000 milliseconds.
   // Maximum retries allowed is set to 11.
   scoped_refptr<URLRequestThrottlerEntry> entry(
       new URLRequestThrottlerEntry(request_context()->throttler_manager(),
                                    std::string(),
                                    200,
                                    3,
                                    100,
                                    2.0,
                                    0.0,
                                    150000));
   // Total time if *not* for not doing automatic backoff would be 150s.
   // In reality it should be "as soon as server responds".
-  request_context()->throttler_manager()
-      ->OverrideEntryForTests(url, entry.get());
+  request_context()->throttler_manager()->OverrideEntryForTests(url,
+                                                                entry.get());
 
   CreateFetcher(url);
 
   base::MessageLoop::current()->Run();
 }
 
 TEST_F(URLFetcherBadHTTPSTest, BadHTTPSTest) {
   SpawnedTestServer::SSLOptions ssl_options(
       SpawnedTestServer::SSLOptions::CERT_EXPIRED);
-  SpawnedTestServer test_server(SpawnedTestServer::TYPE_HTTPS,
-                                ssl_options,
-                                base::FilePath(kDocRoot));
+  SpawnedTestServer test_server(
+      SpawnedTestServer::TYPE_HTTPS, ssl_options, base::FilePath(kDocRoot));
   ASSERT_TRUE(test_server.Start());
 
   CreateFetcher(test_server.GetURL("defaultresponse"));
   base::MessageLoop::current()->Run();
 }
 
 TEST_F(URLFetcherCancelTest, ReleasesContext) {
   SpawnedTestServer test_server(SpawnedTestServer::TYPE_HTTP,
                                 SpawnedTestServer::kLocalhost,
                                 base::FilePath(kDocRoot));
   ASSERT_TRUE(test_server.Start());
 
   GURL url(test_server.GetURL("files/server-unavailable.html"));
 
   // Create a separate thread that will create the URLFetcher.  The current
   // (main) thread will do the IO, and when the fetch is complete it will
   // terminate the main thread's message loop; then the other thread's
   // message loop will be shut down automatically as the thread goes out of
   // scope.
   base::Thread t("URLFetcher test thread");
   ASSERT_TRUE(t.Start());
   t.message_loop()->PostTask(
       FROM_HERE,
-      base::Bind(&URLFetcherCancelTest::CreateFetcher,
-                 base::Unretained(this), url));
+      base::Bind(
+          &URLFetcherCancelTest::CreateFetcher, base::Unretained(this), url));
 
   base::MessageLoop::current()->Run();
 }
 
 TEST_F(URLFetcherCancelTest, CancelWhileDelayedStartTaskPending) {
   SpawnedTestServer test_server(SpawnedTestServer::TYPE_HTTP,
                                 SpawnedTestServer::kLocalhost,
                                 base::FilePath(kDocRoot));
   ASSERT_TRUE(test_server.Start());
 
   GURL url(test_server.GetURL("files/server-unavailable.html"));
 
   // Register an entry for test url.
   // Using a sliding window of 4 seconds, and max of 1 request, under a fast
   // run we expect to have a 4 second delay when posting the Start task.
   scoped_refptr<URLRequestThrottlerEntry> entry(
       new URLRequestThrottlerEntry(request_context()->throttler_manager(),
                                    std::string(),
                                    4000,
                                    1,
                                    2000,
                                    2.0,
                                    0.0,
                                    4000));
-  request_context()->throttler_manager()
-      ->OverrideEntryForTests(url, entry.get());
+  request_context()->throttler_manager()->OverrideEntryForTests(url,
+                                                                entry.get());
   // Fake that a request has just started.
   entry->ReserveSendingTimeForNextRequest(base::TimeTicks());
 
   // The next request we try to send will be delayed by ~4 seconds.
   // The slower the test runs, the less the delay will be (since it takes the
   // time difference from now).
 
   base::Thread t("URLFetcher test thread");
   ASSERT_TRUE(t.Start());
   t.message_loop()->PostTask(
@@ skipping 28 matching lines @@
 
   // Get a small file.
   static const char kFileToFetch[] = "simple.html";
   expected_file_ = test_server.GetDocumentRoot().AppendASCII(kFileToFetch);
   CreateFetcherForFile(
       test_server.GetURL(std::string(kTestServerFilePrefix) + kFileToFetch),
       temp_dir.path().AppendASCII(kFileToFetch));
 
   base::MessageLoop::current()->Run();  // OnURLFetchComplete() will Quit().
 
-  ASSERT_FALSE(base::PathExists(file_path_))
-      << file_path_.value() << " not removed.";
+  ASSERT_FALSE(base::PathExists(file_path_)) << file_path_.value()
+                                             << " not removed.";
 }
 
 TEST_F(URLFetcherFileTest, LargeGet) {
   SpawnedTestServer test_server(SpawnedTestServer::TYPE_HTTP,
                                 SpawnedTestServer::kLocalhost,
                                 base::FilePath(kDocRoot));
   ASSERT_TRUE(test_server.Start());
 
   base::ScopedTempDir temp_dir;
   ASSERT_TRUE(temp_dir.CreateUniqueTempDir());
@@ skipping 26 matching lines @@
     // Get a small file.
     static const char kFileToFetch[] = "simple.html";
     expected_file_ = test_server.GetDocumentRoot().AppendASCII(kFileToFetch);
     CreateFetcherForFile(
         test_server.GetURL(std::string(kTestServerFilePrefix) + kFileToFetch),
         temp_dir.path().AppendASCII(kFileToFetch));
 
     base::MessageLoop::current()->Run();  // OnURLFetchComplete() will Quit().
 
     base::MessageLoop::current()->RunUntilIdle();
-    ASSERT_EQ(kTake[i], base::PathExists(file_path_)) <<
-        "FilePath: " << file_path_.value();
+    ASSERT_EQ(kTake[i], base::PathExists(file_path_))
+        << "FilePath: " << file_path_.value();
   }
 }
 
 TEST_F(URLFetcherFileTest, OverwriteExistingFile) {
   SpawnedTestServer test_server(SpawnedTestServer::TYPE_HTTP,
                                 SpawnedTestServer::kLocalhost,
                                 base::FilePath(kDocRoot));
   ASSERT_TRUE(test_server.Start());
 
   base::ScopedTempDir temp_dir;
@@ skipping 51 matching lines @@
   ASSERT_TRUE(test_server.Start());
 
   // Get a small file.
   static const char kFileToFetch[] = "simple.html";
   expected_file_ = test_server.GetDocumentRoot().AppendASCII(kFileToFetch);
   CreateFetcherForTempFile(
       test_server.GetURL(std::string(kTestServerFilePrefix) + kFileToFetch));
 
   base::MessageLoop::current()->Run();  // OnURLFetchComplete() will Quit().
 
-  ASSERT_FALSE(base::PathExists(file_path_))
-      << file_path_.value() << " not removed.";
+  ASSERT_FALSE(base::PathExists(file_path_)) << file_path_.value()
+                                             << " not removed.";
 }
 
 TEST_F(URLFetcherFileTest, LargeGetToTempFile) {
   SpawnedTestServer test_server(SpawnedTestServer::TYPE_HTTP,
                                 SpawnedTestServer::kLocalhost,
                                 base::FilePath(kDocRoot));
   ASSERT_TRUE(test_server.Start());
 
   // Get a file large enough to require more than one read into
   // URLFetcher::Core's IOBuffer.
   static const char kFileToFetch[] = "animate1.gif";
   expected_file_ = test_server.GetDocumentRoot().AppendASCII(kFileToFetch);
-  CreateFetcherForTempFile(test_server.GetURL(
-      std::string(kTestServerFilePrefix) + kFileToFetch));
+  CreateFetcherForTempFile(
+      test_server.GetURL(std::string(kTestServerFilePrefix) + kFileToFetch));
 
   base::MessageLoop::current()->Run();  // OnURLFetchComplete() will Quit().
 }
 
 TEST_F(URLFetcherFileTest, SavedOutputTempFileOwnerhisp) {
   // If the caller takes the ownership of the temp file, the file should persist
   // even after URLFetcher is gone. If not, the file must be deleted.
   const bool kTake[] = {false, true};
   for (size_t i = 0; i < arraysize(kTake); ++i) {
     take_ownership_of_file_ = kTake[i];
 
     SpawnedTestServer test_server(SpawnedTestServer::TYPE_HTTP,
                                   SpawnedTestServer::kLocalhost,
                                   base::FilePath(kDocRoot));
     ASSERT_TRUE(test_server.Start());
 
     // Get a small file.
     static const char kFileToFetch[] = "simple.html";
     expected_file_ = test_server.GetDocumentRoot().AppendASCII(kFileToFetch);
-    CreateFetcherForTempFile(test_server.GetURL(
-        std::string(kTestServerFilePrefix) + kFileToFetch));
+    CreateFetcherForTempFile(
+        test_server.GetURL(std::string(kTestServerFilePrefix) + kFileToFetch));
 
     base::MessageLoop::current()->Run();  // OnURLFetchComplete() will Quit().
 
     base::MessageLoop::current()->RunUntilIdle();
-    ASSERT_EQ(kTake[i], base::PathExists(file_path_)) <<
-        "FilePath: " << file_path_.value();
+    ASSERT_EQ(kTake[i], base::PathExists(file_path_))
+        << "FilePath: " << file_path_.value();
   }
 }
 
 }  // namespace
 
 }  // namespace net