Clang format slam.

net/url_request/url_request_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 "build/build_config.h"
 
 #if defined(OS_WIN)
 #include <windows.h>
 #include <shlobj.h>
 #endif
@@ skipping 140 matching lines @@
 
   EXPECT_FALSE(load_timing_info.request_start_time.is_null());
   EXPECT_FALSE(load_timing_info.request_start.is_null());
 
   ExpectConnectTimingHasNoTimes(load_timing_info.connect_timing);
 
   EXPECT_LE(load_timing_info.request_start,
             load_timing_info.proxy_resolve_start);
   EXPECT_LE(load_timing_info.proxy_resolve_start,
             load_timing_info.proxy_resolve_end);
-  EXPECT_LE(load_timing_info.proxy_resolve_end,
-            load_timing_info.send_start);
+  EXPECT_LE(load_timing_info.proxy_resolve_end, load_timing_info.send_start);
   EXPECT_LE(load_timing_info.send_start, load_timing_info.send_end);
   EXPECT_LE(load_timing_info.send_end, load_timing_info.receive_headers_end);
 }
 
 // Tests load timing information in the case of a cache hit, when no cache
 // validation request was sent over the wire.
 base::StringPiece TestNetResourceProvider(int key) {
   return "header";
 }
 
@@ skipping 25 matching lines @@
   EXPECT_LE(load_timing_info.request_start, load_timing_info.send_start);
   EXPECT_LE(load_timing_info.send_start, load_timing_info.send_end);
   EXPECT_LE(load_timing_info.send_end, load_timing_info.receive_headers_end);
 
   EXPECT_TRUE(load_timing_info.proxy_resolve_start.is_null());
   EXPECT_TRUE(load_timing_info.proxy_resolve_end.is_null());
 }
 
 // Tests load timing in the case that there is no HTTP response.  This can be
 // used to test in the case of errors or non-HTTP requests.
-void TestLoadTimingNoHttpResponse(
-    const net::LoadTimingInfo& load_timing_info) {
+void TestLoadTimingNoHttpResponse(const net::LoadTimingInfo& load_timing_info) {
   EXPECT_FALSE(load_timing_info.socket_reused);
   EXPECT_EQ(net::NetLog::Source::kInvalidId, load_timing_info.socket_log_id);
 
   // Only the request times should be non-null.
   EXPECT_FALSE(load_timing_info.request_start_time.is_null());
   EXPECT_FALSE(load_timing_info.request_start.is_null());
 
   ExpectConnectTimingHasNoTimes(load_timing_info.connect_timing);
 
   EXPECT_TRUE(load_timing_info.proxy_resolve_start.is_null());
@@ skipping 19 matching lines @@
       new UploadBytesElementReader(data, strlen(data)));
   return UploadDataStream::CreateWithReader(reader.Pass(), 0);
 }
 
 // Verify that the SSLInfo of a successful SSL connection has valid values.
 void CheckSSLInfo(const SSLInfo& ssl_info) {
   // -1 means unknown.  0 means no encryption.
   EXPECT_GT(ssl_info.security_bits, 0);
 
   // The cipher suite TLS_NULL_WITH_NULL_NULL (0) must not be negotiated.
-  int cipher_suite = SSLConnectionStatusToCipherSuite(
-      ssl_info.connection_status);
+  int cipher_suite =
+      SSLConnectionStatusToCipherSuite(ssl_info.connection_status);
   EXPECT_NE(0, cipher_suite);
 }
 
 void CheckFullRequestHeaders(const HttpRequestHeaders& headers,
                              const GURL& host_url) {
   std::string sent_value;
 
   EXPECT_TRUE(headers.GetHeader("Host", &sent_value));
   EXPECT_EQ(GetHostAndOptionalPort(host_url), sent_value);
 
@@ skipping 69 matching lines @@
   // |auth_credentials_| will be passed with the response.
   void set_auth_retval(AuthRequiredResponse auth_retval) {
     ASSERT_NE(USER_CALLBACK, block_mode_);
     ASSERT_NE(AUTH_REQUIRED_RESPONSE_IO_PENDING, auth_retval);
     auth_retval_ = auth_retval;
   }
   void set_auth_credentials(const AuthCredentials& auth_credentials) {
     auth_credentials_ = auth_credentials;
   }
 
-  void set_redirect_url(const GURL& url) {
-    redirect_url_ = url;
-  }
+  void set_redirect_url(const GURL& url) { redirect_url_ = url; }
 
-  void set_block_on(int block_on) {
-    block_on_ = block_on;
-  }
+  void set_block_on(int block_on) { block_on_ = block_on; }
 
   // Allows the user to check in which state did we block.
   Stage stage_blocked_for_callback() const {
     EXPECT_EQ(USER_CALLBACK, block_mode_);
     return stage_blocked_for_callback_;
   }
 
  private:
   void RunCallback(int response, const CompletionCallback& callback);
   void RunAuthCallback(AuthRequiredResponse response,
@@ skipping 30 matching lines @@
 
   // Configuration parameters, can be adjusted by public methods:
   const BlockMode block_mode_;
 
   // Values returned on blocking stages when mode is SYNCHRONOUS or
   // AUTO_CALLBACK. For USER_CALLBACK these are set automatically to IO_PENDING.
   int retval_;  // To be returned in non-auth stages.
   AuthRequiredResponse auth_retval_;
 
   GURL redirect_url_;  // Used if non-empty during OnBeforeURLRequest.
-  int block_on_;  // Bit mask: in which stages to block.
+  int block_on_;       // Bit mask: in which stages to block.
 
   // |auth_credentials_| will be copied to |*target_auth_credential_| on
   // callback.
   AuthCredentials auth_credentials_;
   AuthCredentials* target_auth_credentials_;
 
   // Internal variables, not set by not the user:
   // Last blocked stage waiting for user callback (unused if |block_mode_| !=
   // USER_CALLBACK).
   Stage stage_blocked_for_callback_;
@@ skipping 86 matching lines @@
                                          allowed_unsafe_redirect_url);
 
   return MaybeBlockStage(ON_HEADERS_RECEIVED, callback);
 }
 
 NetworkDelegate::AuthRequiredResponse BlockingNetworkDelegate::OnAuthRequired(
     URLRequest* request,
     const AuthChallengeInfo& auth_info,
     const AuthCallback& callback,
     AuthCredentials* credentials) {
-  TestNetworkDelegate::OnAuthRequired(request, auth_info, callback,
-                                      credentials);
+  TestNetworkDelegate::OnAuthRequired(
+      request, auth_info, callback, credentials);
   // Check that the user has provided callback for the previous blocked stage.
   EXPECT_EQ(NOT_BLOCKED, stage_blocked_for_callback_);
 
   if ((block_on_ & ON_AUTH_REQUIRED) == 0) {
     return AUTH_REQUIRED_RESPONSE_NO_ACTION;
   }
 
   target_auth_credentials_ = credentials;
 
   switch (block_mode_) {
     case SYNCHRONOUS:
       if (auth_retval_ == AUTH_REQUIRED_RESPONSE_SET_AUTH)
         *target_auth_credentials_ = auth_credentials_;
       return auth_retval_;
 
     case AUTO_CALLBACK:
       base::MessageLoop::current()->PostTask(
           FROM_HERE,
           base::Bind(&BlockingNetworkDelegate::RunAuthCallback,
-                     weak_factory_.GetWeakPtr(), auth_retval_, callback));
+                     weak_factory_.GetWeakPtr(),
+                     auth_retval_,
+                     callback));
       return AUTH_REQUIRED_RESPONSE_IO_PENDING;
 
     case USER_CALLBACK:
       auth_callback_ = callback;
       stage_blocked_for_callback_ = ON_AUTH_REQUIRED;
       base::MessageLoop::current()->PostTask(FROM_HERE,
                                              base::MessageLoop::QuitClosure());
       return AUTH_REQUIRED_RESPONSE_IO_PENDING;
   }
   NOTREACHED();
@@ skipping 19 matching lines @@
 
   switch (block_mode_) {
     case SYNCHRONOUS:
       EXPECT_NE(OK, retval_);
       return retval_;
 
     case AUTO_CALLBACK:
       base::MessageLoop::current()->PostTask(
           FROM_HERE,
           base::Bind(&BlockingNetworkDelegate::RunCallback,
-                     weak_factory_.GetWeakPtr(), retval_, callback));
+                     weak_factory_.GetWeakPtr(),
+                     retval_,
+                     callback));
       return ERR_IO_PENDING;
 
     case USER_CALLBACK:
       callback_ = callback;
       stage_blocked_for_callback_ = stage;
       base::MessageLoop::current()->PostTask(FROM_HERE,
                                              base::MessageLoop::QuitClosure());
       return ERR_IO_PENDING;
   }
   NOTREACHED();
