Clang format slam.

net/url_request/url_request_test_util.cc

 // Copyright (c) 2012 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "net/url_request/url_request_test_util.h"
 
 #include "base/compiler_specific.h"
 #include "base/logging.h"
 #include "base/message_loop/message_loop.h"
 #include "base/threading/thread.h"
@@ skipping 69 matching lines @@
     context_storage_.set_ssl_config_service(new SSLConfigServiceDefaults);
   if (!http_auth_handler_factory()) {
     context_storage_.set_http_auth_handler_factory(
         HttpAuthHandlerFactory::CreateDefault(host_resolver()));
   }
   if (!http_server_properties()) {
     context_storage_.set_http_server_properties(
         scoped_ptr<HttpServerProperties>(new HttpServerPropertiesImpl()));
   }
   if (!transport_security_state()) {
-    context_storage_.set_transport_security_state(
-        new TransportSecurityState());
+    context_storage_.set_transport_security_state(new TransportSecurityState());
   }
   if (http_transaction_factory()) {
     // Make sure we haven't been passed an object we're not going to use.
     EXPECT_FALSE(client_socket_factory_);
   } else {
     HttpNetworkSession::Params params;
     params.client_socket_factory = client_socket_factory();
     params.host_resolver = host_resolver();
     params.cert_verifier = cert_verifier();
     params.transport_security_state = transport_security_state();
     params.proxy_service = proxy_service();
     params.ssl_config_service = ssl_config_service();
     params.http_auth_handler_factory = http_auth_handler_factory();
     params.network_delegate = network_delegate();
     params.http_server_properties = http_server_properties();
     params.net_log = net_log();
-    context_storage_.set_http_transaction_factory(new HttpCache(
-        new HttpNetworkSession(params),
-        HttpCache::DefaultBackend::InMemory(0)));
+    context_storage_.set_http_transaction_factory(
+        new HttpCache(new HttpNetworkSession(params),
+                      HttpCache::DefaultBackend::InMemory(0)));
   }
   // In-memory cookie store.
   if (!cookie_store())
     context_storage_.set_cookie_store(new CookieMonster(NULL, NULL));
   // In-memory origin bound cert service.
   if (!server_bound_cert_service()) {
     context_storage_.set_server_bound_cert_service(
-        new ServerBoundCertService(
-            new DefaultServerBoundCertStore(NULL),
-            base::WorkerPool::GetTaskRunner(true)));
+        new ServerBoundCertService(new DefaultServerBoundCertStore(NULL),
+                                   base::WorkerPool::GetTaskRunner(true)));
   }
   if (!http_user_agent_settings()) {
     context_storage_.set_http_user_agent_settings(
         new StaticHttpUserAgentSettings("en-us,fr", std::string()));
   }
   if (!job_factory())
     context_storage_.set_job_factory(new URLRequestJobFactoryImpl);
 }
 
 TestURLRequest::TestURLRequest(const GURL& url,
                                RequestPriority priority,
                                Delegate* delegate,
                                TestURLRequestContext* context)
-    : URLRequest(url, priority, delegate, context) {}
+    : URLRequest(url, priority, delegate, context) {
+}
 
 TestURLRequest::~TestURLRequest() {
 }
 
 TestURLRequestContextGetter::TestURLRequestContextGetter(
     const scoped_refptr<base::SingleThreadTaskRunner>& network_task_runner)
     : network_task_runner_(network_task_runner) {
   DCHECK(network_task_runner_.get());
 }
 
 TestURLRequestContextGetter::TestURLRequestContextGetter(
     const scoped_refptr<base::SingleThreadTaskRunner>& network_task_runner,
     scoped_ptr<TestURLRequestContext> context)
     : network_task_runner_(network_task_runner), context_(context.Pass()) {
   DCHECK(network_task_runner_.get());
 }
 
