Clang format slam.

net/url_request/url_fetcher_core.cc

 // Copyright (c) 2012 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "net/url_request/url_fetcher_core.h"
 
 #include "base/bind.h"
 #include "base/logging.h"
 #include "base/metrics/histogram.h"
 #include "base/sequenced_task_runner.h"
@@ skipping 15 matching lines @@
 #include "net/url_request/url_request_context_getter.h"
 #include "net/url_request/url_request_throttler_manager.h"
 
 namespace {
 
 const int kBufferSize = 4096;
 const int kUploadProgressTimerInterval = 100;
 bool g_interception_enabled = false;
 bool g_ignore_certificate_requests = false;
 
-void EmptyCompletionCallback(int result) {}
+void EmptyCompletionCallback(int result) {
+}
 
 }  // namespace
 
 namespace net {
 
 // URLFetcherCore::Registry ---------------------------------------------------
 
-URLFetcherCore::Registry::Registry() {}
-URLFetcherCore::Registry::~Registry() {}
+URLFetcherCore::Registry::Registry() {
+}
+URLFetcherCore::Registry::~Registry() {
+}
 
 void URLFetcherCore::Registry::AddURLFetcherCore(URLFetcherCore* core) {
   DCHECK(!ContainsKey(fetchers_, core));
   fetchers_.insert(core);
 }
 
 void URLFetcherCore::Registry::RemoveURLFetcherCore(URLFetcherCore* core) {
   DCHECK(ContainsKey(fetchers_, core));
   fetchers_.erase(core);
 }
 
 void URLFetcherCore::Registry::CancelAll() {
   while (!fetchers_.empty())
     (*fetchers_.begin())->CancelURLRequest(ERR_ABORTED);
 }
 
 // URLFetcherCore -------------------------------------------------------------
 
 // static
-base::LazyInstance<URLFetcherCore::Registry>
-    URLFetcherCore::g_registry = LAZY_INSTANCE_INITIALIZER;
+base::LazyInstance<URLFetcherCore::Registry> URLFetcherCore::g_registry =
+    LAZY_INSTANCE_INITIALIZER;
 
 URLFetcherCore::URLFetcherCore(URLFetcher* fetcher,
                                const GURL& original_url,
                                URLFetcher::RequestType request_type,
                                URLFetcherDelegate* d)
     : fetcher_(fetcher),
       original_url_(original_url),
       request_type_(request_type),
       delegate_(d),
       delegate_task_runner_(base::ThreadTaskRunnerHandle::Get()),
@@ skipping 88 matching lines @@
   upload_content_type_ = upload_content_type;
   upload_file_path_ = file_path;
   upload_range_offset_ = range_offset;
   upload_range_length_ = range_length;
   upload_file_task_runner_ = file_task_runner;
   upload_content_set_ = true;
 }
 
 void URLFetcherCore::SetChunkedUpload(const std::string& content_type) {
   DCHECK(is_chunked_upload_ ||
-         (upload_content_type_.empty() &&
-          upload_content_.empty()));
+         (upload_content_type_.empty() && upload_content_.empty()));
 
   // Empty |content_type| is not allowed here, because it is impossible
   // to ensure non-empty upload content as it is not yet supplied.
   DCHECK(!content_type.empty());
 
   upload_content_type_ = content_type;
   upload_content_.clear();
   is_chunked_upload_ = true;
 }
 
 void URLFetcherCore::AppendChunkToUpload(const std::string& content,
                                          bool is_last_chunk) {
   DCHECK(delegate_task_runner_.get());
   DCHECK(network_task_runner_.get());
   network_task_runner_->PostTask(
       FROM_HERE,
-      base::Bind(&URLFetcherCore::CompleteAddingUploadDataChunk, this, content,
+      base::Bind(&URLFetcherCore::CompleteAddingUploadDataChunk,
+                 this,
+                 content,
                  is_last_chunk));
 }
 
 void URLFetcherCore::SetLoadFlags(int load_flags) {
   load_flags_ = load_flags;
 }
 
 int URLFetcherCore::GetLoadFlags() const {
   return load_flags_;
 }
@@ skipping 201 matching lines @@
   DCHECK_EQ(request, request_.get());
   DCHECK(network_task_runner_->BelongsToCurrentThread());
 
   if (g_ignore_certificate_requests) {
     request->ContinueWithCertificate(NULL);
   } else {
     request->Cancel();
   }
 }
 
