Clang format slam.

net/url_request/url_request.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.h"
 
 #include "base/bind.h"
 #include "base/bind_helpers.h"
 #include "base/callback.h"
 #include "base/compiler_specific.h"
@@ skipping 45 matching lines @@
   headers->RemoveHeader(HttpRequestHeaders::kContentType);
   headers->RemoveHeader(HttpRequestHeaders::kOrigin);
 }
 
 // TODO(battre): Delete this, see http://crbug.com/89321:
 // This counter keeps track of the identifiers used for URL requests so far.
 // 0 is reserved to represent an invalid ID.
 uint64 g_next_url_request_identifier = 1;
 
 // This lock protects g_next_url_request_identifier.
-base::LazyInstance<base::Lock>::Leaky
-    g_next_url_request_identifier_lock = LAZY_INSTANCE_INITIALIZER;
+base::LazyInstance<base::Lock>::Leaky g_next_url_request_identifier_lock =
+    LAZY_INSTANCE_INITIALIZER;
 
 // Returns an prior unused identifier for URL requests.
 uint64 GenerateURLRequestIdentifier() {
   base::AutoLock lock(g_next_url_request_identifier_lock.Get());
   return g_next_url_request_identifier++;
 }
 
 // True once the first URLRequest was started.
 bool g_url_requests_started = false;
 
@@ skipping 57 matching lines @@
     DCHECK(!connect_timing->ssl_end.is_null());
     if (connect_timing->ssl_start < block_on_connect)
       connect_timing->ssl_start = block_on_connect;
     if (connect_timing->ssl_end < block_on_connect)
       connect_timing->ssl_end = block_on_connect;
   }
 }
 
 }  // namespace
 
-URLRequest::ProtocolFactory*
-URLRequest::Deprecated::RegisterProtocolFactory(const std::string& scheme,
-                                                ProtocolFactory* factory) {
+URLRequest::ProtocolFactory* URLRequest::Deprecated::RegisterProtocolFactory(
+    const std::string& scheme,
+    ProtocolFactory* factory) {
   return URLRequest::RegisterProtocolFactory(scheme, factory);
 }
 
 void URLRequest::Deprecated::RegisterRequestInterceptor(
     Interceptor* interceptor) {
   URLRequest::RegisterRequestInterceptor(interceptor);
 }
 
 void URLRequest::Deprecated::UnregisterRequestInterceptor(
     Interceptor* interceptor) {
   URLRequest::UnregisterRequestInterceptor(interceptor);
 }
 
 ///////////////////////////////////////////////////////////////////////////////
 // URLRequest::Interceptor
 
 URLRequestJob* URLRequest::Interceptor::MaybeInterceptRedirect(
     URLRequest* request,
     NetworkDelegate* network_delegate,
     const GURL& location) {
   return NULL;
 }
 
 URLRequestJob* URLRequest::Interceptor::MaybeInterceptResponse(
-    URLRequest* request, NetworkDelegate* network_delegate) {
+    URLRequest* request,
+    NetworkDelegate* network_delegate) {
   return NULL;
 }
 
 ///////////////////////////////////////////////////////////////////////////////
 // URLRequest::Delegate
 
 void URLRequest::Delegate::OnReceivedRedirect(URLRequest* request,
                                               const GURL& new_url,
                                               bool* defer_redirect) {
 }
@@ skipping 57 matching lines @@
   int net_error = OK;
   // Log error only on failure, not cancellation, as even successful requests
   // are "cancelled" on destruction.
   if (status_.status() == URLRequestStatus::FAILED)
     net_error = status_.error();
   net_log_.EndEventWithNetErrorCode(NetLog::TYPE_REQUEST_ALIVE, net_error);
 }
 
 // static
 URLRequest::ProtocolFactory* URLRequest::RegisterProtocolFactory(
-    const string& scheme, ProtocolFactory* factory) {
+    const string& scheme,
+    ProtocolFactory* factory) {
   return URLRequestJobManager::GetInstance()->RegisterProtocolFactory(scheme,
                                                                       factory);
 }
 
 // static
 void URLRequest::RegisterRequestInterceptor(Interceptor* interceptor) {
   URLRequestJobManager::GetInstance()->RegisterRequestInterceptor(interceptor);
 }
 
 // static