@@ skipping 67 matching lines @@
     EXPECT_FALSE(r.GetFullRequestHeaders(&headers));
   }
 }
 
 TEST_F(URLRequestTest, DataURLImageTest) {
   TestDelegate d;
   {
     // Use our nice little Chrome logo.
     URLRequest r(
         GURL(
-        "data:image/png;base64,"
-        "iVBORw0KGgoAAAANSUhEUgAAABAAAAAQCAYAAAAf8/9hAAADVklEQVQ4jX2TfUwUBBjG3"
-        "w1y+HGcd9dxhXR8T4awOccJGgOSWclHImznLkTlSw0DDQXkrmgYgbUYnlQTqQxIEVxitD"
-        "5UMCATRA1CEEg+Qjw3bWDxIauJv/5oumqs39/P827vnucRmYN0gyF01GI5MpCVdW0gO7t"
-        "vNC+vqSEtbZefk5NuLv1jdJ46p/zw0HeH4+PHr3h7c1mjoV2t5rKzMx1+fg9bAgK6zHq9"
-        "cU5z+LpA3xOtx34+vTeT21onRuzssC3zxbbSwC13d/pFuC7CkIMDxQpF7r/MWq12UctI1"
-        "dWWm99ypqSYmRUBdKem8MkrO/kgaTt1O7YzlpzE5GIVd0WYUqt57yWf2McHTObYPbVD+Z"
-        "wbtlLTVMZ3BW+TnLyXLaWtmEq6WJVbT3HBh3Svj2HQQcm43XwmtoYM6vVKleh0uoWvnzW"
-        "3v3MpidruPTQPf0bia7sJOtBM0ufTWNvus/nkDFHF9ZS+uYVjRUasMeHUmyLYtcklTvzW"
-        "GFZnNOXczThvpKIzjcahSqIzkvDLayDq6D3eOjtBbNUEIZYyqsvj4V4wY92eNJ4IoyhTb"
-        "xXX1T5xsV9tm9r4TQwHLiZw/pdDZJea8TKmsmR/K0uLh/GwnCHghTja6lPhphezPfO5/5"
-        "MrVvMzNaI3+ERHfrFzPKQukrQGI4d/3EFD/3E2mVNYvi4at7CXWREaxZGD+3hg28zD3gV"
-        "Md6q5c8GdosynKmSeRuGzpjyl1/9UDGtPR5HeaKT8Wjo17WXk579BXVUhN64ehF9fhRtq"
-        "/uxxZKzNiZFGD0wRC3NFROZ5mwIPL/96K/rKMMLrIzF9uhHr+/sYH7DAbwlgC4J+R2Z7F"
-        "Ux1qLnV7MGF40smVSoJ/jvHRfYhQeUJd/SnYtGWhPHR0Sz+GE2F2yth0B36Vcz2KpnufB"
-        "JbsysjjW4kblBUiIjiURUWqJY65zxbnTy57GQyH58zgy0QBtTQv5gH15XMdKkYu+TGaJM"
-        "nlm2O34uI4b9tflqp1+QEFGzoW/ulmcofcpkZCYJhDfSpme7QcrHa+Xfji8paEQkTkSfm"
-        "moRWRNZr/F1KfVMjW+IKEnv2FwZfKdzt0BQR6lClcZR0EfEXEfv/G6W9iLiIyCoReV5En"
-        "hORIBHx+ufPj/gLB/zGI/G4Bk0AAAAASUVORK5CYII="),
+            "data:image/png;base64,"
+            "iVBORw0KGgoAAAANSUhEUgAAABAAAAAQCAYAAAAf8/"
+            "9hAAADVklEQVQ4jX2TfUwUBBjG3"
+            "w1y+"
+            "HGcd9dxhXR8T4awOccJGgOSWclHImznLkTlSw0DDQXkrmgYgbUYnlQTqQxIEVxitD"
+            "5UMCATRA1CEEg+Qjw3bWDxIauJv/5oumqs39/"
+            "P827vnucRmYN0gyF01GI5MpCVdW0gO7t"
+            "vNC+vqSEtbZefk5NuLv1jdJ46p/"
+            "zw0HeH4+PHr3h7c1mjoV2t5rKzMx1+fg9bAgK6zHq9"
+            "cU5z+LpA3xOtx34+vTeT21onRuzssC3zxbbSwC13d/pFuC7CkIMDxQpF7r/"
+            "MWq12UctI1"
+            "dWWm99ypqSYmRUBdKem8MkrO/"
+            "kgaTt1O7YzlpzE5GIVd0WYUqt57yWf2McHTObYPbVD+Z"
+            "wbtlLTVMZ3BW+"
+            "TnLyXLaWtmEq6WJVbT3HBh3Svj2HQQcm43XwmtoYM6vVKleh0uoWvnzW"
+            "3v3MpidruPTQPf0bia7sJOtBM0ufTWNvus/"
+            "nkDFHF9ZS+uYVjRUasMeHUmyLYtcklTvzW"
+            "GFZnNOXczThvpKIzjcahSqIzkvDLayDq6D3eOjtBbNUEIZYyqsvj4V4wY92eNJ4Ioy"
+            "hTb"
+            "xXX1T5xsV9tm9r4TQwHLiZw/pdDZJea8TKmsmR/K0uLh/"
+            "GwnCHghTja6lPhphezPfO5/5"
+            "MrVvMzNaI3+ERHfrFzPKQukrQGI4d/3EFD/"
+            "3E2mVNYvi4at7CXWREaxZGD+3hg28zD3gV"
+            "Md6q5c8GdosynKmSeRuGzpjyl1/"
+            "9UDGtPR5HeaKT8Wjo17WXk579BXVUhN64ehF9fhRtq"
+            "/uxxZKzNiZFGD0wRC3NFROZ5mwIPL/96K/rKMMLrIzF9uhHr+/"
+            "sYH7DAbwlgC4J+R2Z7F"
+            "Ux1qLnV7MGF40smVSoJ/jvHRfYhQeUJd/"
+            "SnYtGWhPHR0Sz+GE2F2yth0B36Vcz2KpnufB"
+            "JbsysjjW4kblBUiIjiURUWqJY65zxbnTy57GQyH58zgy0QBtTQv5gH15XMdKkYu+"
+            "TGaJM"
+            "nlm2O34uI4b9tflqp1+QEFGzoW/"
+            "ulmcofcpkZCYJhDfSpme7QcrHa+Xfji8paEQkTkSfm"
+            "moRWRNZr/F1KfVMjW+IKEnv2FwZfKdzt0BQR6lClcZR0EfEXEfv/"
+            "G6W9iLiIyCoReV5En"
+            "hORIBHx+ufPj/gLB/zGI/G4Bk0AAAAASUVORK5CYII="),
         DEFAULT_PRIORITY,
         &d,
         &default_context_);
 
     r.Start();
     EXPECT_TRUE(r.is_pending());
 
     base::RunLoop().Run();
 
     EXPECT_TRUE(!r.is_pending());
@@ skipping 73 matching lines @@
   std::string partial_buffer_string(buffer.get() + first_byte_position,
                                     buffer.get() + last_byte_position + 1);
 
   TestDelegate d;
   {
     URLRequest r(temp_url, DEFAULT_PRIORITY, &d, &default_context_);
 
     HttpRequestHeaders headers;
     headers.SetHeader(
         HttpRequestHeaders::kRange,
-        net::HttpByteRange::Bounded(
-            first_byte_position, last_byte_position).GetHeaderValue());
+        net::HttpByteRange::Bounded(first_byte_position, last_byte_position)
+            .GetHeaderValue());
     r.SetExtraRequestHeaders(headers);
     r.Start();
     EXPECT_TRUE(r.is_pending());
 
     base::RunLoop().Run();
     EXPECT_TRUE(!r.is_pending());
     EXPECT_EQ(1, d.response_started_count());
     EXPECT_FALSE(d.received_data_before_response());
     EXPECT_EQ(static_cast<int>(content_length), d.bytes_received());
     // Don't use EXPECT_EQ, it will print out a lot of garbage if check failed.
@@ skipping 21 matching lines @@
   const size_t content_length = last_byte_position - first_byte_position + 1;
   std::string partial_buffer_string(buffer.get() + first_byte_position,
                                     buffer.get() + last_byte_position + 1);
 
   TestDelegate d;
   {
     URLRequest r(temp_url, DEFAULT_PRIORITY, &d, &default_context_);
 
     HttpRequestHeaders headers;
     headers.SetHeader(HttpRequestHeaders::kRange,
-                      net::HttpByteRange::RightUnbounded(
-                          first_byte_position).GetHeaderValue());
+                      net::HttpByteRange::RightUnbounded(first_byte_position)
+                          .GetHeaderValue());
     r.SetExtraRequestHeaders(headers);
     r.Start();
     EXPECT_TRUE(r.is_pending());
 
     base::RunLoop().Run();
     EXPECT_TRUE(!r.is_pending());
     EXPECT_EQ(1, d.response_started_count());
     EXPECT_FALSE(d.received_data_before_response());
     EXPECT_EQ(static_cast<int>(content_length), d.bytes_received());
     // Don't use EXPECT_EQ, it will print out a lot of garbage if check failed.
@@ skipping 89 matching lines @@
   app_path = app_path.AppendASCII("url_request_unittest");
   app_path = app_path.AppendASCII("with-headers.html");
 
   std::wstring lnk_path = app_path.value() + L".lnk";
 
   base::win::ScopedCOMInitializer com_initializer;
 
   // Temporarily create a shortcut for test
   {
     base::win::ScopedComPtr<IShellLink> shell;
-    ASSERT_TRUE(SUCCEEDED(shell.CreateInstance(CLSID_ShellLink, NULL,
-                                               CLSCTX_INPROC_SERVER)));
+    ASSERT_TRUE(SUCCEEDED(
+        shell.CreateInstance(CLSID_ShellLink, NULL, CLSCTX_INPROC_SERVER)));
     base::win::ScopedComPtr<IPersistFile> persist;
     ASSERT_TRUE(SUCCEEDED(shell.QueryInterface(persist.Receive())));
     EXPECT_TRUE(SUCCEEDED(shell->SetPath(app_path.value().c_str())));
     EXPECT_TRUE(SUCCEEDED(shell->SetDescription(L"ResolveShortcutTest")));
     EXPECT_TRUE(SUCCEEDED(persist->Save(lnk_path.c_str(), TRUE)));
   }
 
   TestDelegate d;
   {
     URLRequest r(FilePathToFileURL(base::FilePath(lnk_path)),
                  DEFAULT_PRIORITY,
                  &d,
                  &default_context_);
 
     r.Start();
     EXPECT_TRUE(r.is_pending());
 
     base::RunLoop().Run();
 
     WIN32_FILE_ATTRIBUTE_DATA data;
-    GetFileAttributesEx(app_path.value().c_str(),
-                        GetFileExInfoStandard, &data);
-    HANDLE file = CreateFile(app_path.value().c_str(), GENERIC_READ,
-                             FILE_SHARE_READ, NULL, OPEN_EXISTING,
-                             FILE_ATTRIBUTE_NORMAL, NULL);
+    GetFileAttributesEx(app_path.value().c_str(), GetFileExInfoStandard, &data);
+    HANDLE file = CreateFile(app_path.value().c_str(),
+                             GENERIC_READ,
+                             FILE_SHARE_READ,
+                             NULL,
+                             OPEN_EXISTING,
+                             FILE_ATTRIBUTE_NORMAL,
+                             NULL);
     EXPECT_NE(INVALID_HANDLE_VALUE, file);
     scoped_ptr<char[]> buffer(new char[data.nFileSizeLow]);
     DWORD read_size;
     BOOL result;
-    result = ReadFile(file, buffer.get(), data.nFileSizeLow,
-                      &read_size, NULL);
+    result = ReadFile(file, buffer.get(), data.nFileSizeLow, &read_size, NULL);
     std::string content(buffer.get(), read_size);
     CloseHandle(file);
 
     EXPECT_TRUE(!r.is_pending());
     EXPECT_EQ(1, d.received_redirect_count());
     EXPECT_EQ(content, d.data_received());
   }
 
   // Clean the shortcut
   DeleteFile(lnk_path.c_str());
@@ skipping 96 matching lines @@
 
   ASSERT_EQ(1, d.received_redirect_count());
   ASSERT_FALSE(req.status().is_success());
 }
 #endif
 
 // Custom URLRequestJobs for use with interceptor tests
 class RestartTestJob : public URLRequestTestJob {
  public:
   RestartTestJob(URLRequest* request, NetworkDelegate* network_delegate)
-    : URLRequestTestJob(request, network_delegate, true) {}
+      : URLRequestTestJob(request, network_delegate, true) {}
+
  protected:
-  virtual void StartAsync() OVERRIDE {
-    this->NotifyRestartRequired();
-  }
+  virtual void StartAsync() OVERRIDE { this->NotifyRestartRequired(); }
+
  private:
   virtual ~RestartTestJob() {}
 };
 
 class CancelTestJob : public URLRequestTestJob {
  public:
   explicit CancelTestJob(URLRequest* request, NetworkDelegate* network_delegate)
-    : URLRequestTestJob(request, network_delegate, true) {}
+      : URLRequestTestJob(request, network_delegate, true) {}
+
  protected:
-  virtual void StartAsync() OVERRIDE {
-    request_->Cancel();
-  }
+  virtual void StartAsync() OVERRIDE { request_->Cancel(); }
+
  private:
   virtual ~CancelTestJob() {}
 };
 
 class CancelThenRestartTestJob : public URLRequestTestJob {
  public:
   explicit CancelThenRestartTestJob(URLRequest* request,
                                     NetworkDelegate* network_delegate)
-      : URLRequestTestJob(request, network_delegate, true) {
-  }
+      : URLRequestTestJob(request, network_delegate, true) {}
+
  protected:
   virtual void StartAsync() OVERRIDE {
     request_->Cancel();
     this->NotifyRestartRequired();
   }
+
  private:
   virtual ~CancelThenRestartTestJob() {}
 };
 
 // An Interceptor for use with interceptor tests
 class TestInterceptor : URLRequest::Interceptor {
  public:
   TestInterceptor()
-      : intercept_main_request_(false), restart_main_request_(false),
-        cancel_main_request_(false), cancel_then_restart_main_request_(false),
+      : intercept_main_request_(false),
+        restart_main_request_(false),
+        cancel_main_request_(false),
+        cancel_then_restart_main_request_(false),
         simulate_main_network_error_(false),
-        intercept_redirect_(false), cancel_redirect_request_(false),
-        intercept_final_response_(false), cancel_final_request_(false),
-        did_intercept_main_(false), did_restart_main_(false),
-        did_cancel_main_(false), did_cancel_then_restart_main_(false),
+        intercept_redirect_(false),
+        cancel_redirect_request_(false),
+        intercept_final_response_(false),
+        cancel_final_request_(false),
+        did_intercept_main_(false),
+        did_restart_main_(false),
+        did_cancel_main_(false),
+        did_cancel_then_restart_main_(false),
         did_simulate_error_main_(false),
-        did_intercept_redirect_(false), did_cancel_redirect_(false),
-        did_intercept_final_(false), did_cancel_final_(false) {
+        did_intercept_redirect_(false),
+        did_cancel_redirect_(false),
+        did_intercept_final_(false),
+        did_cancel_final_(false) {
     URLRequest::Deprecated::RegisterRequestInterceptor(this);
   }
 
   virtual ~TestInterceptor() {
     URLRequest::Deprecated::UnregisterRequestInterceptor(this);
   }
 
   virtual URLRequestJob* MaybeIntercept(
       URLRequest* request,
       NetworkDelegate* network_delegate) OVERRIDE {
@@ skipping 15 matching lines @@
     if (simulate_main_network_error_) {
       simulate_main_network_error_ = false;
       did_simulate_error_main_ = true;
       // will error since the requeted url is not one of its canned urls
       return new URLRequestTestJob(request, network_delegate, true);
     }
     if (!intercept_main_request_)
       return NULL;
     intercept_main_request_ = false;
     did_intercept_main_ = true;
-    URLRequestTestJob* job =  new URLRequestTestJob(request,
-                                                    network_delegate,
-                                                    main_headers_,
-                                                    main_data_,
-                                                    true);
+    URLRequestTestJob* job = new URLRequestTestJob(
+        request, network_delegate, main_headers_, main_data_, true);
     job->set_load_timing_info(main_request_load_timing_info_);
     return job;
   }
 
   virtual URLRequestJob* MaybeInterceptRedirect(
       URLRequest* request,
       NetworkDelegate* network_delegate,
       const GURL& location) OVERRIDE {
     if (cancel_redirect_request_) {
       cancel_redirect_request_ = false;
       did_cancel_redirect_ = true;
       return new CancelTestJob(request, network_delegate);
     }
     if (!intercept_redirect_)
       return NULL;
     intercept_redirect_ = false;
     did_intercept_redirect_ = true;
-    return new URLRequestTestJob(request,
-                                 network_delegate,
-                                 redirect_headers_,
-                                 redirect_data_,
-                                 true);
+    return new URLRequestTestJob(
+        request, network_delegate, redirect_headers_, redirect_data_, true);
   }
 
   virtual URLRequestJob* MaybeInterceptResponse(
-      URLRequest* request, NetworkDelegate* network_delegate) OVERRIDE {
+      URLRequest* request,
+      NetworkDelegate* network_delegate) OVERRIDE {
     if (cancel_final_request_) {
       cancel_final_request_ = false;
       did_cancel_final_ = true;
       return new CancelTestJob(request, network_delegate);
     }
     if (!intercept_final_response_)
       return NULL;
     intercept_final_response_ = false;
     did_intercept_final_ = true;
-    return new URLRequestTestJob(request,
-                                 network_delegate,
-                                 final_headers_,
-                                 final_data_,
-                                 true);
+    return new URLRequestTestJob(
+        request, network_delegate, final_headers_, final_data_, true);
   }
 
   // Whether to intercept the main request, and if so the response to return and
   // the LoadTimingInfo to use.
   bool intercept_main_request_;
   std::string main_headers_;
   std::string main_data_;
   LoadTimingInfo main_request_load_timing_info_;
 
   // Other actions we take at MaybeIntercept time
@@ skipping 24 matching lines @@
   bool did_cancel_main_;
   bool did_cancel_then_restart_main_;
   bool did_simulate_error_main_;
   bool did_intercept_redirect_;
   bool did_cancel_redirect_;
   bool did_intercept_final_;
   bool did_cancel_final_;
 
   // Static getters for canned response header and data strings
 
-  static std::string ok_data() {
-    return URLRequestTestJob::test_data_1();
-  }
+  static std::string ok_data() { return URLRequestTestJob::test_data_1(); }
 
-  static std::string ok_headers() {
-    return URLRequestTestJob::test_headers();
-  }
+  static std::string ok_headers() { return URLRequestTestJob::test_headers(); }
 
-  static std::string redirect_data() {
-    return std::string();
-  }
+  static std::string redirect_data() { return std::string(); }
 
   static std::string redirect_headers() {
     return URLRequestTestJob::test_redirect_headers();
   }
 
   static std::string error_data() {
     return std::string("ohhh nooooo mr. bill!");
   }
 
   static std::string error_headers() {
@@ skipping 43 matching lines @@
 TEST_F(URLRequestTest, InterceptRedirect) {
   TestInterceptor interceptor;
 
   // intercept the main request and respond with a redirect
   interceptor.intercept_main_request_ = true;
   interceptor.main_headers_ = TestInterceptor::redirect_headers();
   interceptor.main_data_ = TestInterceptor::redirect_data();
 
   // intercept that redirect and respond a final OK response
   interceptor.intercept_redirect_ = true;
-  interceptor.redirect_headers_ =  TestInterceptor::ok_headers();
+  interceptor.redirect_headers_ = TestInterceptor::ok_headers();
   interceptor.redirect_data_ = TestInterceptor::ok_data();
 
   TestDelegate d;
   URLRequest req(GURL("http://test_intercept/foo"),
                  DEFAULT_PRIORITY,
                  &d,
                  &default_context_);
   req.set_method("GET");
   req.Start();
   base::RunLoop().Run();
@@ skipping 647 matching lines @@
       : SpawnedTestServer(SpawnedTestServer::TYPE_HTTP,
                           ScopedCustomUrlRequestTestHttpHost::value(),
                           base::FilePath()) {}
 };
 
 TEST_F(URLRequestTest, DelayedCookieCallback) {
   LocalHttpTestServer test_server;
   ASSERT_TRUE(test_server.Start());
 
   TestURLRequestContext context;
-  scoped_refptr<DelayedCookieMonster> delayed_cm =
-      new DelayedCookieMonster();
+  scoped_refptr<DelayedCookieMonster> delayed_cm = new DelayedCookieMonster();
   scoped_refptr<CookieStore> cookie_store = delayed_cm;
   context.set_cookie_store(delayed_cm.get());
 
   // Set up a cookie.
   {
     TestNetworkDelegate network_delegate;
     context.set_network_delegate(&network_delegate);
     TestDelegate d;
     URLRequest req(test_server.GetURL("set-cookie?CookieToNotSend=1"),
                    DEFAULT_PRIORITY,
@@ skipping 11 matching lines @@
     TestNetworkDelegate network_delegate;
     context.set_network_delegate(&network_delegate);
     TestDelegate d;
     URLRequest req(test_server.GetURL("echoheader?Cookie"),
                    DEFAULT_PRIORITY,
                    &d,
                    &context);
     req.Start();
     base::RunLoop().Run();
 
-    EXPECT_TRUE(d.data_received().find("CookieToNotSend=1")
-                != std::string::npos);
+    EXPECT_TRUE(d.data_received().find("CookieToNotSend=1") !=
+                std::string::npos);
     EXPECT_EQ(0, network_delegate.blocked_get_cookies_count());
     EXPECT_EQ(0, network_delegate.blocked_set_cookie_count());
   }
 }
 
 TEST_F(URLRequestTest, DoNotSendCookies) {
   LocalHttpTestServer test_server;
   ASSERT_TRUE(test_server.Start());
 
   // Set up a cookie.
@@ skipping 16 matching lines @@
     TestNetworkDelegate network_delegate;
     default_context_.set_network_delegate(&network_delegate);
     TestDelegate d;
     URLRequest req(test_server.GetURL("echoheader?Cookie"),
                    DEFAULT_PRIORITY,
                    &d,
                    &default_context_);
     req.Start();
     base::RunLoop().Run();
 
-    EXPECT_TRUE(d.data_received().find("CookieToNotSend=1")
-                != std::string::npos);
+    EXPECT_TRUE(d.data_received().find("CookieToNotSend=1") !=
+                std::string::npos);
     EXPECT_EQ(0, network_delegate.blocked_get_cookies_count());
     EXPECT_EQ(0, network_delegate.blocked_set_cookie_count());
   }
 
   // Verify that the cookie isn't sent when LOAD_DO_NOT_SEND_COOKIES is set.
   {
     TestNetworkDelegate network_delegate;
     default_context_.set_network_delegate(&network_delegate);
     TestDelegate d;
     URLRequest req(test_server.GetURL("echoheader?Cookie"),
                    DEFAULT_PRIORITY,
                    &d,
                    &default_context_);
     req.SetLoadFlags(LOAD_DO_NOT_SEND_COOKIES);
     req.Start();
     base::RunLoop().Run();
 
-    EXPECT_TRUE(d.data_received().find("Cookie: CookieToNotSend=1")
-                == std::string::npos);
+    EXPECT_TRUE(d.data_received().find("Cookie: CookieToNotSend=1") ==
+                std::string::npos);
 
     // LOAD_DO_NOT_SEND_COOKIES does not trigger OnGetCookies.
     EXPECT_EQ(0, network_delegate.blocked_get_cookies_count());
     EXPECT_EQ(0, network_delegate.blocked_set_cookie_count());
   }
 }
 
 TEST_F(URLRequestTest, DoNotSaveCookies) {
   LocalHttpTestServer test_server;
   ASSERT_TRUE(test_server.Start());
@@ skipping 41 matching lines @@
     TestNetworkDelegate network_delegate;
     default_context_.set_network_delegate(&network_delegate);
     TestDelegate d;
     URLRequest req(test_server.GetURL("echoheader?Cookie"),
                    DEFAULT_PRIORITY,
                    &d,
                    &default_context_);
     req.Start();
     base::RunLoop().Run();
 
-    EXPECT_TRUE(d.data_received().find("CookieToNotSave=1")
-                == std::string::npos);
-    EXPECT_TRUE(d.data_received().find("CookieToNotUpdate=2")
-                != std::string::npos);
+    EXPECT_TRUE(d.data_received().find("CookieToNotSave=1") ==
+                std::string::npos);
+    EXPECT_TRUE(d.data_received().find("CookieToNotUpdate=2") !=
+                std::string::npos);
 
     EXPECT_EQ(0, network_delegate.blocked_get_cookies_count());
     EXPECT_EQ(0, network_delegate.blocked_set_cookie_count());
     EXPECT_EQ(0, network_delegate.set_cookie_count());
   }
 }
 
 TEST_F(URLRequestTest, DoNotSendCookies_ViaPolicy) {
   LocalHttpTestServer test_server;
   ASSERT_TRUE(test_server.Start());
@@ skipping 19 matching lines @@
     TestNetworkDelegate network_delegate;
     default_context_.set_network_delegate(&network_delegate);
     TestDelegate d;
     URLRequest req(test_server.GetURL("echoheader?Cookie"),
                    DEFAULT_PRIORITY,
                    &d,
                    &default_context_);
     req.Start();
     base::RunLoop().Run();
 
-    EXPECT_TRUE(d.data_received().find("CookieToNotSend=1")
-                != std::string::npos);
+    EXPECT_TRUE(d.data_received().find("CookieToNotSend=1") !=
+                std::string::npos);
 
     EXPECT_EQ(0, network_delegate.blocked_get_cookies_count());
     EXPECT_EQ(0, network_delegate.blocked_set_cookie_count());
   }
 
   // Verify that the cookie isn't sent.
   {
     TestNetworkDelegate network_delegate;
     default_context_.set_network_delegate(&network_delegate);
     TestDelegate d;
     network_delegate.set_cookie_options(TestNetworkDelegate::NO_GET_COOKIES);
     URLRequest req(test_server.GetURL("echoheader?Cookie"),
                    DEFAULT_PRIORITY,
                    &d,
                    &default_context_);
     req.Start();
     base::RunLoop().Run();
 
-    EXPECT_TRUE(d.data_received().find("Cookie: CookieToNotSend=1")
-                == std::string::npos);
+    EXPECT_TRUE(d.data_received().find("Cookie: CookieToNotSend=1") ==
+                std::string::npos);
 
     EXPECT_EQ(1, network_delegate.blocked_get_cookies_count());
     EXPECT_EQ(0, network_delegate.blocked_set_cookie_count());
   }
 }
 
 TEST_F(URLRequestTest, DoNotSaveCookies_ViaPolicy) {
   LocalHttpTestServer test_server;
   ASSERT_TRUE(test_server.Start());
 
@@ skipping 37 matching lines @@
     TestNetworkDelegate network_delegate;
     default_context_.set_network_delegate(&network_delegate);
     TestDelegate d;
     URLRequest req(test_server.GetURL("echoheader?Cookie"),
                    DEFAULT_PRIORITY,
                    &d,
                    &default_context_);
     req.Start();
     base::RunLoop().Run();
 
-    EXPECT_TRUE(d.data_received().find("CookieToNotSave=1")
-                == std::string::npos);
-    EXPECT_TRUE(d.data_received().find("CookieToNotUpdate=2")
-                != std::string::npos);
+    EXPECT_TRUE(d.data_received().find("CookieToNotSave=1") ==
+                std::string::npos);
+    EXPECT_TRUE(d.data_received().find("CookieToNotUpdate=2") !=
+                std::string::npos);
 
     EXPECT_EQ(0, network_delegate.blocked_get_cookies_count());
     EXPECT_EQ(0, network_delegate.blocked_set_cookie_count());
   }
 }
 
 TEST_F(URLRequestTest, DoNotSaveEmptyCookies) {
   LocalHttpTestServer test_server;
   ASSERT_TRUE(test_server.Start());
 
@@ skipping 40 matching lines @@
     TestNetworkDelegate network_delegate;
     default_context_.set_network_delegate(&network_delegate);
     TestDelegate d;
     URLRequest req(test_server.GetURL("echoheader?Cookie"),
                    DEFAULT_PRIORITY,
                    &d,
                    &default_context_);
     req.Start();
     base::RunLoop().Run();
 
-    EXPECT_TRUE(d.data_received().find("CookieToNotSend=1")
-                != std::string::npos);
+    EXPECT_TRUE(d.data_received().find("CookieToNotSend=1") !=
+                std::string::npos);
 
     EXPECT_EQ(0, network_delegate.blocked_get_cookies_count());
     EXPECT_EQ(0, network_delegate.blocked_set_cookie_count());
   }
 
   // Verify that the cookie isn't sent.
   {
     TestNetworkDelegate network_delegate;
     default_context_.set_network_delegate(&network_delegate);
     TestDelegate d;
     network_delegate.set_cookie_options(TestNetworkDelegate::NO_GET_COOKIES);
     URLRequest req(test_server.GetURL("echoheader?Cookie"),
                    DEFAULT_PRIORITY,
                    &d,
                    &default_context_);
     req.Start();
     base::RunLoop().Run();
 
-    EXPECT_TRUE(d.data_received().find("Cookie: CookieToNotSend=1")
-                == std::string::npos);
+    EXPECT_TRUE(d.data_received().find("Cookie: CookieToNotSend=1") ==
+                std::string::npos);
 
     EXPECT_EQ(1, network_delegate.blocked_get_cookies_count());
     EXPECT_EQ(0, network_delegate.blocked_set_cookie_count());
   }
 }
 
 TEST_F(URLRequestTest, DoNotSaveCookies_ViaPolicy_Async) {
   LocalHttpTestServer test_server;
   ASSERT_TRUE(test_server.Start());
 
@@ skipping 37 matching lines @@
     TestNetworkDelegate network_delegate;
     default_context_.set_network_delegate(&network_delegate);
     TestDelegate d;
     URLRequest req(test_server.GetURL("echoheader?Cookie"),
                    DEFAULT_PRIORITY,
                    &d,
                    &default_context_);
     req.Start();
     base::RunLoop().Run();
 
-    EXPECT_TRUE(d.data_received().find("CookieToNotSave=1")
-                == std::string::npos);
-    EXPECT_TRUE(d.data_received().find("CookieToNotUpdate=2")
-                != std::string::npos);
+    EXPECT_TRUE(d.data_received().find("CookieToNotSave=1") ==
+                std::string::npos);
+    EXPECT_TRUE(d.data_received().find("CookieToNotUpdate=2") !=
+                std::string::npos);
 
     EXPECT_EQ(0, network_delegate.blocked_get_cookies_count());
     EXPECT_EQ(0, network_delegate.blocked_set_cookie_count());
   }
 }
 
 // FixedDateNetworkDelegate swaps out the server's HTTP Date response header
 // value for the |fixed_date| argument given to the constructor.
 class FixedDateNetworkDelegate : public TestNetworkDelegate {
  public:
@@ skipping 93 matching lines @@
                    DEFAULT_PRIORITY,
                    &d,
                    &default_context_);
     req.Start();
     base::RunLoop().Run();
 
     EXPECT_TRUE(d.data_received().find("StillGood=1") != std::string::npos);
   }
 }
 