-void URLFetcherCore::OnReadCompleted(URLRequest* request,
-                                     int bytes_read) {
+void URLFetcherCore::OnReadCompleted(URLRequest* request, int bytes_read) {
   DCHECK(request == request_);
   DCHECK(network_task_runner_->BelongsToCurrentThread());
 
   if (!stopped_on_redirect_)
     url_ = request->url();
   URLRequestThrottlerManager* throttler_manager =
       request->context()->throttler_manager();
   if (throttler_manager) {
     url_throttler_entry_ = throttler_manager->RegisterRequestUrl(url_);
   }
@@ skipping 84 matching lines @@
   request_->set_stack_trace(stack_trace_);
   int flags = request_->load_flags() | load_flags_;
   if (!g_interception_enabled)
     flags = flags | LOAD_DISABLE_INTERCEPT;
 
   if (is_chunked_upload_)
     request_->EnableChunkedUpload();
   request_->SetLoadFlags(flags);
   request_->SetReferrer(referrer_);
   request_->set_referrer_policy(referrer_policy_);
-  request_->set_first_party_for_cookies(first_party_for_cookies_.is_empty() ?
-      original_url_ : first_party_for_cookies_);
+  request_->set_first_party_for_cookies(first_party_for_cookies_.is_empty()
+                                            ? original_url_
+                                            : first_party_for_cookies_);
   if (url_request_data_key_ && !url_request_create_data_callback_.is_null()) {
     request_->SetUserData(url_request_data_key_,
                           url_request_create_data_callback_.Run());
   }
 
   switch (request_type_) {
     case URLFetcher::GET:
       break;
 
     case URLFetcher::POST:
     case URLFetcher::PUT:
     case URLFetcher::PATCH:
       // Upload content must be set.
       DCHECK(is_chunked_upload_ || upload_content_set_);
 
-      request_->set_method(
-          request_type_ == URLFetcher::POST ? "POST" :
-          request_type_ == URLFetcher::PUT ? "PUT" : "PATCH");
+      request_->set_method(request_type_ == URLFetcher::POST
+                               ? "POST"
+                               : request_type_ == URLFetcher::PUT ? "PUT"
+                                                                  : "PATCH");
       if (!upload_content_type_.empty()) {
         extra_request_headers_.SetHeader(HttpRequestHeaders::kContentType,
                                          upload_content_type_);
       }
       if (!upload_content_.empty()) {
         scoped_ptr<UploadElementReader> reader(new UploadBytesElementReader(
             upload_content_.data(), upload_content_.size()));
         request_->set_upload(make_scoped_ptr(
             UploadDataStream::CreateWithReader(reader.Pass(), 0)));
       } else if (!upload_file_path_.empty()) {
@@ skipping 67 matching lines @@
   }
   if (original_url_throttler_entry_.get() != NULL) {
     delay = original_url_throttler_entry_->ReserveSendingTimeForNextRequest(
         GetBackoffReleaseTime());
   }
 
   if (delay == 0) {
     StartURLRequest();
   } else {
     base::ThreadTaskRunnerHandle::Get()->PostDelayedTask(
-        FROM_HERE, base::Bind(&URLFetcherCore::StartURLRequest, this),
+        FROM_HERE,
+        base::Bind(&URLFetcherCore::StartURLRequest, this),
         base::TimeDelta::FromMilliseconds(delay));
   }
 }
 
 void URLFetcherCore::CancelURLRequest(int error) {
   DCHECK(network_task_runner_->BelongsToCurrentThread());
 
   if (request_.get()) {
     request_->CancelWithError(error);
     ReleaseRequest();
@@ skipping 12 matching lines @@
   // references to URLFetcher::Core at this point so it may take a while to
   // delete the object, but we cannot delay the destruction of the request
   // context.
   request_context_getter_ = NULL;
   first_party_for_cookies_ = GURL();
   url_request_data_key_ = NULL;
   url_request_create_data_callback_.Reset();
   was_cancelled_ = true;
 }
 
-void URLFetcherCore::OnCompletedURLRequest(
-    base::TimeDelta backoff_delay) {
+void URLFetcherCore::OnCompletedURLRequest(base::TimeDelta backoff_delay) {
   DCHECK(delegate_task_runner_->BelongsToCurrentThread());
 
   // Save the status and backoff_delay so that delegates can read it.
   if (delegate_) {
     backoff_delay_ = backoff_delay;
     InformDelegateFetchIsComplete();
   }
 }
 
 void URLFetcherCore::InformDelegateFetchIsComplete() {
@@ skipping 28 matching lines @@
   }
   // If the file was successfully closed, then the URL request is complete.
   RetryOrCompleteUrlFetch();
 }
 
 void URLFetcherCore::RetryOrCompleteUrlFetch() {
   DCHECK(network_task_runner_->BelongsToCurrentThread());
   base::TimeDelta backoff_delay;
 
   // Checks the response from server.
-  if (response_code_ >= 500 ||
-      status_.error() == ERR_TEMPORARILY_THROTTLED) {
+  if (response_code_ >= 500 || status_.error() == ERR_TEMPORARILY_THROTTLED) {
     // When encountering a server error, we will send the request again
     // after backoff time.
     ++num_retries_on_5xx_;
 
     // Note that backoff_delay may be 0 because (a) the
     // URLRequestThrottlerManager and related code does not
     // necessarily back off on the first error, (b) it only backs off
     // on some of the 5xx status codes, (c) not all URLRequestContexts
     // have a throttler manager.
     base::TimeTicks backoff_release_time = GetBackoffReleaseTime();
@@ skipping 47 matching lines @@
   if (original_url_throttler_entry_.get()) {
     base::TimeTicks original_url_backoff =
         original_url_throttler_entry_->GetExponentialBackoffReleaseTime();
     base::TimeTicks destination_url_backoff;
     if (url_throttler_entry_.get() != NULL &&
         original_url_throttler_entry_.get() != url_throttler_entry_.get()) {
       destination_url_backoff =
           url_throttler_entry_->GetExponentialBackoffReleaseTime();
     }
 
-    return original_url_backoff > destination_url_backoff ?
-        original_url_backoff : destination_url_backoff;
+    return original_url_backoff > destination_url_backoff
+               ? original_url_backoff
+               : destination_url_backoff;
   } else {
     return base::TimeTicks();
   }
 }
 
-void URLFetcherCore::CompleteAddingUploadDataChunk(
-    const std::string& content, bool is_last_chunk) {
+void URLFetcherCore::CompleteAddingUploadDataChunk(const std::string& content,
+                                                   bool is_last_chunk) {
   if (was_cancelled_) {
     // Since CompleteAddingUploadDataChunk() is posted as a *delayed* task, it
     // may run after the URLFetcher was already stopped.
     return;
   }
   DCHECK(is_chunked_upload_);
   DCHECK(request_.get());
   DCHECK(!content.empty());
-  request_->AppendChunkToUpload(content.data(),
-                                static_cast<int>(content.length()),
-                                is_last_chunk);
+  request_->AppendChunkToUpload(
+      content.data(), static_cast<int>(content.length()), is_last_chunk);
 }
 
 int URLFetcherCore::WriteBuffer(scoped_refptr<DrainableIOBuffer> data) {
   while (data->BytesRemaining() > 0) {
     const int result = response_writer_->Write(
         data.get(),
         data->BytesRemaining(),
         base::Bind(&URLFetcherCore::DidWriteBuffer, this, data));
     if (result < 0) {
       if (result != ERR_IO_PENDING)
@@ skipping 27 matching lines @@
   if (request_.get())
     ReadResponse();
 }
 
 void URLFetcherCore::ReadResponse() {
   // Some servers may treat HEAD requests as GET requests.  To free up the
   // network connection as soon as possible, signal that the request has
   // completed immediately, without trying to read any data back (all we care
   // about is the response code and headers, which we already have).
   int bytes_read = 0;
-  if (request_->status().is_success() &&
-      (request_type_ != URLFetcher::HEAD))
+  if (request_->status().is_success() && (request_type_ != URLFetcher::HEAD))
     request_->Read(buffer_.get(), kBufferSize, &bytes_read);
   OnReadCompleted(request_.get(), bytes_read);
 }
 
 void URLFetcherCore::InformDelegateUploadProgress() {
   DCHECK(network_task_runner_->BelongsToCurrentThread());
   if (request_.get()) {
     int64 current = request_->GetUploadProgress().position();
     if (current_upload_bytes_ != current) {
       current_upload_bytes_ = current;
       int64 total = -1;
       if (!is_chunked_upload_) {
         total = static_cast<int64>(request_->GetUploadProgress().size());
         // Total may be zero if the UploadDataStream::Init has not been called
         // yet.  Don't send the upload progress until the size is initialized.
         if (!total)
           return;
       }
       delegate_task_runner_->PostTask(
           FROM_HERE,
           base::Bind(
               &URLFetcherCore::InformDelegateUploadProgressInDelegateThread,
-              this, current, total));
+              this,
+              current,
+              total));
     }
   }
 }
 
-void URLFetcherCore::InformDelegateUploadProgressInDelegateThread(
-    int64 current, int64 total) {
+void URLFetcherCore::InformDelegateUploadProgressInDelegateThread(int64 current,
+                                                                  int64 total) {
   DCHECK(delegate_task_runner_->BelongsToCurrentThread());
   if (delegate_)
     delegate_->OnURLFetchUploadProgress(fetcher_, current, total);
 }
 
 void URLFetcherCore::InformDelegateDownloadProgress() {
   DCHECK(network_task_runner_->BelongsToCurrentThread());
   delegate_task_runner_->PostTask(
       FROM_HERE,
       base::Bind(
           &URLFetcherCore::InformDelegateDownloadProgressInDelegateThread,
-          this, current_response_bytes_, total_response_bytes_));
+          this,
+          current_response_bytes_,
+          total_response_bytes_));
 }
 
 void URLFetcherCore::InformDelegateDownloadProgressInDelegateThread(
-    int64 current, int64 total) {
+    int64 current,
+    int64 total) {
   DCHECK(delegate_task_runner_->BelongsToCurrentThread());
   if (delegate_)
     delegate_->OnURLFetchDownloadProgress(fetcher_, current, total);
 }
 
 }  // namespace net