@@ skipping 13 matching lines @@
   url_chain_.push_back(url);
   method_ = "GET";
   referrer_policy_ = CLEAR_REFERRER_ON_TRANSITION_FROM_SECURE_TO_INSECURE;
   load_flags_ = LOAD_NORMAL;
   delegate_ = delegate;
   is_pending_ = false;
   is_redirecting_ = false;
   redirect_limit_ = kMaxRedirects;
   priority_ = priority;
   calling_delegate_ = false;
-  use_blocked_by_as_load_param_ =false;
-  before_request_callback_ = base::Bind(&URLRequest::BeforeRequestComplete,
-                                        base::Unretained(this));
+  use_blocked_by_as_load_param_ = false;
+  before_request_callback_ =
+      base::Bind(&URLRequest::BeforeRequestComplete, base::Unretained(this));
   has_notified_completion_ = false;
   received_response_content_length_ = 0;
   creation_time_ = base::TimeTicks::Now();
   notified_before_network_start_ = false;
 
   SIMPLE_STATS_COUNTER("URLRequestCount");
 
   // Sanity check out environment.
   DCHECK(base::MessageLoop::current())
       << "The current base::MessageLoop must exist";
@@ skipping 30 matching lines @@
 }
 
 const UploadDataStream* URLRequest::get_upload() const {
   return upload_data_stream_.get();
 }
 
 bool URLRequest::has_upload() const {
   return upload_data_stream_.get() != NULL;
 }
 