-
 // Check that it is impossible to change the referrer in the extra headers of
 // an URLRequest.
 TEST_F(URLRequestTest, DoNotOverrideReferrer) {
   LocalHttpTestServer test_server;
   ASSERT_TRUE(test_server.Start());
 
   // If extra headers contain referer and the request contains a referer,
   // only the latter shall be respected.
   {
     TestDelegate d;
@@ skipping 30 matching lines @@
     req.Start();
     base::RunLoop().Run();
 
     EXPECT_EQ("None", d.data_received());
   }
 }
 
 class URLRequestTestHTTP : public URLRequestTest {
  public:
   URLRequestTestHTTP()
-      : test_server_(base::FilePath(FILE_PATH_LITERAL(
-                                  "net/data/url_request_unittest"))) {
-  }
+      : test_server_(base::FilePath(
+            FILE_PATH_LITERAL("net/data/url_request_unittest"))) {}
 
  protected:
   // Requests |redirect_url|, which must return a HTTP 3xx redirect.
   // |request_method| is the method to use for the initial request.
   // |redirect_method| is the method that is expected to be used for the second
   // request, after redirection.
   // If |include_data| is true, data is uploaded with the request.  The
   // response body is expected to match it exactly, if and only if
   // |request_method| == |redirect_method|.
   void HTTPRedirectMethodTest(const GURL& redirect_url,
@@ skipping 23 matching lines @@
         EXPECT_NE(kData, d.data_received());
       }
     }
     if (HasFailure())
       LOG(WARNING) << "Request method was: " << request_method;
   }
 
   void HTTPUploadDataOperationTest(const std::string& method) {
     const int kMsgSize = 20000;  // multiple of 10
     const int kIterations = 50;
-    char* uploadBytes = new char[kMsgSize+1];
+    char* uploadBytes = new char[kMsgSize + 1];
     char* ptr = uploadBytes;
     char marker = 'a';
-    for (int idx = 0; idx < kMsgSize/10; idx++) {
+    for (int idx = 0; idx < kMsgSize / 10; idx++) {
       memcpy(ptr, "----------", 10);
       ptr += 10;
       if (idx % 100 == 0) {
         ptr--;
         *ptr++ = marker;
         if (++marker > 'z')
           marker = 'a';
       }
     }
     uploadBytes[kMsgSize] = '\0';
@@ skipping 127 matching lines @@
     EXPECT_EQ(0, d.received_redirect_count());
 
     EXPECT_EQ(1, network_delegate.error_count());
     EXPECT_EQ(ERR_TUNNEL_CONNECTION_FAILED, network_delegate.last_error());
   }
 }
 
 // Tests that we can block and asynchronously return OK in various stages.
 TEST_F(URLRequestTestHTTP, NetworkDelegateBlockAsynchronously) {
   static const BlockingNetworkDelegate::Stage blocking_stages[] = {
-    BlockingNetworkDelegate::ON_BEFORE_URL_REQUEST,
-    BlockingNetworkDelegate::ON_BEFORE_SEND_HEADERS,
-    BlockingNetworkDelegate::ON_HEADERS_RECEIVED
-  };
+      BlockingNetworkDelegate::ON_BEFORE_URL_REQUEST,
+      BlockingNetworkDelegate::ON_BEFORE_SEND_HEADERS,
+      BlockingNetworkDelegate::ON_HEADERS_RECEIVED};
   static const size_t blocking_stages_length = arraysize(blocking_stages);
 
   ASSERT_TRUE(test_server_.Start());
 
   TestDelegate d;
   BlockingNetworkDelegate network_delegate(
       BlockingNetworkDelegate::USER_CALLBACK);
   network_delegate.set_block_on(
       BlockingNetworkDelegate::ON_BEFORE_URL_REQUEST |
       BlockingNetworkDelegate::ON_BEFORE_SEND_HEADERS |
@@ skipping 295 matching lines @@
     EXPECT_EQ(0, r.status().error());
     EXPECT_EQ(200, r.GetResponseCode());
     EXPECT_TRUE(d.auth_required_called());
     EXPECT_EQ(1, network_delegate.created_requests());
     EXPECT_EQ(0, network_delegate.destroyed_requests());
   }
   EXPECT_EQ(1, network_delegate.destroyed_requests());
 }
 
 TEST_F(URLRequestTestHTTP,
-    NetworkDelegateOnAuthRequiredSyncNoAction_GetFullRequestHeaders) {
+       NetworkDelegateOnAuthRequiredSyncNoAction_GetFullRequestHeaders) {
   ASSERT_TRUE(test_server_.Start());
 
   TestDelegate d;
   BlockingNetworkDelegate network_delegate(
       BlockingNetworkDelegate::SYNCHRONOUS);
 
   TestURLRequestContext context(true);
   context.set_network_delegate(&network_delegate);
   context.Init();
 
@@ skipping 52 matching lines @@
     EXPECT_FALSE(d.auth_required_called());
     EXPECT_EQ(1, network_delegate.created_requests());
     EXPECT_EQ(0, network_delegate.destroyed_requests());
   }
   EXPECT_EQ(1, network_delegate.destroyed_requests());
 }
 
 // Same as above, but also tests that GetFullRequestHeaders returns the proper
 // headers (for the first or second request) when called at the proper times.
 TEST_F(URLRequestTestHTTP,
-    NetworkDelegateOnAuthRequiredSyncSetAuth_GetFullRequestHeaders) {
+       NetworkDelegateOnAuthRequiredSyncSetAuth_GetFullRequestHeaders) {
   ASSERT_TRUE(test_server_.Start());
 
   TestDelegate d;
   BlockingNetworkDelegate network_delegate(
       BlockingNetworkDelegate::SYNCHRONOUS);
   network_delegate.set_block_on(BlockingNetworkDelegate::ON_AUTH_REQUIRED);
   network_delegate.set_auth_retval(
       NetworkDelegate::AUTH_REQUIRED_RESPONSE_SET_AUTH);
 
   network_delegate.set_auth_credentials(AuthCredentials(kUser, kSecret));
@@ skipping 483 matching lines @@
 TEST_F(URLRequestTestHTTP, GetZippedTest) {
   ASSERT_TRUE(test_server_.Start());
 
   // Parameter that specifies the Content-Length field in the response:
   // C - Compressed length.
   // U - Uncompressed length.
   // L - Large length (larger than both C & U).
   // M - Medium length (between C & U).
   // S - Small length (smaller than both C & U).
   const char test_parameters[] = "CULMS";
-  const int num_tests = arraysize(test_parameters)- 1;  // Skip NULL.
+  const int num_tests = arraysize(test_parameters) - 1;  // Skip NULL.
   // C & U should be OK.
   // L & M are larger than the data sent, and show an error.
   // S has too little data, but we seem to accept it.
-  const bool test_expect_success[num_tests] =
-      { true, true, false, false, true };
+  const bool test_expect_success[num_tests] = {true, true, false, false, true};
 
-  for (int i = 0; i < num_tests ; i++) {
+  for (int i = 0; i < num_tests; i++) {
     TestDelegate d;
     {
-      std::string test_file =
-          base::StringPrintf("compressedfiles/BullRunSpeech.txt?%c",
-                             test_parameters[i]);
+      std::string test_file = base::StringPrintf(
+          "compressedfiles/BullRunSpeech.txt?%c", test_parameters[i]);
 
       TestNetworkDelegate network_delegate;  // Must outlive URLRequest.
       TestURLRequestContext context(true);
       context.set_network_delegate(&network_delegate);
       context.Init();
 
       URLRequest r(
           test_server_.GetURL(test_file), DEFAULT_PRIORITY, &d, &context);
       r.Start();
       EXPECT_TRUE(r.is_pending());
@@ skipping 14 matching lines @@
             << " Parameter = \"" << test_file << "\"";
       }
     }
   }
 }
 
 TEST_F(URLRequestTestHTTP, HTTPSToHTTPRedirectNoRefererTest) {
   ASSERT_TRUE(test_server_.Start());
 
   SpawnedTestServer https_test_server(
-      SpawnedTestServer::TYPE_HTTPS, SpawnedTestServer::kLocalhost,
+      SpawnedTestServer::TYPE_HTTPS,
+      SpawnedTestServer::kLocalhost,
       base::FilePath(FILE_PATH_LITERAL("net/data/ssl")));
   ASSERT_TRUE(https_test_server.Start());
 
   // An https server is sent a request with an https referer,
   // and responds with a redirect to an http url. The http
   // server should not be sent the referer.
   GURL http_destination = test_server_.GetURL(std::string());
   TestDelegate d;
   URLRequest req(
       https_test_server.GetURL("server-redirect?" + http_destination.spec()),
@@ skipping 47 matching lines @@
   EXPECT_LE(load_timing_info_before_redirect.receive_headers_end,
             load_timing_info.connect_timing.connect_start);
 }
 
 TEST_F(URLRequestTestHTTP, MultipleRedirectTest) {
   ASSERT_TRUE(test_server_.Start());
 
   GURL destination_url = test_server_.GetURL(std::string());
   GURL middle_redirect_url =
       test_server_.GetURL("server-redirect?" + destination_url.spec());
-  GURL original_url = test_server_.GetURL(
-      "server-redirect?" + middle_redirect_url.spec());
+  GURL original_url =
+      test_server_.GetURL("server-redirect?" + middle_redirect_url.spec());
   TestDelegate d;
   URLRequest req(original_url, DEFAULT_PRIORITY, &d, &default_context_);
   req.Start();
   base::RunLoop().Run();
 
   EXPECT_EQ(1, d.response_started_count());
   EXPECT_EQ(2, d.received_redirect_count());
   EXPECT_EQ(destination_url, req.url());
   EXPECT_EQ(original_url, req.original_url());
   ASSERT_EQ(3U, req.url_chain().size());
@@ skipping 16 matching lines @@
   typedef base::Callback<void()> Callback;
 
   // Each time delegate information is added to the URLRequest, the resulting
   // load state is checked.  The expected load state after each request is
   // passed in as an argument.
   static void Run(URLRequest* url_request,
                   LoadState expected_first_load_state,
                   LoadState expected_second_load_state,
                   LoadState expected_third_load_state,
                   const Callback& callback) {
-    AsyncDelegateLogger* logger = new AsyncDelegateLogger(
-        url_request,
-        expected_first_load_state,
-        expected_second_load_state,
-        expected_third_load_state,
-        callback);
+    AsyncDelegateLogger* logger =
+        new AsyncDelegateLogger(url_request,
+                                expected_first_load_state,
+                                expected_second_load_state,
+                                expected_third_load_state,
+                                callback);
     logger->Start();
   }
 
   // Checks that the log entries, starting with log_position, contain the
   // DELEGATE_INFO NetLog events that an AsyncDelegateLogger should have
   // recorded.  Returns the index of entry after the expected number of
   // events this logged, or entries.size() if there aren't enough entries.
   static size_t CheckDelegateInfo(
-      const CapturingNetLog::CapturedEntryList& entries, size_t log_position) {
+      const CapturingNetLog::CapturedEntryList& entries,
+      size_t log_position) {
     // There should be 4 DELEGATE_INFO events: Two begins and two ends.
     if (log_position + 3 >= entries.size()) {
       ADD_FAILURE() << "Not enough log entries";
       return entries.size();
     }
     std::string delegate_info;
     EXPECT_EQ(NetLog::TYPE_DELEGATE_INFO, entries[log_position].type);
     EXPECT_EQ(NetLog::PHASE_BEGIN, entries[log_position].phase);
-    EXPECT_TRUE(entries[log_position].GetStringValue("delegate_info",
-                                                     &delegate_info));
+    EXPECT_TRUE(
+        entries[log_position].GetStringValue("delegate_info", &delegate_info));
     EXPECT_EQ(kFirstDelegateInfo, delegate_info);
 
     ++log_position;
     EXPECT_EQ(NetLog::TYPE_DELEGATE_INFO, entries[log_position].type);
     EXPECT_EQ(NetLog::PHASE_END, entries[log_position].phase);
 
     ++log_position;
     EXPECT_EQ(NetLog::TYPE_DELEGATE_INFO, entries[log_position].type);
     EXPECT_EQ(NetLog::PHASE_BEGIN, entries[log_position].phase);
-    EXPECT_TRUE(entries[log_position].GetStringValue("delegate_info",
-                                                     &delegate_info));
+    EXPECT_TRUE(
+        entries[log_position].GetStringValue("delegate_info", &delegate_info));
     EXPECT_EQ(kSecondDelegateInfo, delegate_info);
 
     ++log_position;
     EXPECT_EQ(NetLog::TYPE_DELEGATE_INFO, entries[log_position].type);
     EXPECT_EQ(NetLog::PHASE_END, entries[log_position].phase);
 
     return log_position + 1;
   }
 
   // Find delegate request begin and end messages for OnBeforeNetworkStart.
@@ skipping 17 matching lines @@
 
   AsyncDelegateLogger(URLRequest* url_request,
                       LoadState expected_first_load_state,
                       LoadState expected_second_load_state,
                       LoadState expected_third_load_state,
                       const Callback& callback)
       : url_request_(url_request),
         expected_first_load_state_(expected_first_load_state),
         expected_second_load_state_(expected_second_load_state),
         expected_third_load_state_(expected_third_load_state),
-        callback_(callback) {
-  }
+        callback_(callback) {}
 
   ~AsyncDelegateLogger() {}
 
   void Start() {
     url_request_->LogBlockedBy(kFirstDelegateInfo);
     LoadStateWithParam load_state = url_request_->GetLoadState();
     EXPECT_EQ(expected_first_load_state_, load_state.state);
     EXPECT_NE(ASCIIToUTF16(kFirstDelegateInfo), load_state.param);
     base::MessageLoop::current()->PostTask(
-        FROM_HERE,
-        base::Bind(&AsyncDelegateLogger::LogSecondDelegate, this));
+        FROM_HERE, base::Bind(&AsyncDelegateLogger::LogSecondDelegate, this));
   }
 
   void LogSecondDelegate() {
     url_request_->LogAndReportBlockedBy(kSecondDelegateInfo);
     LoadStateWithParam load_state = url_request_->GetLoadState();
     EXPECT_EQ(expected_second_load_state_, load_state.state);
     if (expected_second_load_state_ == LOAD_STATE_WAITING_FOR_DELEGATE) {
       EXPECT_EQ(ASCIIToUTF16(kSecondDelegateInfo), load_state.param);
     } else {
       EXPECT_NE(ASCIIToUTF16(kSecondDelegateInfo), load_state.param);
     }
     base::MessageLoop::current()->PostTask(
-        FROM_HERE,
-        base::Bind(&AsyncDelegateLogger::LogComplete, this));
+        FROM_HERE, base::Bind(&AsyncDelegateLogger::LogComplete, this));
   }
 
   void LogComplete() {
     url_request_->LogUnblocked();
     LoadStateWithParam load_state = url_request_->GetLoadState();
     EXPECT_EQ(expected_third_load_state_, load_state.state);
     if (expected_second_load_state_ == LOAD_STATE_WAITING_FOR_DELEGATE)
       EXPECT_EQ(base::string16(), load_state.param);
     callback_.Run();
   }
@@ skipping 48 matching lines @@
       URLRequest* request,
       const AuthChallengeInfo& auth_info,
       const AuthCallback& callback,
       AuthCredentials* credentials) OVERRIDE {
     AsyncDelegateLogger::Run(
         request,
         LOAD_STATE_WAITING_FOR_DELEGATE,
         LOAD_STATE_WAITING_FOR_DELEGATE,
         LOAD_STATE_WAITING_FOR_DELEGATE,
         base::Bind(&AsyncLoggingNetworkDelegate::SetAuthAndResume,
-                   callback, credentials));
+                   callback,
+                   credentials));
     return AUTH_REQUIRED_RESPONSE_IO_PENDING;
   }
 
  private:
-  static int RunCallbackAsynchronously(
-      URLRequest* request,
-      const CompletionCallback& callback) {
-    AsyncDelegateLogger::Run(
-        request,
-        LOAD_STATE_WAITING_FOR_DELEGATE,
-        LOAD_STATE_WAITING_FOR_DELEGATE,
-        LOAD_STATE_WAITING_FOR_DELEGATE,
-        base::Bind(callback, OK));
+  static int RunCallbackAsynchronously(URLRequest* request,
+                                       const CompletionCallback& callback) {
+    AsyncDelegateLogger::Run(request,
+                             LOAD_STATE_WAITING_FOR_DELEGATE,
+                             LOAD_STATE_WAITING_FOR_DELEGATE,
+                             LOAD_STATE_WAITING_FOR_DELEGATE,
+                             base::Bind(callback, OK));
     return ERR_IO_PENDING;
   }
 
   static void SetAuthAndResume(const AuthCallback& callback,
                                AuthCredentials* credentials) {
     *credentials = AuthCredentials(kUser, kSecret);
     callback.Run(NetworkDelegate::AUTH_REQUIRED_RESPONSE_SET_AUTH);
   }
 
   DISALLOW_COPY_AND_ASSIGN(AsyncLoggingNetworkDelegate);
@@ skipping 30 matching lines @@
                                   const GURL& new_url,
                                   bool* defer_redirect) OVERRIDE {
     *defer_redirect = true;
     AsyncDelegateLogger::Run(
         request,
         LOAD_STATE_WAITING_FOR_DELEGATE,
         LOAD_STATE_WAITING_FOR_DELEGATE,
         LOAD_STATE_WAITING_FOR_DELEGATE,
         base::Bind(
             &AsyncLoggingUrlRequestDelegate::OnReceivedRedirectLoggingComplete,
-            base::Unretained(this), request, new_url));
+            base::Unretained(this),
+            request,
+            new_url));
   }
 
   virtual void OnResponseStarted(URLRequest* request) OVERRIDE {
     AsyncDelegateLogger::Run(
-      request,
-      LOAD_STATE_WAITING_FOR_DELEGATE,
-      LOAD_STATE_WAITING_FOR_DELEGATE,
-      LOAD_STATE_WAITING_FOR_DELEGATE,
-      base::Bind(
-          &AsyncLoggingUrlRequestDelegate::OnResponseStartedLoggingComplete,
-          base::Unretained(this), request));
+        request,
+        LOAD_STATE_WAITING_FOR_DELEGATE,
+        LOAD_STATE_WAITING_FOR_DELEGATE,
+        LOAD_STATE_WAITING_FOR_DELEGATE,
+        base::Bind(
+            &AsyncLoggingUrlRequestDelegate::OnResponseStartedLoggingComplete,
+            base::Unretained(this),
+            request));
   }
 