-TestURLRequestContextGetter::~TestURLRequestContextGetter() {}
+TestURLRequestContextGetter::~TestURLRequestContextGetter() {
+}
 
 TestURLRequestContext* TestURLRequestContextGetter::GetURLRequestContext() {
   if (!context_.get())
     context_.reset(new TestURLRequestContext);
   return context_.get();
 }
 
 scoped_refptr<base::SingleThreadTaskRunner>
 TestURLRequestContextGetter::GetNetworkTaskRunner() const {
   return network_task_runner_;
@@ skipping 14 matching lines @@
       received_before_network_start_count_(0),
       received_data_before_response_(false),
       request_failed_(false),
       have_certificate_errors_(false),
       certificate_errors_are_fatal_(false),
       auth_required_(false),
       have_full_request_headers_(false),
       buf_(new IOBuffer(kBufferSize)) {
 }
 
-TestDelegate::~TestDelegate() {}
+TestDelegate::~TestDelegate() {
+}
 
 void TestDelegate::ClearFullRequestHeaders() {
   full_request_headers_.Clear();
   have_full_request_headers_ = false;
 }
 
 void TestDelegate::OnReceivedRedirect(URLRequest* request,
                                       const GURL& new_url,
                                       bool* defer_redirect) {
   EXPECT_TRUE(request->is_redirecting());
@@ skipping 125 matching lines @@
       blocked_set_cookie_count_(0),
       set_cookie_count_(0),
       has_load_timing_info_before_redirect_(false),
       has_load_timing_info_before_auth_(false),
       can_access_files_(true),
       can_throttle_requests_(true) {
 }
 
 TestNetworkDelegate::~TestNetworkDelegate() {
   for (std::map<int, int>::iterator i = next_states_.begin();
-       i != next_states_.end(); ++i) {
+       i != next_states_.end();
+       ++i) {
     event_order_[i->first] += "~TestNetworkDelegate\n";
     EXPECT_TRUE(i->second & kStageDestruction) << event_order_[i->first];
   }
 }
 
 bool TestNetworkDelegate::GetLoadTimingInfoBeforeRedirect(
     LoadTimingInfo* load_timing_info_before_redirect) const {
   *load_timing_info_before_redirect = load_timing_info_before_redirect_;
   return has_load_timing_info_before_redirect_;
 }
 
 bool TestNetworkDelegate::GetLoadTimingInfoBeforeAuth(
     LoadTimingInfo* load_timing_info_before_auth) const {
   *load_timing_info_before_auth = load_timing_info_before_auth_;
   return has_load_timing_info_before_auth_;
 }
 
 void TestNetworkDelegate::InitRequestStatesIfNew(int request_id) {
   if (next_states_.find(request_id) == next_states_.end()) {
     // TODO(davidben): Although the URLRequest documentation does not allow
     // calling Cancel() before Start(), the ResourceLoader does so. URLRequest's
     // destructor also calls Cancel. Either officially support this or fix the
     // ResourceLoader code.
     next_states_[request_id] = kStageBeforeURLRequest | kStageCompletedError;
     event_order_[request_id] = "";
   }
 }
 
-int TestNetworkDelegate::OnBeforeURLRequest(
-    URLRequest* request,
-    const CompletionCallback& callback,
-    GURL* new_url ) {
+int TestNetworkDelegate::OnBeforeURLRequest(URLRequest* request,
+                                            const CompletionCallback& callback,
+                                            GURL* new_url) {
   int req_id = request->identifier();
   InitRequestStatesIfNew(req_id);
   event_order_[req_id] += "OnBeforeURLRequest\n";
-  EXPECT_TRUE(next_states_[req_id] & kStageBeforeURLRequest) <<
-      event_order_[req_id];
+  EXPECT_TRUE(next_states_[req_id] & kStageBeforeURLRequest)
+      << event_order_[req_id];
   next_states_[req_id] =
       kStageBeforeSendHeaders |
       kStageResponseStarted |  // data: URLs do not trigger sending headers
-      kStageBeforeRedirect |  // a delegate can trigger a redirection
-      kStageCompletedError |  // request canceled by delegate
-      kStageAuthRequired;  // Auth can come next for FTP requests
+      kStageBeforeRedirect |   // a delegate can trigger a redirection
+      kStageCompletedError |   // request canceled by delegate
+      kStageAuthRequired;      // Auth can come next for FTP requests
   created_requests_++;
   return OK;
 }
 
-int TestNetworkDelegate::OnBeforeSendHeaders(
-    URLRequest* request,
-    const CompletionCallback& callback,
-    HttpRequestHeaders* headers) {
+int TestNetworkDelegate::OnBeforeSendHeaders(URLRequest* request,
+                                             const CompletionCallback& callback,
+                                             HttpRequestHeaders* headers) {
   int req_id = request->identifier();
   InitRequestStatesIfNew(req_id);
   event_order_[req_id] += "OnBeforeSendHeaders\n";
-  EXPECT_TRUE(next_states_[req_id] & kStageBeforeSendHeaders) <<
-      event_order_[req_id];
+  EXPECT_TRUE(next_states_[req_id] & kStageBeforeSendHeaders)
+      << event_order_[req_id];
   next_states_[req_id] =
-      kStageSendHeaders |
-      kStageCompletedError;  // request canceled by delegate
+      kStageSendHeaders | kStageCompletedError;  // request canceled by delegate
 
   return OK;
 }
 
-void TestNetworkDelegate::OnSendHeaders(
-    URLRequest* request,
-    const HttpRequestHeaders& headers) {
+void TestNetworkDelegate::OnSendHeaders(URLRequest* request,
+                                        const HttpRequestHeaders& headers) {
   int req_id = request->identifier();
   InitRequestStatesIfNew(req_id);
   event_order_[req_id] += "OnSendHeaders\n";
-  EXPECT_TRUE(next_states_[req_id] & kStageSendHeaders) <<
-      event_order_[req_id];
-  next_states_[req_id] =
-      kStageHeadersReceived |
-      kStageCompletedError;
+  EXPECT_TRUE(next_states_[req_id] & kStageSendHeaders) << event_order_[req_id];
+  next_states_[req_id] = kStageHeadersReceived | kStageCompletedError;
 }
 
 int TestNetworkDelegate::OnHeadersReceived(
     URLRequest* request,
     const CompletionCallback& callback,
     const HttpResponseHeaders* original_response_headers,
     scoped_refptr<HttpResponseHeaders>* override_response_headers,
     GURL* allowed_unsafe_redirect_url) {
   int req_id = request->identifier();
   event_order_[req_id] += "OnHeadersReceived\n";
   InitRequestStatesIfNew(req_id);
-  EXPECT_TRUE(next_states_[req_id] & kStageHeadersReceived) <<
-      event_order_[req_id];
-  next_states_[req_id] =
-      kStageBeforeRedirect |
-      kStageResponseStarted |
-      kStageAuthRequired |
-      kStageCompletedError;  // e.g. proxy resolution problem
+  EXPECT_TRUE(next_states_[req_id] & kStageHeadersReceived)
+      << event_order_[req_id];
+  next_states_[req_id] = kStageBeforeRedirect | kStageResponseStarted |
+                         kStageAuthRequired |
+                         kStageCompletedError;  // e.g. proxy resolution problem
 
   // Basic authentication sends a second request from the URLRequestHttpJob
   // layer before the URLRequest reports that a response has started.
   next_states_[req_id] |= kStageBeforeSendHeaders;
 
   if (!redirect_on_headers_received_url_.is_empty()) {
     *override_response_headers =
         new net::HttpResponseHeaders(original_response_headers->raw_headers());
     (*override_response_headers)->ReplaceStatusLine("HTTP/1.1 302 Found");
     (*override_response_headers)->RemoveHeader("Location");
-    (*override_response_headers)->AddHeader(
-        "Location: " + redirect_on_headers_received_url_.spec());
+    (*override_response_headers)
+        ->AddHeader("Location: " + redirect_on_headers_received_url_.spec());
 
     redirect_on_headers_received_url_ = GURL();
 
     if (!allowed_unsafe_redirect_url_.is_empty())
       *allowed_unsafe_redirect_url = allowed_unsafe_redirect_url_;
   }
 
   return OK;
 }
 
 void TestNetworkDelegate::OnBeforeRedirect(URLRequest* request,
                                            const GURL& new_location) {
   load_timing_info_before_redirect_ = LoadTimingInfo();
   request->GetLoadTimingInfo(&load_timing_info_before_redirect_);
   has_load_timing_info_before_redirect_ = true;
   EXPECT_FALSE(load_timing_info_before_redirect_.request_start_time.is_null());
   EXPECT_FALSE(load_timing_info_before_redirect_.request_start.is_null());
 
   int req_id = request->identifier();
   InitRequestStatesIfNew(req_id);
   event_order_[req_id] += "OnBeforeRedirect\n";
-  EXPECT_TRUE(next_states_[req_id] & kStageBeforeRedirect) <<
-      event_order_[req_id];
+  EXPECT_TRUE(next_states_[req_id] & kStageBeforeRedirect)
+      << event_order_[req_id];
   next_states_[req_id] =
-      kStageBeforeURLRequest |  // HTTP redirects trigger this.
+      kStageBeforeURLRequest |   // HTTP redirects trigger this.
       kStageBeforeSendHeaders |  // Redirects from the network delegate do not
                                  // trigger onBeforeURLRequest.
       kStageCompletedError;
 
   // A redirect can lead to a file or a data URL. In this case, we do not send
   // headers.
   next_states_[req_id] |= kStageResponseStarted;
 }
 
 void TestNetworkDelegate::OnResponseStarted(URLRequest* request) {
   LoadTimingInfo load_timing_info;
   request->GetLoadTimingInfo(&load_timing_info);
   EXPECT_FALSE(load_timing_info.request_start_time.is_null());
   EXPECT_FALSE(load_timing_info.request_start.is_null());
 
   int req_id = request->identifier();
   InitRequestStatesIfNew(req_id);
   event_order_[req_id] += "OnResponseStarted\n";
-  EXPECT_TRUE(next_states_[req_id] & kStageResponseStarted) <<
-      event_order_[req_id];
+  EXPECT_TRUE(next_states_[req_id] & kStageResponseStarted)
+      << event_order_[req_id];
   next_states_[req_id] = kStageCompletedSuccess | kStageCompletedError;
   if (request->status().status() == URLRequestStatus::FAILED) {
     error_count_++;
     last_error_ = request->status().error();
   }
 }
 
 void TestNetworkDelegate::OnRawBytesRead(const URLRequest& request,
                                          int bytes_read) {
 }
 
 void TestNetworkDelegate::OnCompleted(URLRequest* request, bool started) {
   int req_id = request->identifier();
   InitRequestStatesIfNew(req_id);
   event_order_[req_id] += "OnCompleted\n";
   // Expect "Success -> (next_states_ & kStageCompletedSuccess)"
   // is logically identical to
   // Expect "!(Success) || (next_states_ & kStageCompletedSuccess)"
   EXPECT_TRUE(!request->status().is_success() ||
-              (next_states_[req_id] & kStageCompletedSuccess)) <<
-      event_order_[req_id];
+              (next_states_[req_id] & kStageCompletedSuccess))
+      << event_order_[req_id];
   EXPECT_TRUE(request->status().is_success() ||
-              (next_states_[req_id] & kStageCompletedError)) <<
-      event_order_[req_id];
+              (next_states_[req_id] & kStageCompletedError))
+      << event_order_[req_id];
   next_states_[req_id] = kStageURLRequestDestroyed;
   completed_requests_++;
   if (request->status().status() == URLRequestStatus::FAILED) {
     error_count_++;
     last_error_ = request->status().error();
   } else if (request->status().status() == URLRequestStatus::CANCELED) {
     canceled_requests_++;
   } else {
     DCHECK_EQ(URLRequestStatus::SUCCESS, request->status().status());
   }
 }
 
 void TestNetworkDelegate::OnURLRequestDestroyed(URLRequest* request) {
   int req_id = request->identifier();
   InitRequestStatesIfNew(req_id);
   event_order_[req_id] += "OnURLRequestDestroyed\n";
-  EXPECT_TRUE(next_states_[req_id] & kStageURLRequestDestroyed) <<
-      event_order_[req_id];
+  EXPECT_TRUE(next_states_[req_id] & kStageURLRequestDestroyed)
+      << event_order_[req_id];
   next_states_[req_id] = kStageDestruction;
   destroyed_requests_++;
 }
 
 void TestNetworkDelegate::OnPACScriptError(int line_number,
                                            const base::string16& error) {
 }
 
 NetworkDelegate::AuthRequiredResponse TestNetworkDelegate::OnAuthRequired(
     URLRequest* request,
     const AuthChallengeInfo& auth_info,
     const AuthCallback& callback,
     AuthCredentials* credentials) {
   load_timing_info_before_auth_ = LoadTimingInfo();
   request->GetLoadTimingInfo(&load_timing_info_before_auth_);
   has_load_timing_info_before_auth_ = true;
   EXPECT_FALSE(load_timing_info_before_auth_.request_start_time.is_null());
   EXPECT_FALSE(load_timing_info_before_auth_.request_start.is_null());
 
   int req_id = request->identifier();
   InitRequestStatesIfNew(req_id);
   event_order_[req_id] += "OnAuthRequired\n";
-  EXPECT_TRUE(next_states_[req_id] & kStageAuthRequired) <<
-      event_order_[req_id];
-  next_states_[req_id] = kStageBeforeSendHeaders |
+  EXPECT_TRUE(next_states_[req_id] & kStageAuthRequired)
+      << event_order_[req_id];
+  next_states_[req_id] =
+      kStageBeforeSendHeaders |
       kStageAuthRequired |  // For example, proxy auth followed by server auth.
       kStageHeadersReceived |  // Request canceled by delegate simulates empty
                                // response.
       kStageResponseStarted |  // data: URLs do not trigger sending headers
       kStageBeforeRedirect |   // a delegate can trigger a redirection
       kStageCompletedError;    // request cancelled before callback
   return NetworkDelegate::AUTH_REQUIRED_RESPONSE_NO_ACTION;
 }
 
 bool TestNetworkDelegate::OnCanGetCookies(const URLRequest& request,
@@ skipping 38 matching lines @@
 int TestNetworkDelegate::OnBeforeSocketStreamConnect(
     SocketStream* socket,
     const CompletionCallback& callback) {
   return OK;
 }
 
 // static
 std::string ScopedCustomUrlRequestTestHttpHost::value_("127.0.0.1");
 
 ScopedCustomUrlRequestTestHttpHost::ScopedCustomUrlRequestTestHttpHost(
-  const std::string& new_value)
-    : old_value_(value_),
-      new_value_(new_value) {
+    const std::string& new_value)
+    : old_value_(value_), new_value_(new_value) {
   value_ = new_value_;
 }
 
 ScopedCustomUrlRequestTestHttpHost::~ScopedCustomUrlRequestTestHttpHost() {
   DCHECK_EQ(value_, new_value_);
   value_ = old_value_;
 }
 
 // static
 const std::string& ScopedCustomUrlRequestTestHttpHost::value() {
   return value_;
 }
 
 TestJobInterceptor::TestJobInterceptor() : main_intercept_job_(NULL) {
 }
 
 URLRequestJob* TestJobInterceptor::MaybeCreateJob(
     URLRequest* request,
     NetworkDelegate* network_delegate) const {
   URLRequestJob* job = main_intercept_job_;
   main_intercept_job_ = NULL;
   return job;
 }
 
 void TestJobInterceptor::set_main_intercept_job(URLRequestJob* job) {
   main_intercept_job_ = job;
 }
 
 }  // namespace net