-void URLRequest::SetExtraRequestHeaderById(int id, const string& value,
+void URLRequest::SetExtraRequestHeaderById(int id,
+                                           const string& value,
                                            bool overwrite) {
   DCHECK(!is_pending_ || is_redirecting_);
   NOTREACHED() << "implement me!";
 }
 
 void URLRequest::SetExtraRequestHeaderByName(const string& name,
                                              const string& value,
                                              bool overwrite) {
   DCHECK(!is_pending_ || is_redirecting_);
   if (overwrite) {
     extra_request_headers_.SetHeader(name, value);
   } else {
     extra_request_headers_.SetHeaderIfMissing(name, value);
   }
 }
 
 void URLRequest::RemoveRequestHeaderByName(const string& name) {
   DCHECK(!is_pending_ || is_redirecting_);
   extra_request_headers_.RemoveHeader(name);
 }
 
-void URLRequest::SetExtraRequestHeaders(
-    const HttpRequestHeaders& headers) {
+void URLRequest::SetExtraRequestHeaders(const HttpRequestHeaders& headers) {
   DCHECK(!is_pending_);
   extra_request_headers_ = headers;
 
   // NOTE: This method will likely become non-trivial once the other setters
   // for request headers are implemented.
 }
 
 bool URLRequest::GetFullRequestHeaders(HttpRequestHeaders* headers) const {
   if (!job_.get())
     return false;
 
   return job_->GetFullRequestHeaders(headers);
 }
 
 int64 URLRequest::GetTotalReceivedBytes() const {
   if (!job_.get())
     return 0;
 
   return job_->GetTotalReceivedBytes();
 }
 
 LoadStateWithParam URLRequest::GetLoadState() const {
   // The !blocked_by_.empty() check allows |this| to report it's blocked on a
   // delegate before it has been started.
   if (calling_delegate_ || !blocked_by_.empty()) {
-    return LoadStateWithParam(
-        LOAD_STATE_WAITING_FOR_DELEGATE,
-        use_blocked_by_as_load_param_ ? base::UTF8ToUTF16(blocked_by_) :
-                                        base::string16());
+    return LoadStateWithParam(LOAD_STATE_WAITING_FOR_DELEGATE,
+                              use_blocked_by_as_load_param_
+                                  ? base::UTF8ToUTF16(blocked_by_)
+                                  : base::string16());
   }
   return LoadStateWithParam(job_.get() ? job_->GetLoadState() : LOAD_STATE_IDLE,
                             base::string16());
 }
 
 base::Value* URLRequest::GetStateAsValue() const {
   base::DictionaryValue* dict = new base::DictionaryValue();
   dict->SetString("url", original_url().possibly_invalid_spec());
 
   if (url_chain_.size() > 1) {
     base::ListValue* list = new base::ListValue();
     for (std::vector<GURL>::const_iterator url = url_chain_.begin();
-         url != url_chain_.end(); ++url) {
+         url != url_chain_.end();
+         ++url) {
       list->AppendString(url->possibly_invalid_spec());
     }
     dict->Set("url_chain", list);
   }
 
   dict->SetInteger("load_flags", load_flags_);
 
   LoadStateWithParam load_state = GetLoadState();
   dict->SetInteger("load_state", load_state.state);
   if (!load_state.param.empty())
@@ skipping 33 matching lines @@
 
   // Only log information to NetLog during startup and certain deferring calls
   // to delegates.  For all reads but the first, do nothing.
   if (!calling_delegate_ && !response_info_.request_time.is_null())
     return;
 
   LogUnblocked();
   blocked_by_ = blocked_by;
   use_blocked_by_as_load_param_ = false;
 
-  net_log_.BeginEvent(
-      NetLog::TYPE_DELEGATE_INFO,
-      NetLog::StringCallback("delegate_info", &blocked_by_));
+  net_log_.BeginEvent(NetLog::TYPE_DELEGATE_INFO,
+                      NetLog::StringCallback("delegate_info", &blocked_by_));
 }
 
 void URLRequest::LogAndReportBlockedBy(const char* source) {
   LogBlockedBy(source);
   use_blocked_by_as_load_param_ = true;
 }
 
 void URLRequest::LogUnblocked() {
   if (blocked_by_.empty())
     return;
@@ skipping 111 matching lines @@
     const GURL& first_party_for_cookies) {
   first_party_for_cookies_ = first_party_for_cookies;
 }
 
 void URLRequest::set_method(const std::string& method) {
   DCHECK(!is_pending_);
   method_ = method;
 }
 
 // static
-std::string URLRequest::ComputeMethodForRedirect(
-    const std::string& method,
-    int http_status_code) {
+std::string URLRequest::ComputeMethodForRedirect(const std::string& method,
+                                                 int http_status_code) {
   // For 303 redirects, all request methods except HEAD are converted to GET,
   // as per the latest httpbis draft.  The draft also allows POST requests to
   // be converted to GETs when following 301/302 redirects, for historical
   // reasons. Most major browsers do this and so shall we.  Both RFC 2616 and
   // the httpbis draft say to prompt the user to confirm the generation of new
   // requests, other than GET and HEAD requests, but IE omits these prompts and
   // so shall we.
-  // See:  https://tools.ietf.org/html/draft-ietf-httpbis-p2-semantics-17#section-7.3
+  // See:
+  // https://tools.ietf.org/html/draft-ietf-httpbis-p2-semantics-17#section-7.3
   if ((http_status_code == 303 && method != "HEAD") ||
       ((http_status_code == 301 || http_status_code == 302) &&
        method == "POST")) {
     return "GET";
   }
   return method;
 }
 
 void URLRequest::SetReferrer(const std::string& referrer) {
   DCHECK(!is_pending_);
@@ skipping 34 matching lines @@
     OnCallToDelegate();
     int error = network_delegate_->NotifyBeforeURLRequest(
         this, before_request_callback_, &delegate_redirect_url_);
     // If ERR_IO_PENDING is returned, the delegate will invoke
     // |before_request_callback_| later.
     if (error != ERR_IO_PENDING)
       BeforeRequestComplete(error);
     return;
   }
 
-  StartJob(URLRequestJobManager::GetInstance()->CreateJob(
-      this, network_delegate_));
+  StartJob(
+      URLRequestJobManager::GetInstance()->CreateJob(this, network_delegate_));
 }
 
 ///////////////////////////////////////////////////////////////////////////////
 
 void URLRequest::BeforeRequestComplete(int error) {
   DCHECK(!job_.get());
   DCHECK_NE(ERR_IO_PENDING, error);
   DCHECK_EQ(network_delegate_, context_->network_delegate());
 
   // Check that there are no callbacks to already canceled requests.
   DCHECK_NE(URLRequestStatus::CANCELED, status_.status());
 
   OnCallToDelegateComplete();
 
   if (error != OK) {
     std::string source("delegate");
     net_log_.AddEvent(NetLog::TYPE_CANCELLED,
                       NetLog::StringCallback("source", &source));
     StartJob(new URLRequestErrorJob(this, network_delegate_, error));
   } else if (!delegate_redirect_url_.is_empty()) {
     GURL new_url;
     new_url.Swap(&delegate_redirect_url_);
 
     URLRequestRedirectJob* job = new URLRequestRedirectJob(
-        this, network_delegate_, new_url,
+        this,
+        network_delegate_,
+        new_url,
         // Use status code 307 to preserve the method, so POST requests work.
-        URLRequestRedirectJob::REDIRECT_307_TEMPORARY_REDIRECT, "Delegate");
+        URLRequestRedirectJob::REDIRECT_307_TEMPORARY_REDIRECT,
+        "Delegate");
     StartJob(job);
   } else {
-    StartJob(URLRequestJobManager::GetInstance()->CreateJob(
-        this, network_delegate_));
+    StartJob(URLRequestJobManager::GetInstance()->CreateJob(this,
+                                                            network_delegate_));
   }
 }
 
 void URLRequest::StartJob(URLRequestJob* job) {
   DCHECK(!is_pending_);
   DCHECK(!job_.get());
 
   net_log_.BeginEvent(
       NetLog::TYPE_URL_REQUEST_START_JOB,
       base::Bind(&NetLogURLRequestStartCallback,
-                 &url(), &method_, load_flags_, priority_,
+                 &url(),
+                 &method_,
+                 load_flags_,
+                 priority_,
                  upload_data_stream_ ? upload_data_stream_->identifier() : -1));
 
   job_ = job;
   job_->SetExtraRequestHeaders(extra_request_headers_);
   job_->SetPriority(priority_);
 
   if (upload_data_stream_.get())
     job_->SetUpload(upload_data_stream_.get());
 
   is_pending_ = true;
@@ skipping 22 matching lines @@
   job_->Start();
 }
 
 void URLRequest::Restart() {
   // Should only be called if the original job didn't make any progress.
   DCHECK(job_.get() && !job_->has_response_started());
   RestartWithJob(
       URLRequestJobManager::GetInstance()->CreateJob(this, network_delegate_));
 }
 
-void URLRequest::RestartWithJob(URLRequestJob *job) {
+void URLRequest::RestartWithJob(URLRequestJob* job) {
   DCHECK(job->request() == this);
   PrepareToRestart();
   StartJob(job);
 }
 
 void URLRequest::Cancel() {
   DoCancel(ERR_ABORTED, SSLInfo());
 }
 
 void URLRequest::CancelWithError(int error) {
@@ skipping 415 matching lines @@
 }
 
 bool URLRequest::CanEnablePrivacyMode() const {
   if (network_delegate_) {
     return network_delegate_->CanEnablePrivacyMode(url(),
                                                    first_party_for_cookies_);
   }
   return !g_default_can_use_cookies;
 }
 
-
 void URLRequest::NotifyReadCompleted(int bytes_read) {
   // Notify in case the entire URL Request has been finished.
   if (bytes_read <= 0)
     NotifyRequestCompleted();
 
   // Notify NetworkChangeNotifier that we just received network data.
   // This is to identify cases where the NetworkChangeNotifier thinks we
   // are off-line but we are still receiving network data (crbug.com/124069),
   // and to get rough network connection measurements.
   if (bytes_read > 0 && !was_cached())
@@ skipping 60 matching lines @@
       new base::debug::StackTrace(NULL, 0);
   *stack_trace_copy = stack_trace;
   stack_trace_.reset(stack_trace_copy);
 }
 
 const base::debug::StackTrace* URLRequest::stack_trace() const {
   return stack_trace_.get();
 }
 
 }  // namespace net