-  virtual void OnReadCompleted(URLRequest* request,
-                               int bytes_read) OVERRIDE {
+  virtual void OnReadCompleted(URLRequest* request, int bytes_read) OVERRIDE {
     AsyncDelegateLogger::Run(
         request,
         LOAD_STATE_IDLE,
         LOAD_STATE_IDLE,
         LOAD_STATE_IDLE,
         base::Bind(
             &AsyncLoggingUrlRequestDelegate::AfterReadCompletedLoggingComplete,
-            base::Unretained(this), request, bytes_read));
+            base::Unretained(this),
+            request,
+            bytes_read));
   }
 
  private:
   void OnReceivedRedirectLoggingComplete(URLRequest* request,
                                          const GURL& new_url) {
     bool defer_redirect = false;
     TestDelegate::OnReceivedRedirect(request, new_url, &defer_redirect);
     // FollowDeferredRedirect should not be called after cancellation.
     if (cancel_stage_ == CANCEL_ON_RECEIVED_REDIRECT)
       return;
@@ skipping 44 matching lines @@
 
     base::RunLoop().Run();
 
     EXPECT_EQ(200, r.GetResponseCode());
     EXPECT_EQ(URLRequestStatus::SUCCESS, r.status().status());
   }
 
   CapturingNetLog::CapturedEntryList entries;
   net_log_.GetEntries(&entries);
   size_t log_position = ExpectLogContainsSomewhereAfter(
-      entries,
-      0,
-      NetLog::TYPE_DELEGATE_INFO,
-      NetLog::PHASE_BEGIN);
+      entries, 0, NetLog::TYPE_DELEGATE_INFO, NetLog::PHASE_BEGIN);
 
   log_position = AsyncDelegateLogger::CheckDelegateInfo(entries, log_position);
 
   // Nothing else should add any delegate info to the request.
   EXPECT_FALSE(LogContainsEntryWithTypeAfter(
       entries, log_position + 1, NetLog::TYPE_DELEGATE_INFO));
 }
 
 // Tests handling of delegate info from a network delegate.
 TEST_F(URLRequestTestHTTP, NetworkDelegateInfo) {
@@ skipping 22 matching lines @@
     EXPECT_EQ(URLRequestStatus::SUCCESS, r.status().status());
     EXPECT_EQ(1, network_delegate.created_requests());
     EXPECT_EQ(0, network_delegate.destroyed_requests());
   }
   EXPECT_EQ(1, network_delegate.destroyed_requests());
 
   size_t log_position = 0;
   CapturingNetLog::CapturedEntryList entries;
   net_log_.GetEntries(&entries);
   for (size_t i = 0; i < 3; ++i) {
-    log_position = ExpectLogContainsSomewhereAfter(
-        entries,
-        log_position + 1,
-        NetLog::TYPE_URL_REQUEST_DELEGATE,
-        NetLog::PHASE_BEGIN);
+    log_position =
+        ExpectLogContainsSomewhereAfter(entries,
+                                        log_position + 1,
+                                        NetLog::TYPE_URL_REQUEST_DELEGATE,
+                                        NetLog::PHASE_BEGIN);
 
-    log_position = AsyncDelegateLogger::CheckDelegateInfo(entries,
-                                                          log_position + 1);
+    log_position =
+        AsyncDelegateLogger::CheckDelegateInfo(entries, log_position + 1);
 
     ASSERT_LT(log_position, entries.size());
     EXPECT_EQ(NetLog::TYPE_URL_REQUEST_DELEGATE, entries[log_position].type);
     EXPECT_EQ(NetLog::PHASE_END, entries[log_position].phase);
 
     if (i == 1) {
       log_position = AsyncDelegateLogger::ExpectBeforeNetworkEvents(
           entries, log_position + 1);
     }
   }
@@ skipping 32 matching lines @@
     EXPECT_EQ(0, network_delegate.destroyed_requests());
   }
   EXPECT_EQ(1, network_delegate.destroyed_requests());
 
   size_t log_position = 0;
   CapturingNetLog::CapturedEntryList entries;
   net_log_.GetEntries(&entries);
   // The NetworkDelegate logged information in OnBeforeURLRequest,
   // OnBeforeSendHeaders, and OnHeadersReceived.
   for (size_t i = 0; i < 3; ++i) {
-    log_position = ExpectLogContainsSomewhereAfter(
-        entries,
-        log_position + 1,
-        NetLog::TYPE_URL_REQUEST_DELEGATE,
-        NetLog::PHASE_BEGIN);
+    log_position =
+        ExpectLogContainsSomewhereAfter(entries,
+                                        log_position + 1,
+                                        NetLog::TYPE_URL_REQUEST_DELEGATE,
+                                        NetLog::PHASE_BEGIN);
 
-    log_position = AsyncDelegateLogger::CheckDelegateInfo(entries,
-                                                          log_position + 1);
+    log_position =
+        AsyncDelegateLogger::CheckDelegateInfo(entries, log_position + 1);
 
     ASSERT_LT(log_position, entries.size());
     EXPECT_EQ(NetLog::TYPE_URL_REQUEST_DELEGATE, entries[log_position].type);
     EXPECT_EQ(NetLog::PHASE_END, entries[log_position].phase);
 
     if (i == 1) {
       log_position = AsyncDelegateLogger::ExpectBeforeNetworkEvents(
           entries, log_position + 1);
     }
   }
 
   // The URLRequest::Delegate then gets informed about the redirect.
-  log_position = ExpectLogContainsSomewhereAfter(
-      entries,
-      log_position + 1,
-      NetLog::TYPE_URL_REQUEST_DELEGATE,
-      NetLog::PHASE_BEGIN);
+  log_position =
+      ExpectLogContainsSomewhereAfter(entries,
+                                      log_position + 1,
+                                      NetLog::TYPE_URL_REQUEST_DELEGATE,
+                                      NetLog::PHASE_BEGIN);
 
   // The NetworkDelegate logged information in the same three events as before.
   for (size_t i = 0; i < 3; ++i) {
-    log_position = ExpectLogContainsSomewhereAfter(
-        entries,
-        log_position + 1,
-        NetLog::TYPE_URL_REQUEST_DELEGATE,
-        NetLog::PHASE_BEGIN);
+    log_position =
+        ExpectLogContainsSomewhereAfter(entries,
+                                        log_position + 1,
+                                        NetLog::TYPE_URL_REQUEST_DELEGATE,
+                                        NetLog::PHASE_BEGIN);
 
-    log_position = AsyncDelegateLogger::CheckDelegateInfo(entries,
-                                                          log_position + 1);
+    log_position =
+        AsyncDelegateLogger::CheckDelegateInfo(entries, log_position + 1);
 
     ASSERT_LT(log_position, entries.size());
     EXPECT_EQ(NetLog::TYPE_URL_REQUEST_DELEGATE, entries[log_position].type);
     EXPECT_EQ(NetLog::PHASE_END, entries[log_position].phase);
   }
 
   EXPECT_FALSE(LogContainsEntryWithTypeAfter(
       entries, log_position + 1, NetLog::TYPE_DELEGATE_INFO));
 }
 
@@ skipping 28 matching lines @@
   }
   EXPECT_EQ(1, network_delegate.destroyed_requests());
 
   size_t log_position = 0;
   CapturingNetLog::CapturedEntryList entries;
   net_log_.GetEntries(&entries);
   // The NetworkDelegate should have logged information in OnBeforeURLRequest,
   // OnBeforeSendHeaders, OnHeadersReceived, OnAuthRequired, and then again in
   // OnBeforeURLRequest and OnBeforeSendHeaders.
   for (size_t i = 0; i < 6; ++i) {
-    log_position = ExpectLogContainsSomewhereAfter(
-        entries,
-        log_position + 1,
-        NetLog::TYPE_URL_REQUEST_DELEGATE,
-        NetLog::PHASE_BEGIN);
+    log_position =
+        ExpectLogContainsSomewhereAfter(entries,
+                                        log_position + 1,
+                                        NetLog::TYPE_URL_REQUEST_DELEGATE,
+                                        NetLog::PHASE_BEGIN);
 
-    log_position = AsyncDelegateLogger::CheckDelegateInfo(entries,
-                                                          log_position + 1);
+    log_position =
+        AsyncDelegateLogger::CheckDelegateInfo(entries, log_position + 1);
 
     ASSERT_LT(log_position, entries.size());
     EXPECT_EQ(NetLog::TYPE_URL_REQUEST_DELEGATE, entries[log_position].type);
     EXPECT_EQ(NetLog::PHASE_END, entries[log_position].phase);
 
     if (i == 1) {
       log_position = AsyncDelegateLogger::ExpectBeforeNetworkEvents(
           entries, log_position + 1);
     }
   }
@@ skipping 29 matching lines @@
 
     EXPECT_EQ(200, r.GetResponseCode());
     EXPECT_EQ(URLRequestStatus::SUCCESS, r.status().status());
   }
 
   CapturingNetLog::CapturedEntryList entries;
   net_log_.GetEntries(&entries);
 
   size_t log_position = 0;
 
-  log_position = AsyncDelegateLogger::ExpectBeforeNetworkEvents(
-      entries, log_position);
+  log_position =
+      AsyncDelegateLogger::ExpectBeforeNetworkEvents(entries, log_position);
 
   // The delegate info should only have been logged on header complete.  Other
   // times it should silently be ignored.
   log_position =
       ExpectLogContainsSomewhereAfter(entries,
                                       log_position + 1,
                                       NetLog::TYPE_URL_REQUEST_DELEGATE,
                                       NetLog::PHASE_BEGIN);
 
-  log_position = AsyncDelegateLogger::CheckDelegateInfo(entries,
-                                                        log_position + 1);
+  log_position =
+      AsyncDelegateLogger::CheckDelegateInfo(entries, log_position + 1);
 
   ASSERT_LT(log_position, entries.size());
   EXPECT_EQ(NetLog::TYPE_URL_REQUEST_DELEGATE, entries[log_position].type);
   EXPECT_EQ(NetLog::PHASE_END, entries[log_position].phase);
 
   EXPECT_FALSE(LogContainsEntryWithTypeAfter(
       entries, log_position + 1, NetLog::TYPE_DELEGATE_INFO));
   EXPECT_FALSE(LogContainsEntryWithTypeAfter(
       entries, log_position + 1, NetLog::TYPE_URL_REQUEST_DELEGATE));
 }
@@ skipping 25 matching lines @@
 
   CapturingNetLog::CapturedEntryList entries;
   net_log_.GetEntries(&entries);
 
   // Delegate info should only have been logged in OnReceivedRedirect and
   // OnResponseStarted.
   size_t log_position = 0;
   for (int i = 0; i < 2; ++i) {
     if (i == 0) {
       log_position = AsyncDelegateLogger::ExpectBeforeNetworkEvents(
-                         entries, log_position) + 1;
+                         entries, log_position) +
+                     1;
     }
 
-    log_position = ExpectLogContainsSomewhereAfter(
-            entries,
-            log_position,
-            NetLog::TYPE_URL_REQUEST_DELEGATE,
-            NetLog::PHASE_BEGIN);
+    log_position =
+        ExpectLogContainsSomewhereAfter(entries,
+                                        log_position,
+                                        NetLog::TYPE_URL_REQUEST_DELEGATE,
+                                        NetLog::PHASE_BEGIN);
 
-    log_position = AsyncDelegateLogger::CheckDelegateInfo(entries,
-                                                          log_position + 1);
+    log_position =
+        AsyncDelegateLogger::CheckDelegateInfo(entries, log_position + 1);
 
     ASSERT_LT(log_position, entries.size());
     EXPECT_EQ(NetLog::TYPE_URL_REQUEST_DELEGATE, entries[log_position].type);
     EXPECT_EQ(NetLog::PHASE_END, entries[log_position].phase);
   }
 
   EXPECT_FALSE(LogContainsEntryWithTypeAfter(
       entries, log_position + 1, NetLog::TYPE_DELEGATE_INFO));
   EXPECT_FALSE(LogContainsEntryWithTypeAfter(
       entries, log_position + 1, NetLog::TYPE_URL_REQUEST_DELEGATE));
 }
 
 // Tests handling of delegate info from a URLRequest::Delegate in the case of
 // an HTTP redirect, with cancellation at various points.
 TEST_F(URLRequestTestHTTP, URLRequestDelegateOnRedirectCancelled) {
   ASSERT_TRUE(test_server_.Start());
 
   const AsyncLoggingUrlRequestDelegate::CancelStage kCancelStages[] = {
-    AsyncLoggingUrlRequestDelegate::CANCEL_ON_RECEIVED_REDIRECT,
-    AsyncLoggingUrlRequestDelegate::CANCEL_ON_RESPONSE_STARTED,
-    AsyncLoggingUrlRequestDelegate::CANCEL_ON_READ_COMPLETED,
+      AsyncLoggingUrlRequestDelegate::CANCEL_ON_RECEIVED_REDIRECT,
+      AsyncLoggingUrlRequestDelegate::CANCEL_ON_RESPONSE_STARTED,
+      AsyncLoggingUrlRequestDelegate::CANCEL_ON_READ_COMPLETED,
   };
 
   for (size_t test_case = 0; test_case < arraysize(kCancelStages);
        ++test_case) {
     AsyncLoggingUrlRequestDelegate request_delegate(kCancelStages[test_case]);
     TestURLRequestContext context(true);
     CapturingNetLog net_log;
     context.set_network_delegate(NULL);
     context.set_net_log(&net_log);
     context.Init();
@@ skipping 13 matching lines @@
     net_log.GetEntries(&entries);
 
     // Delegate info is always logged in both OnReceivedRedirect and
     // OnResponseStarted.  In the CANCEL_ON_RECEIVED_REDIRECT, the
     // OnResponseStarted delegate call is after cancellation, but logging is
     // still currently supported in that call.
     size_t log_position = 0;
     for (int i = 0; i < 2; ++i) {
       if (i == 0) {
         log_position = AsyncDelegateLogger::ExpectBeforeNetworkEvents(
-                           entries, log_position) + 1;
+                           entries, log_position) +
+                       1;
       }
 
-      log_position = ExpectLogContainsSomewhereAfter(
-              entries,
-              log_position,
-              NetLog::TYPE_URL_REQUEST_DELEGATE,
-              NetLog::PHASE_BEGIN);
+      log_position =
+          ExpectLogContainsSomewhereAfter(entries,
+                                          log_position,
+                                          NetLog::TYPE_URL_REQUEST_DELEGATE,
+                                          NetLog::PHASE_BEGIN);
 
-      log_position = AsyncDelegateLogger::CheckDelegateInfo(entries,
-                                                            log_position + 1);
+      log_position =
+          AsyncDelegateLogger::CheckDelegateInfo(entries, log_position + 1);
 
       ASSERT_LT(log_position, entries.size());
       EXPECT_EQ(NetLog::TYPE_URL_REQUEST_DELEGATE, entries[log_position].type);
       EXPECT_EQ(NetLog::PHASE_END, entries[log_position].phase);
     }
 
     EXPECT_FALSE(LogContainsEntryWithTypeAfter(
         entries, log_position + 1, NetLog::TYPE_DELEGATE_INFO));
     EXPECT_FALSE(LogContainsEntryWithTypeAfter(
         entries, log_position + 1, NetLog::TYPE_URL_REQUEST_DELEGATE));
@@ skipping 12 matching lines @@
     TestDelegate::OnReceivedRedirect(request, new_url, defer_redirect);
     request->SetExtraRequestHeaderByName(kExtraHeader, kExtraValue, false);
   }
 };
 
 }  // namespace
 
 TEST_F(URLRequestTestHTTP, RedirectWithAdditionalHeadersTest) {
   ASSERT_TRUE(test_server_.Start());
 
-  GURL destination_url = test_server_.GetURL(
-      "echoheader?" + std::string(kExtraHeader));
-  GURL original_url = test_server_.GetURL(
-      "server-redirect?" + destination_url.spec());
+  GURL destination_url =
+      test_server_.GetURL("echoheader?" + std::string(kExtraHeader));
+  GURL original_url =
+      test_server_.GetURL("server-redirect?" + destination_url.spec());
   RedirectWithAdditionalHeadersDelegate d;
   URLRequest req(original_url, DEFAULT_PRIORITY, &d, &default_context_);
   req.Start();
   base::RunLoop().Run();
 
   std::string value;
   const HttpRequestHeaders& headers = req.extra_request_headers();
   EXPECT_TRUE(headers.GetHeader(kExtraHeader, &value));
   EXPECT_EQ(kExtraValue, value);
   EXPECT_FALSE(req.is_pending());
   EXPECT_FALSE(req.is_redirecting());
   EXPECT_EQ(kExtraValue, d.data_received());
 }
 
 namespace {
 
 const char kExtraHeaderToRemove[] = "To-Be-Removed";
 
 class RedirectWithHeaderRemovalDelegate : public TestDelegate {
   virtual void OnReceivedRedirect(net::URLRequest* request,
-                          const GURL& new_url,
-                          bool* defer_redirect) OVERRIDE {
+                                  const GURL& new_url,
+                                  bool* defer_redirect) OVERRIDE {
     TestDelegate::OnReceivedRedirect(request, new_url, defer_redirect);
     request->RemoveRequestHeaderByName(kExtraHeaderToRemove);
   }
 };
 
 }  // namespace
 
 TEST_F(URLRequestTestHTTP, RedirectWithHeaderRemovalTest) {
   ASSERT_TRUE(test_server_.Start());
 
-  GURL destination_url = test_server_.GetURL(
-      "echoheader?" + std::string(kExtraHeaderToRemove));
-  GURL original_url = test_server_.GetURL(
-      "server-redirect?" + destination_url.spec());
+  GURL destination_url =
+      test_server_.GetURL("echoheader?" + std::string(kExtraHeaderToRemove));
+  GURL original_url =
+      test_server_.GetURL("server-redirect?" + destination_url.spec());
   RedirectWithHeaderRemovalDelegate d;
   URLRequest req(original_url, DEFAULT_PRIORITY, &d, &default_context_);
   req.SetExtraRequestHeaderByName(kExtraHeaderToRemove, "dummy", false);
   req.Start();
   base::RunLoop().Run();
 
   std::string value;
   const HttpRequestHeaders& headers = req.extra_request_headers();
   EXPECT_FALSE(headers.GetHeader(kExtraHeaderToRemove, &value));
   EXPECT_FALSE(req.is_pending());
@@ skipping 189 matching lines @@
     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("with-headers.html"));
     element_readers.push_back(
         new UploadFileElementReader(base::MessageLoopProxy::current().get(),
                                     path,
                                     0,
                                     kuint64max,
                                     base::Time()));
-    r.set_upload(make_scoped_ptr(
-        new UploadDataStream(element_readers.Pass(), 0)));
+    r.set_upload(
+        make_scoped_ptr(new UploadDataStream(element_readers.Pass(), 0)));
 
     r.Start();
     EXPECT_TRUE(r.is_pending());
 
     base::RunLoop().Run();
 
     int64 size = 0;
     ASSERT_EQ(true, base::GetFileSize(path, &size));
     scoped_ptr<char[]> buf(new char[size]);
 
     ASSERT_EQ(size, base::ReadFile(path, buf.get(), size));
 
     ASSERT_EQ(1, d.response_started_count())
         << "request failed: " << r.status().status()
         << ", error: " << r.status().error();
 
     EXPECT_FALSE(d.received_data_before_response());
 
     EXPECT_EQ(size, d.bytes_received());
     EXPECT_EQ(std::string(&buf[0], size), d.data_received());
   }
 }
 
 TEST_F(URLRequestTestHTTP, PostUnreadableFileTest) {
   ASSERT_TRUE(test_server_.Start());
 
   TestDelegate d;
   {
-    URLRequest r(test_server_.GetURL("echo"), DEFAULT_PRIORITY,
-                 &d, &default_context_);
+    URLRequest r(
+        test_server_.GetURL("echo"), DEFAULT_PRIORITY, &d, &default_context_);
     r.set_method("POST");
 
     ScopedVector<UploadElementReader> element_readers;
 
     element_readers.push_back(new UploadFileElementReader(
         base::MessageLoopProxy::current().get(),
         base::FilePath(FILE_PATH_LITERAL(
             "c:\\path\\to\\non\\existant\\file.randomness.12345")),
         0,
         kuint64max,
         base::Time()));
-    r.set_upload(make_scoped_ptr(
-        new UploadDataStream(element_readers.Pass(), 0)));
+    r.set_upload(
+        make_scoped_ptr(new UploadDataStream(element_readers.Pass(), 0)));
 
     r.Start();
     EXPECT_TRUE(r.is_pending());
 
     base::RunLoop().Run();
 
     EXPECT_TRUE(d.request_failed());
     EXPECT_FALSE(d.received_data_before_response());
     EXPECT_EQ(0, d.bytes_received());
     EXPECT_EQ(URLRequestStatus::FAILED, r.status().status());
@@ skipping 109 matching lines @@
       default_context_.transport_security_state();
   bool sni_available = true;
   TransportSecurityState::DomainState domain_state;
   EXPECT_TRUE(security_state->GetDomainState(
       SpawnedTestServer::kLocalhost, sni_available, &domain_state));
   EXPECT_EQ(TransportSecurityState::DomainState::MODE_FORCE_HTTPS,
             domain_state.upgrade_mode);
   EXPECT_TRUE(domain_state.sts_include_subdomains);
   EXPECT_FALSE(domain_state.pkp_include_subdomains);
 #if defined(OS_ANDROID)
-  // Android's CertVerifyProc does not (yet) handle pins.
+// Android's CertVerifyProc does not (yet) handle pins.
 #else
   EXPECT_FALSE(domain_state.HasPublicKeyPins());
 #endif
 }
 
 // Android's CertVerifyProc does not (yet) handle pins. Therefore, it will
 // reject HPKP headers, and a test setting only HPKP headers will fail (no
 // DomainState present because header rejected).
 #if defined(OS_ANDROID)
 #define MAYBE_ProcessPKP DISABLED_ProcessPKP
@@ skipping 84 matching lines @@
   // We should have set parameters from the first header, not the second.
   TransportSecurityState* security_state =
       default_context_.transport_security_state();
   bool sni_available = true;
   TransportSecurityState::DomainState domain_state;
   EXPECT_TRUE(security_state->GetDomainState(
       SpawnedTestServer::kLocalhost, sni_available, &domain_state));
   EXPECT_EQ(TransportSecurityState::DomainState::MODE_FORCE_HTTPS,
             domain_state.upgrade_mode);
 #if defined(OS_ANDROID)
-  // Android's CertVerifyProc does not (yet) handle pins.
+// Android's CertVerifyProc does not (yet) handle pins.
 #else
   EXPECT_TRUE(domain_state.HasPublicKeyPins());
 #endif
   EXPECT_NE(domain_state.upgrade_expiry,
             domain_state.dynamic_spki_hashes_expiry);
 
   // Even though there is an HSTS header asserting includeSubdomains, it is
   // the *second* such header, and we MUST process only the first.
   EXPECT_FALSE(domain_state.sts_include_subdomains);
   // includeSubdomains does not occur in the test HPKP header.
@@ skipping 21 matching lines @@
 
   TransportSecurityState* security_state =
       default_context_.transport_security_state();
   bool sni_available = true;
   TransportSecurityState::DomainState domain_state;
   EXPECT_TRUE(security_state->GetDomainState(
       SpawnedTestServer::kLocalhost, sni_available, &domain_state));
   EXPECT_EQ(TransportSecurityState::DomainState::MODE_FORCE_HTTPS,
             domain_state.upgrade_mode);
 #if defined(OS_ANDROID)
-  // Android's CertVerifyProc does not (yet) handle pins.
+// Android's CertVerifyProc does not (yet) handle pins.
 #else
   EXPECT_TRUE(domain_state.HasPublicKeyPins());
 #endif
   EXPECT_NE(domain_state.upgrade_expiry,
             domain_state.dynamic_spki_hashes_expiry);
 
   EXPECT_TRUE(domain_state.sts_include_subdomains);
   EXPECT_FALSE(domain_state.pkp_include_subdomains);
 }
 
@@ skipping 288 matching lines @@
 // the reference fragment of the target URL must not be modified.
 TEST_F(URLRequestTestHTTP, RedirectJobWithReferenceFragment) {
   ASSERT_TRUE(test_server_.Start());
 
   GURL original_url(test_server_.GetURL("original#should-not-be-appended"));
   GURL redirect_url(test_server_.GetURL("echo"));
 
   TestDelegate d;
   URLRequest r(original_url, DEFAULT_PRIORITY, &d, &default_context_);
 
-  URLRequestRedirectJob* job = new URLRequestRedirectJob(
-      &r, &default_network_delegate_, redirect_url,
-      URLRequestRedirectJob::REDIRECT_302_FOUND, "Very Good Reason");
+  URLRequestRedirectJob* job =
+      new URLRequestRedirectJob(&r,
+                                &default_network_delegate_,
+                                redirect_url,
+                                URLRequestRedirectJob::REDIRECT_302_FOUND,
+                                "Very Good Reason");
   AddTestInterceptor()->set_main_intercept_job(job);
 
   r.Start();
   base::RunLoop().Run();
 
   EXPECT_EQ(URLRequestStatus::SUCCESS, r.status().status());
   EXPECT_EQ(net::OK, r.status().error());
   EXPECT_EQ(original_url, r.original_url());
   EXPECT_EQ(redirect_url, r.url());
 }
@@ skipping 378 matching lines @@
     d.set_credentials(AuthCredentials(kUser, kSecret));
 
     URLRequest r(url_requiring_auth, DEFAULT_PRIORITY, &d, &context);
     r.Start();
 
     base::RunLoop().Run();
 
     EXPECT_TRUE(d.data_received().find("user/secret") != std::string::npos);
 
     // Make sure we sent the cookie in the restarted transaction.
-    EXPECT_TRUE(d.data_received().find("Cookie: got_challenged=true")
-        != std::string::npos);
+    EXPECT_TRUE(d.data_received().find("Cookie: got_challenged=true") !=
+                std::string::npos);
   }
 
   // Same test as above, except this time the restart is initiated earlier
   // (without user intervention since identity is embedded in the URL).
   {
     TestNetworkDelegate network_delegate;  // Must outlive URLRequest.
     TestURLRequestContext context(true);
     context.set_network_delegate(&network_delegate);
     context.Init();
 
     TestDelegate d;
 
     GURL::Replacements replacements;
     std::string username("user2");
     std::string password("secret");
     replacements.SetUsernameStr(username);
     replacements.SetPasswordStr(password);
     GURL url_with_identity = url_requiring_auth.ReplaceComponents(replacements);
 
     URLRequest r(url_with_identity, DEFAULT_PRIORITY, &d, &context);
     r.Start();
 
     base::RunLoop().Run();
 
     EXPECT_TRUE(d.data_received().find("user2/secret") != std::string::npos);
 
     // Make sure we sent the cookie in the restarted transaction.
-    EXPECT_TRUE(d.data_received().find("Cookie: got_challenged=true")
-        != std::string::npos);
+    EXPECT_TRUE(d.data_received().find("Cookie: got_challenged=true") !=
+                std::string::npos);
   }
 }
 
 // Tests that load timing works as expected with auth and the cache.
 TEST_F(URLRequestTestHTTP, BasicAuthLoadTiming) {
   ASSERT_TRUE(test_server_.Start());
 
   // populate the cache
   {
     TestDelegate d;
@@ skipping 68 matching lines @@
   URLRequest req(test_server_.GetURL("files/redirect-to-echoall"),
                  DEFAULT_PRIORITY,
                  &d,
                  &default_context_);
   req.set_method("POST");
   req.set_upload(make_scoped_ptr(CreateSimpleUploadData(kData)));
 
   // Set headers (some of which are specific to the POST).
   HttpRequestHeaders headers;
   headers.AddHeadersFromString(
-    "Content-Type: multipart/form-data; "
-    "boundary=----WebKitFormBoundaryAADeAA+NAAWMAAwZ\r\n"
-    "Accept: text/xml,application/xml,application/xhtml+xml,text/html;q=0.9,"
-    "text/plain;q=0.8,image/png,*/*;q=0.5\r\n"
-    "Accept-Language: en-US,en\r\n"
-    "Accept-Charset: ISO-8859-1,*,utf-8\r\n"
-    "Content-Length: 11\r\n"
-    "Origin: http://localhost:1337/");
+      "Content-Type: multipart/form-data; "
+      "boundary=----WebKitFormBoundaryAADeAA+NAAWMAAwZ\r\n"
+      "Accept: text/xml,application/xml,application/xhtml+xml,text/html;q=0.9,"
+      "text/plain;q=0.8,image/png,*/*;q=0.5\r\n"
+      "Accept-Language: en-US,en\r\n"
+      "Accept-Charset: ISO-8859-1,*,utf-8\r\n"
+      "Content-Length: 11\r\n"
+      "Origin: http://localhost:1337/");
   req.SetExtraRequestHeaders(headers);
   req.Start();
   base::RunLoop().Run();
 
   std::string mime_type;
   req.GetMimeType(&mime_type);
   EXPECT_EQ("text/html", mime_type);
 
   const std::string& data = d.data_received();
 
@@ skipping 113 matching lines @@
                  DEFAULT_PRIORITY,
                  &d,
                  &default_context_);
   req.set_method("POST");
   req.set_upload(make_scoped_ptr(CreateSimpleUploadData(kData)));
   HttpRequestHeaders headers;
   headers.SetHeader(HttpRequestHeaders::kContentLength,
                     base::UintToString(arraysize(kData) - 1));
   req.SetExtraRequestHeaders(headers);
 
-  URLRequestRedirectJob* job = new URLRequestRedirectJob(
-      &req, &default_network_delegate_, test_server_.GetURL("echo"),
-      URLRequestRedirectJob::REDIRECT_302_FOUND, "Very Good Reason");
+  URLRequestRedirectJob* job =
+      new URLRequestRedirectJob(&req,
+                                &default_network_delegate_,
+                                test_server_.GetURL("echo"),
+                                URLRequestRedirectJob::REDIRECT_302_FOUND,
+                                "Very Good Reason");
   AddTestInterceptor()->set_main_intercept_job(job);
 
   req.Start();
   base::RunLoop().Run();
   EXPECT_EQ("GET", req.method());
 }
 
 TEST_F(URLRequestTestHTTP, InterceptPost307RedirectPost) {
   ASSERT_TRUE(test_server_.Start());
 
   const char kData[] = "hello world";
 
   TestDelegate d;
   URLRequest req(test_server_.GetURL("empty.html"),
                  DEFAULT_PRIORITY,
                  &d,
                  &default_context_);
   req.set_method("POST");
   req.set_upload(make_scoped_ptr(CreateSimpleUploadData(kData)));
   HttpRequestHeaders headers;
   headers.SetHeader(HttpRequestHeaders::kContentLength,
                     base::UintToString(arraysize(kData) - 1));
   req.SetExtraRequestHeaders(headers);
 
   URLRequestRedirectJob* job = new URLRequestRedirectJob(
-      &req, &default_network_delegate_, test_server_.GetURL("echo"),
+      &req,
+      &default_network_delegate_,
+      test_server_.GetURL("echo"),
       URLRequestRedirectJob::REDIRECT_307_TEMPORARY_REDIRECT,
       "Very Good Reason");
   AddTestInterceptor()->set_main_intercept_job(job);
 
   req.Start();
   base::RunLoop().Run();
   EXPECT_EQ("POST", req.method());
   EXPECT_EQ(kData, d.data_received());
 }
 
@@ skipping 155 matching lines @@
   TestURLRequestContext context(true);
   context.set_network_delegate(&network_delegate);
   context.Init();
   // We override the HttpUserAgentSettings after initialization because empty
   // entries get overridden by Init().
   context.set_http_user_agent_settings(NULL);
 
   struct {
     const char* request;
     const char* expected_response;
-  } tests[] = { { "echoheader?Accept-Language", "None" },
-                { "echoheader?Accept-Charset", "None" },
-                { "echoheader?User-Agent", "" } };
+  } tests[] = {{"echoheader?Accept-Language", "None"},
+               {"echoheader?Accept-Charset", "None"},
+               {"echoheader?User-Agent", ""}};
 
   for (size_t i = 0; i < ARRAYSIZE_UNSAFE(tests); i++) {
     TestDelegate d;
     URLRequest req(
         test_server_.GetURL(tests[i].request), DEFAULT_PRIORITY, &d, &context);
     req.Start();
     base::RunLoop().Run();
     EXPECT_EQ(tests[i].expected_response, d.data_received())
         << " Request = \"" << tests[i].request << "\"";
   }
 }
 
 // Make sure that URLRequest passes on its priority updates to
 // newly-created jobs after the first one.
 TEST_F(URLRequestTestHTTP, SetSubsequentJobPriority) {
   ASSERT_TRUE(test_server_.Start());
 
   TestDelegate d;
   URLRequest req(test_server_.GetURL("empty.html"),
                  DEFAULT_PRIORITY,
                  &d,
                  &default_context_);
   EXPECT_EQ(DEFAULT_PRIORITY, req.priority());
 
   scoped_refptr<URLRequestRedirectJob> redirect_job =
-      new URLRequestRedirectJob(
-          &req, &default_network_delegate_, test_server_.GetURL("echo"),
-          URLRequestRedirectJob::REDIRECT_302_FOUND, "Very Good Reason");
+      new URLRequestRedirectJob(&req,
+                                &default_network_delegate_,
+                                test_server_.GetURL("echo"),
+                                URLRequestRedirectJob::REDIRECT_302_FOUND,
+                                "Very Good Reason");
   AddTestInterceptor()->set_main_intercept_job(redirect_job.get());
 
   req.SetPriority(LOW);
   req.Start();
   EXPECT_TRUE(req.is_pending());
 
   scoped_refptr<URLRequestTestJob> job =
       new URLRequestTestJob(&req, &default_network_delegate_);
   AddTestInterceptor()->set_main_intercept_job(job.get());
 
@@ skipping 14 matching lines @@
   params.proxy_service = default_context_.proxy_service();
   params.ssl_config_service = default_context_.ssl_config_service();
   params.http_auth_handler_factory =
       default_context_.http_auth_handler_factory();
   params.network_delegate = &default_network_delegate_;
   params.http_server_properties = default_context_.http_server_properties();
   scoped_ptr<HttpNetworkLayer> network_layer(
       new HttpNetworkLayer(new HttpNetworkSession(params)));
   network_layer->OnSuspend();
 
-  HttpCache http_cache(network_layer.release(), default_context_.net_log(),
+  HttpCache http_cache(network_layer.release(),
+                       default_context_.net_log(),
                        HttpCache::DefaultBackend::InMemory(0));
 
   TestURLRequestContext context(true);
   context.set_http_transaction_factory(&http_cache);
   context.Init();
 
   TestDelegate d;
-  URLRequest req(GURL("http://127.0.0.1/"),
-                 DEFAULT_PRIORITY,
-                 &d,
-                 &context);
+  URLRequest req(GURL("http://127.0.0.1/"), DEFAULT_PRIORITY, &d, &context);
   req.Start();
   base::RunLoop().Run();
 
   EXPECT_TRUE(d.request_failed());
   EXPECT_EQ(URLRequestStatus::FAILED, req.status().status());
   EXPECT_EQ(ERR_NETWORK_IO_SUSPENDED, req.status().error());
 }
 
 // Check that creating a network request while entering/exiting suspend mode
 // fails as it should in the case there is no cache.  This is the only case
@@ skipping 11 matching lines @@
   params.network_delegate = &default_network_delegate_;
   params.http_server_properties = default_context_.http_server_properties();
   HttpNetworkLayer network_layer(new HttpNetworkSession(params));
   network_layer.OnSuspend();
 
   TestURLRequestContext context(true);
   context.set_http_transaction_factory(&network_layer);
   context.Init();
 
   TestDelegate d;
-  URLRequest req(GURL("http://127.0.0.1/"),
-                 DEFAULT_PRIORITY,
-                 &d,
-                 &context);
+  URLRequest req(GURL("http://127.0.0.1/"), DEFAULT_PRIORITY, &d, &context);
   req.Start();
   base::RunLoop().Run();
 
   EXPECT_TRUE(d.request_failed());
   EXPECT_EQ(URLRequestStatus::FAILED, req.status().status());
   EXPECT_EQ(ERR_NETWORK_IO_SUSPENDED, req.status().error());
 }
 
 class HTTPSRequestTest : public testing::Test {
  public:
@@ skipping 23 matching lines @@
                  &default_context_);
     r.Start();
     EXPECT_TRUE(r.is_pending());
 
     base::RunLoop().Run();
 
     EXPECT_EQ(1, d.response_started_count());
     EXPECT_FALSE(d.received_data_before_response());
     EXPECT_NE(0, d.bytes_received());
     CheckSSLInfo(r.ssl_info());
-    EXPECT_EQ(test_server.host_port_pair().host(),
-              r.GetSocketAddress().host());
-    EXPECT_EQ(test_server.host_port_pair().port(),
-              r.GetSocketAddress().port());
+    EXPECT_EQ(test_server.host_port_pair().host(), r.GetSocketAddress().host());
+    EXPECT_EQ(test_server.host_port_pair().port(), r.GetSocketAddress().port());
   }
 }
 
 TEST_F(HTTPSRequestTest, HTTPSMismatchedTest) {
   SpawnedTestServer::SSLOptions ssl_options(
       SpawnedTestServer::SSLOptions::CERT_MISMATCHED_NAME);
   SpawnedTestServer test_server(
       SpawnedTestServer::TYPE_HTTPS,
       ssl_options,
       base::FilePath(FILE_PATH_LITERAL("net/data/ssl")));
   ASSERT_TRUE(test_server.Start());
 
   bool err_allowed = true;
-  for (int i = 0; i < 2 ; i++, err_allowed = !err_allowed) {
+  for (int i = 0; i < 2; i++, err_allowed = !err_allowed) {
     TestDelegate d;
     {
       d.set_allow_certificate_errors(err_allowed);
       URLRequest r(test_server.GetURL(std::string()),
                    DEFAULT_PRIORITY,
                    &d,
                    &default_context_);
 
       r.Start();
       EXPECT_TRUE(r.is_pending());
@@ skipping 18 matching lines @@
       SpawnedTestServer::SSLOptions::CERT_EXPIRED);
   SpawnedTestServer test_server(
       SpawnedTestServer::TYPE_HTTPS,
       ssl_options,
       base::FilePath(FILE_PATH_LITERAL("net/data/ssl")));
   ASSERT_TRUE(test_server.Start());
 
   // Iterate from false to true, just so that we do the opposite of the
   // previous test in order to increase test coverage.
   bool err_allowed = false;
-  for (int i = 0; i < 2 ; i++, err_allowed = !err_allowed) {
+  for (int i = 0; i < 2; i++, err_allowed = !err_allowed) {
     TestDelegate d;
     {
       d.set_allow_certificate_errors(err_allowed);
       URLRequest r(test_server.GetURL(std::string()),
                    DEFAULT_PRIORITY,
                    &d,
                    &default_context_);
 
       r.Start();
       EXPECT_TRUE(r.is_pending());
 
       base::RunLoop().Run();
 
       EXPECT_EQ(1, d.response_started_count());
       EXPECT_FALSE(d.received_data_before_response());
       EXPECT_TRUE(d.have_certificate_errors());
       if (err_allowed) {
         EXPECT_NE(0, d.bytes_received());
         CheckSSLInfo(r.ssl_info());
       } else {
         EXPECT_EQ(0, d.bytes_received());
       }
     }
   }
 }
 
 // Tests TLSv1.1 -> TLSv1 fallback. Verifies that we don't fall back more
 // than necessary.
 TEST_F(HTTPSRequestTest, TLSv1Fallback) {
-  // The OpenSSL library in use may not support TLS 1.1.
+// The OpenSSL library in use may not support TLS 1.1.
 #if !defined(USE_OPENSSL)
   EXPECT_GT(kDefaultSSLVersionMax, SSL_PROTOCOL_VERSION_TLS1);
 #endif
   if (kDefaultSSLVersionMax <= SSL_PROTOCOL_VERSION_TLS1)
     return;
 
   SpawnedTestServer::SSLOptions ssl_options(
       SpawnedTestServer::SSLOptions::CERT_OK);
   ssl_options.tls_intolerant =
       SpawnedTestServer::SSLOptions::TLS_INTOLERANT_TLS1_1;
@@ skipping 123 matching lines @@
   // MockHostResolver in order to direct www.google.com to the testserver.
   // By default, MockHostResolver maps all hosts to 127.0.0.1.
 
   MockHostResolver host_resolver;
   TestNetworkDelegate network_delegate;  // Must outlive URLRequest.
   TestURLRequestContext context(true);
   context.set_network_delegate(&network_delegate);
   context.set_host_resolver(&host_resolver);
   TransportSecurityState transport_security_state;
   TransportSecurityState::DomainState domain_state;
-  EXPECT_TRUE(transport_security_state.GetDomainState("www.google.com", true,
-                                                      &domain_state));
+  EXPECT_TRUE(transport_security_state.GetDomainState(
+      "www.google.com", true, &domain_state));
   context.set_transport_security_state(&transport_security_state);
   context.Init();
 
   TestDelegate d;
   URLRequest r(GURL(base::StringPrintf("https://www.google.com:%d",
                                        test_server.host_port_pair().port())),
                DEFAULT_PRIORITY,
                &d,
                &context);
 
   r.Start();
   EXPECT_TRUE(r.is_pending());
 
   base::RunLoop().Run();
 
   EXPECT_EQ(1, d.response_started_count());
   EXPECT_FALSE(d.received_data_before_response());
   EXPECT_TRUE(d.have_certificate_errors());
   EXPECT_TRUE(d.certificate_errors_are_fatal());
 
   // Get a fresh copy of the state, and check that it hasn't been updated.
   TransportSecurityState::DomainState new_domain_state;
-  EXPECT_TRUE(transport_security_state.GetDomainState("www.google.com", true,
-                                                      &new_domain_state));
+  EXPECT_TRUE(transport_security_state.GetDomainState(
+      "www.google.com", true, &new_domain_state));
   EXPECT_EQ(new_domain_state.upgrade_mode, domain_state.upgrade_mode);
   EXPECT_EQ(new_domain_state.sts_include_subdomains,
             domain_state.sts_include_subdomains);
   EXPECT_EQ(new_domain_state.pkp_include_subdomains,
             domain_state.pkp_include_subdomains);
   EXPECT_TRUE(FingerprintsEqual(new_domain_state.static_spki_hashes,
                                 domain_state.static_spki_hashes));
   EXPECT_TRUE(FingerprintsEqual(new_domain_state.dynamic_spki_hashes,
                                 domain_state.dynamic_spki_hashes));
   EXPECT_TRUE(FingerprintsEqual(new_domain_state.bad_static_spki_hashes,
                                 domain_state.bad_static_spki_hashes));
 }
 
 // Make sure HSTS preserves a POST request's method and body.
 TEST_F(HTTPSRequestTest, HSTSPreservesPosts) {
   static const char kData[] = "hello world";
 
   SpawnedTestServer::SSLOptions ssl_options(
       SpawnedTestServer::SSLOptions::CERT_OK);
   SpawnedTestServer test_server(
       SpawnedTestServer::TYPE_HTTPS,
       ssl_options,
       base::FilePath(FILE_PATH_LITERAL("net/data/ssl")));
   ASSERT_TRUE(test_server.Start());
 
-
   // Per spec, TransportSecurityState expects a domain name, rather than an IP
   // address, so a MockHostResolver is needed to redirect www.somewhere.com to
   // the SpawnedTestServer.  By default, MockHostResolver maps all hosts
   // to 127.0.0.1.
   MockHostResolver host_resolver;
 
   // Force https for www.somewhere.com.
   TransportSecurityState transport_security_state;
   base::Time expiry = base::Time::Now() + base::TimeDelta::FromDays(1000);
   bool include_subdomains = false;
-  transport_security_state.AddHSTS("www.somewhere.com", expiry,
-                                   include_subdomains);
+  transport_security_state.AddHSTS(
+      "www.somewhere.com", expiry, include_subdomains);
 
   TestNetworkDelegate network_delegate;  // Must outlive URLRequest.
 
   TestURLRequestContext context(true);
   context.set_host_resolver(&host_resolver);
   context.set_transport_security_state(&transport_security_state);
   context.set_network_delegate(&network_delegate);
   context.Init();
 
   TestDelegate d;
@@ skipping 47 matching lines @@
   EXPECT_NE(0, d.bytes_received());
   EXPECT_EQ(static_cast<int>(SSL_CONNECTION_VERSION_SSL3),
             SSLConnectionStatusToVersion(r.ssl_info().connection_status));
   EXPECT_TRUE(r.ssl_info().connection_status & SSL_CONNECTION_VERSION_FALLBACK);
 }
 
 namespace {
 
 class SSLClientAuthTestDelegate : public TestDelegate {
  public:
-  SSLClientAuthTestDelegate() : on_certificate_requested_count_(0) {
-  }
+  SSLClientAuthTestDelegate() : on_certificate_requested_count_(0) {}
   virtual void OnCertificateRequested(
       URLRequest* request,
       SSLCertRequestInfo* cert_request_info) OVERRIDE {
     on_certificate_requested_count_++;
     base::MessageLoop::current()->Quit();
   }
   int on_certificate_requested_count() {
     return on_certificate_requested_count_;
   }
+
  private:
   int on_certificate_requested_count_;
 };
 
 }  // namespace
 
 // TODO(davidben): Test the rest of the code. Specifically,
 // - Filtering which certificates to select.
 // - Sending a certificate back.
 // - Getting a certificate request in an SSL renegotiation sending the
@@ skipping 57 matching lines @@
                  &default_context_);
 
     r.Start();
     EXPECT_TRUE(r.is_pending());
 
     base::RunLoop().Run();
 
     EXPECT_EQ(1, d.response_started_count());
   }
 
-  reinterpret_cast<HttpCache*>(default_context_.http_transaction_factory())->
-    CloseAllConnections();
+  reinterpret_cast<HttpCache*>(default_context_.http_transaction_factory())
+      ->CloseAllConnections();
 
   {
     TestDelegate d;
     URLRequest r(test_server.GetURL("ssl-session-cache"),
                  DEFAULT_PRIORITY,
                  &d,
                  &default_context_);
 
     r.Start();
     EXPECT_TRUE(r.is_pending());
@@ skipping 64 matching lines @@
   params.cert_verifier = default_context_.cert_verifier();
   params.transport_security_state = default_context_.transport_security_state();
   params.proxy_service = default_context_.proxy_service();
   params.ssl_config_service = default_context_.ssl_config_service();
   params.http_auth_handler_factory =
       default_context_.http_auth_handler_factory();
   params.network_delegate = &default_network_delegate_;
   params.http_server_properties = default_context_.http_server_properties();
   params.ssl_session_cache_shard = "alternate";
 
-  scoped_ptr<net::HttpCache> cache(new net::HttpCache(
-      new net::HttpNetworkSession(params),
-      net::HttpCache::DefaultBackend::InMemory(0)));
+  scoped_ptr<net::HttpCache> cache(
+      new net::HttpCache(new net::HttpNetworkSession(params),
+                         net::HttpCache::DefaultBackend::InMemory(0)));
 
   default_context_.set_http_transaction_factory(cache.get());
 
   {
     TestDelegate d;
     URLRequest r(test_server.GetURL("ssl-session-cache"),
                  DEFAULT_PRIORITY,
                  &d,
                  &default_context_);
 
@@ skipping 69 matching lines @@
                  &default_context_);
 
     r.Start();
     EXPECT_TRUE(r.is_pending());
 
     base::RunLoop().Run();
 
     EXPECT_EQ(1, d.response_started_count());
   }
 
-  reinterpret_cast<HttpCache*>(default_context_.http_transaction_factory())->
-    CloseAllConnections();
+  reinterpret_cast<HttpCache*>(default_context_.http_transaction_factory())
+      ->CloseAllConnections();
 
   // Now change the certificate to be acceptable (so that the response is
   // loaded), and ensure that no session id is presented to the peer.
   cert_verifier_.set_default_result(net::OK);
   {
     TestDelegate d;
     URLRequest r(test_server.GetURL("ssl-session-cache"),
                  DEFAULT_PRIORITY,
                  &d,
                  &default_context_);
@@ skipping 59 matching lines @@
   virtual ~TestSSLConfigService() {}
 
  private:
   const bool ev_enabled_;
   const bool online_rev_checking_;
   const bool rev_checking_required_local_anchors_;
 };
 
 // This the fingerprint of the "Testing CA" certificate used by the testserver.
 // See net/data/ssl/certificates/ocsp-test-root.pem.
-static const SHA1HashValue kOCSPTestCertFingerprint =
-  { { 0xf1, 0xad, 0xf6, 0xce, 0x42, 0xac, 0xe7, 0xb4, 0xf4, 0x24,
-      0xdb, 0x1a, 0xf7, 0xa0, 0x9f, 0x09, 0xa1, 0xea, 0xf1, 0x5c } };
+static const SHA1HashValue kOCSPTestCertFingerprint = {
+    {0xf1, 0xad, 0xf6, 0xce, 0x42, 0xac, 0xe7, 0xb4, 0xf4, 0x24, 0xdb, 0x1a,
+     0xf7, 0xa0, 0x9f, 0x09, 0xa1, 0xea, 0xf1, 0x5c}};
 
 // This is the SHA256, SPKI hash of the "Testing CA" certificate used by the
 // testserver.
-static const SHA256HashValue kOCSPTestCertSPKI = { {
-  0xee, 0xe6, 0x51, 0x2d, 0x4c, 0xfa, 0xf7, 0x3e,
-  0x6c, 0xd8, 0xca, 0x67, 0xed, 0xb5, 0x5d, 0x49,
-  0x76, 0xe1, 0x52, 0xa7, 0x6e, 0x0e, 0xa0, 0x74,
-  0x09, 0x75, 0xe6, 0x23, 0x24, 0xbd, 0x1b, 0x28,
-} };
+static const SHA256HashValue kOCSPTestCertSPKI = {{
+    0xee, 0xe6, 0x51, 0x2d, 0x4c, 0xfa, 0xf7, 0x3e, 0x6c, 0xd8, 0xca, 0x67,
+    0xed, 0xb5, 0x5d, 0x49, 0x76, 0xe1, 0x52, 0xa7, 0x6e, 0x0e, 0xa0, 0x74,
+    0x09, 0x75, 0xe6, 0x23, 0x24, 0xbd, 0x1b, 0x28,
+}};
 
 // This is the policy OID contained in the certificates that testserver
 // generates.
 static const char kOCSPTestCertPolicy[] = "1.3.6.1.4.1.11129.2.4.1";
 
 class HTTPSOCSPTest : public HTTPSRequestTest {
  public:
   HTTPSOCSPTest()
       : context_(true),
-        ev_test_policy_(
-            new ScopedTestEVPolicy(EVRootCAMetadata::GetInstance(),
-                                   kOCSPTestCertFingerprint,
-                                   kOCSPTestCertPolicy)) {
-  }
+        ev_test_policy_(new ScopedTestEVPolicy(EVRootCAMetadata::GetInstance(),
+                                               kOCSPTestCertFingerprint,
+                                               kOCSPTestCertPolicy)) {}
 
   virtual void SetUp() OVERRIDE {
     SetupContext(&context_);
     context_.Init();
 
     scoped_refptr<net::X509Certificate> root_cert =
         ImportCertFromFile(GetTestCertsDirectory(), "ocsp-test-root.pem");
     CHECK_NE(static_cast<X509Certificate*>(NULL), root_cert);
     test_root_.reset(new ScopedTestRoot(root_cert.get()));
 
@@ skipping 74 matching lines @@
 }
 
 // SystemUsesChromiumEVMetadata returns true iff the current operating system
 // uses Chromium's EV metadata (i.e. EVRootCAMetadata). If it does not, then
 // several tests are effected because our testing EV certificate won't be
 // recognised as EV.
 static bool SystemUsesChromiumEVMetadata() {
 #if defined(USE_OPENSSL_CERTS) && !defined(OS_ANDROID)
   // http://crbug.com/117478 - OpenSSL does not support EV validation.
   return false;
-#elif (defined(OS_MACOSX) && !defined(OS_IOS)) || defined(OS_ANDROID)
+#elif(defined(OS_MACOSX) && !defined(OS_IOS)) || defined(OS_ANDROID)
   // On OS X and Android, we use the system to tell us whether a certificate is
   // EV or not and the system won't recognise our testing root.
   return false;
 #else
   return true;
 #endif
 }
 
 static bool SystemSupportsOCSP() {
 #if defined(USE_OPENSSL)
@@ skipping 76 matching lines @@
  protected:
   virtual void SetupContext(URLRequestContext* context) OVERRIDE {
     context->set_ssl_config_service(
         new TestSSLConfigService(false /* check for EV */,
                                  false /* online revocation checking */,
                                  true /* require rev. checking for local
                                          anchors */));
   }
 };
 
-
 TEST_F(HTTPSHardFailTest, FailsOnOCSPInvalid) {
   if (!SystemSupportsOCSP()) {
     LOG(WARNING) << "Skipping test because system doesn't support OCSP";
     return;
   }
 
   if (!SystemSupportsHardFailRevocationChecking()) {
     LOG(WARNING) << "Skipping test because system doesn't support hard fail "
                  << "revocation checking";
     return;
   }
 
   SpawnedTestServer::SSLOptions ssl_options(
       SpawnedTestServer::SSLOptions::CERT_AUTO);
   ssl_options.ocsp_status = SpawnedTestServer::SSLOptions::OCSP_INVALID;
 
   CertStatus cert_status;
   DoConnection(ssl_options, &cert_status);
 
-  EXPECT_EQ(CERT_STATUS_REVOKED,
-            cert_status & CERT_STATUS_REVOKED);
+  EXPECT_EQ(CERT_STATUS_REVOKED, cert_status & CERT_STATUS_REVOKED);
 
   // Without a positive OCSP response, we shouldn't show the EV status.
   EXPECT_TRUE(cert_status & CERT_STATUS_REV_CHECKING_ENABLED);
 }
 
 class HTTPSEVCRLSetTest : public HTTPSOCSPTest {
  protected:
   virtual void SetupContext(URLRequestContext* context) OVERRIDE {
     context->set_ssl_config_service(
         new TestSSLConfigService(true /* check for EV */,
@@ skipping 32 matching lines @@
   }
 
   SpawnedTestServer::SSLOptions ssl_options(
       SpawnedTestServer::SSLOptions::CERT_AUTO);
   ssl_options.ocsp_status = SpawnedTestServer::SSLOptions::OCSP_REVOKED;
   SSLConfigService::SetCRLSet(scoped_refptr<CRLSet>());
 
   CertStatus cert_status;
   DoConnection(ssl_options, &cert_status);
 
-  // Currently only works for Windows. When using NSS or OS X, it's not
-  // possible to determine whether the check failed because of actual
-  // revocation or because there was an OCSP failure.
+// Currently only works for Windows. When using NSS or OS X, it's not
+// possible to determine whether the check failed because of actual
+// revocation or because there was an OCSP failure.
 #if defined(OS_WIN)
   EXPECT_EQ(CERT_STATUS_REVOKED, cert_status & CERT_STATUS_ALL_ERRORS);
 #else
   EXPECT_EQ(0u, cert_status & CERT_STATUS_ALL_ERRORS);
 #endif
 
   EXPECT_FALSE(cert_status & CERT_STATUS_IS_EV);
   EXPECT_EQ(SystemUsesChromiumEVMetadata(),
             static_cast<bool>(cert_status & CERT_STATUS_REV_CHECKING_ENABLED));
 }
@@ skipping 46 matching lines @@
 TEST_F(HTTPSEVCRLSetTest, FreshCRLSetCovered) {
   if (!SystemSupportsOCSP()) {
     LOG(WARNING) << "Skipping test because system doesn't support OCSP";
     return;
   }
 
   SpawnedTestServer::SSLOptions ssl_options(
       SpawnedTestServer::SSLOptions::CERT_AUTO);
   ssl_options.ocsp_status = SpawnedTestServer::SSLOptions::OCSP_INVALID;
   SSLConfigService::SetCRLSet(
-      scoped_refptr<CRLSet>(CRLSet::ForTesting(
-          false, &kOCSPTestCertSPKI, "")));
+      scoped_refptr<CRLSet>(CRLSet::ForTesting(false, &kOCSPTestCertSPKI, "")));
 
   CertStatus cert_status;
   DoConnection(ssl_options, &cert_status);
 
   // With a fresh CRLSet that covers the issuing certificate, we shouldn't do a
   // revocation check for EV.
   EXPECT_EQ(0u, cert_status & CERT_STATUS_ALL_ERRORS);
   EXPECT_EQ(SystemUsesChromiumEVMetadata(),
             static_cast<bool>(cert_status & CERT_STATUS_IS_EV));
   EXPECT_FALSE(
@@ skipping 85 matching lines @@
 TEST_F(HTTPSCRLSetTest, CRLSetRevoked) {
 #if defined(USE_OPENSSL)
   LOG(WARNING) << "Skipping test because system doesn't support CRLSets";
   return;
 #endif
 
   SpawnedTestServer::SSLOptions ssl_options(
       SpawnedTestServer::SSLOptions::CERT_AUTO);
   ssl_options.ocsp_status = SpawnedTestServer::SSLOptions::OCSP_OK;
   ssl_options.cert_serial = 10;
-  SSLConfigService::SetCRLSet(
-      scoped_refptr<CRLSet>(CRLSet::ForTesting(
-          false, &kOCSPTestCertSPKI, "\x0a")));
+  SSLConfigService::SetCRLSet(scoped_refptr<CRLSet>(
+      CRLSet::ForTesting(false, &kOCSPTestCertSPKI, "\x0a")));
 
   CertStatus cert_status = 0;
   DoConnection(ssl_options, &cert_status);
 
   // If the certificate is recorded as revoked in the CRLSet, that should be
   // reflected without online revocation checking.
   EXPECT_EQ(CERT_STATUS_REVOKED, cert_status & CERT_STATUS_ALL_ERRORS);
   EXPECT_FALSE(cert_status & CERT_STATUS_IS_EV);
   EXPECT_FALSE(
       static_cast<bool>(cert_status & CERT_STATUS_REV_CHECKING_ENABLED));
 }
 #endif  // !defined(OS_IOS)
 
 #if !defined(DISABLE_FTP_SUPPORT)
 class URLRequestTestFTP : public URLRequestTest {
  public:
   URLRequestTestFTP()
-      : test_server_(SpawnedTestServer::TYPE_FTP, SpawnedTestServer::kLocalhost,
-                     base::FilePath()) {
-  }
+      : test_server_(SpawnedTestServer::TYPE_FTP,
+                     SpawnedTestServer::kLocalhost,
+                     base::FilePath()) {}
 
  protected:
   SpawnedTestServer test_server_;
 };
 
 // Make sure an FTP request using an unsafe ports fails.
 TEST_F(URLRequestTestFTP, UnsafePort) {
   ASSERT_TRUE(test_server_.Start());
 
   URLRequestJobFactoryImpl job_factory;
   FtpNetworkLayer ftp_transaction_factory(default_context_.host_resolver());
 
   GURL url("ftp://127.0.0.1:7");
   job_factory.SetProtocolHandler(
-      "ftp",
-      new FtpProtocolHandler(&ftp_transaction_factory));
+      "ftp", new FtpProtocolHandler(&ftp_transaction_factory));
   default_context_.set_job_factory(&job_factory);
 
   TestDelegate d;
   {
     URLRequest r(url, DEFAULT_PRIORITY, &d, &default_context_);
     r.Start();
     EXPECT_TRUE(r.is_pending());
 
     base::RunLoop().Run();
 
@@ skipping 322 matching lines @@
 
     EXPECT_FALSE(r.is_pending());
     EXPECT_EQ(1, d->response_started_count());
     EXPECT_FALSE(d->received_data_before_response());
     EXPECT_EQ(d->bytes_received(), static_cast<int>(file_size));
   }
 }
 #endif  // !defined(DISABLE_FTP_SUPPORT)
 
 }  // namespace net