Allow URLFetcher to be used from sequenced tasks.

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 <stdint.h>
 #include <utility>
 
 #include "base/bind.h"
 #include "base/logging.h"
 #include "base/metrics/histogram_macros.h"
 #include "base/profiler/scoped_tracker.h"
 #include "base/sequenced_task_runner.h"
 #include "base/single_thread_task_runner.h"
 #include "base/stl_util.h"
-#include "base/threading/thread_task_runner_handle.h"
+#include "base/threading/sequenced_task_runner_handle.h"
 #include "base/tracked_objects.h"
 #include "net/base/elements_upload_data_stream.h"
 #include "net/base/io_buffer.h"
 #include "net/base/load_flags.h"
 #include "net/base/net_errors.h"
 #include "net/base/request_priority.h"
 #include "net/base/upload_bytes_element_reader.h"
 #include "net/base/upload_data_stream.h"
 #include "net/base/upload_file_element_reader.h"
 #include "net/http/http_response_headers.h"
@@ skipping 44 matching lines @@
     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()),
+      delegate_task_runner_(base::SequencedTaskRunnerHandle::Get()),
       load_flags_(LOAD_NORMAL),
       response_code_(URLFetcher::RESPONSE_CODE_INVALID),
       buffer_(new IOBuffer(kBufferSize)),
       url_request_data_key_(NULL),
       was_fetched_via_proxy_(false),
       was_cached_(false),
       received_response_content_length_(0),
       total_received_bytes_(0),
       upload_content_set_(false),
       upload_range_offset_(0),
       upload_range_length_(0),
       referrer_policy_(
           URLRequest::CLEAR_REFERRER_ON_TRANSITION_FROM_SECURE_TO_INSECURE),
       is_chunked_upload_(false),
       was_cancelled_(false),
       stop_on_redirect_(false),
       stopped_on_redirect_(false),
       automatically_retry_on_5xx_(true),
       num_retries_on_5xx_(0),
       max_retries_on_5xx_(0),
       num_retries_on_network_changes_(0),
       max_retries_on_network_changes_(0),
       current_upload_bytes_(-1),
       current_response_bytes_(0),
       total_response_bytes_(-1) {
   CHECK(original_url_.is_valid());
 }
 
 void URLFetcherCore::Start() {
-  DCHECK(delegate_task_runner_.get());
+  DCHECK(delegate_task_runner_);
   DCHECK(request_context_getter_.get()) << "We need an URLRequestContext!";
   if (network_task_runner_.get()) {
     DCHECK_EQ(network_task_runner_,
               request_context_getter_->GetNetworkTaskRunner());
   } else {
     network_task_runner_ = request_context_getter_->GetNetworkTaskRunner();
   }
   DCHECK(network_task_runner_.get()) << "We need an IO task runner";
 
   network_task_runner_->PostTask(
       FROM_HERE, base::Bind(&URLFetcherCore::StartOnIOThread, this));
 }
 
 void URLFetcherCore::Stop() {
-  if (delegate_task_runner_.get())  // May be NULL in tests.
-    DCHECK(delegate_task_runner_->BelongsToCurrentThread());
+  if (delegate_task_runner_)  // May be NULL in tests.
+    DCHECK(delegate_task_runner_->RunsTasksOnCurrentThread());
 
   delegate_ = NULL;
   fetcher_ = NULL;
   if (!network_task_runner_.get())
     return;
   if (network_task_runner_->RunsTasksOnCurrentThread()) {
     CancelURLRequest(ERR_ABORTED);
   } else {
     network_task_runner_->PostTask(
         FROM_HERE,
@@ skipping 58 matching lines @@
   // 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(delegate_task_runner_);
   DCHECK(network_task_runner_.get());
   DCHECK(is_chunked_upload_);
   network_task_runner_->PostTask(
       FROM_HERE,
       base::Bind(&URLFetcherCore::CompleteAddingUploadDataChunk, this, content,
                  is_last_chunk));
 }
 
 void URLFetcherCore::SetLoadFlags(int load_flags) {
   load_flags_ = load_flags;
@@ skipping 64 matching lines @@
   return backoff_delay_;
 }
 
 void URLFetcherCore::SetAutomaticallyRetryOnNetworkChanges(int max_retries) {
   max_retries_on_network_changes_ = max_retries;
 }
 
 void URLFetcherCore::SaveResponseToFileAtPath(
     const base::FilePath& file_path,
     scoped_refptr<base::SequencedTaskRunner> file_task_runner) {
-  DCHECK(delegate_task_runner_->BelongsToCurrentThread());
+  DCHECK(delegate_task_runner_->RunsTasksOnCurrentThread());
   SaveResponseWithWriter(std::unique_ptr<URLFetcherResponseWriter>(
       new URLFetcherFileWriter(file_task_runner, file_path)));
 }
 
 void URLFetcherCore::SaveResponseToTemporaryFile(
     scoped_refptr<base::SequencedTaskRunner> file_task_runner) {
-  DCHECK(delegate_task_runner_->BelongsToCurrentThread());
+  DCHECK(delegate_task_runner_->RunsTasksOnCurrentThread());
   SaveResponseWithWriter(std::unique_ptr<URLFetcherResponseWriter>(
       new URLFetcherFileWriter(file_task_runner, base::FilePath())));
 }
 
 void URLFetcherCore::SaveResponseWithWriter(
     std::unique_ptr<URLFetcherResponseWriter> response_writer) {
-  DCHECK(delegate_task_runner_->BelongsToCurrentThread());
+  DCHECK(delegate_task_runner_->RunsTasksOnCurrentThread());
   response_writer_ = std::move(response_writer);
 }
 
 HttpResponseHeaders* URLFetcherCore::GetResponseHeaders() const {
   return response_headers_.get();
 }
 
 // TODO(panayiotis): socket_address_ is written in the IO thread,
 // if this is accessed in the UI thread, this could result in a race.
 // Same for response_headers_ above and was_fetched_via_proxy_ below.
@@ skipping 27 matching lines @@
 
 const URLRequestStatus& URLFetcherCore::GetStatus() const {
   return status_;
 }
 
 int URLFetcherCore::GetResponseCode() const {
   return response_code_;
 }
 
 void URLFetcherCore::ReceivedContentWasMalformed() {
-  DCHECK(delegate_task_runner_->BelongsToCurrentThread());
+  DCHECK(delegate_task_runner_->RunsTasksOnCurrentThread());
   if (network_task_runner_.get()) {
     network_task_runner_->PostTask(
         FROM_HERE, base::Bind(&URLFetcherCore::NotifyMalformedContent, this));
   }
 }
 
 bool URLFetcherCore::GetResponseAsString(
     std::string* out_response_string) const {
   URLFetcherStringWriter* string_writer =
       response_writer_ ? response_writer_->AsStringWriter() : NULL;
   if (!string_writer)
     return false;
 
   *out_response_string = string_writer->data();
   UMA_HISTOGRAM_MEMORY_KB("UrlFetcher.StringResponseSize",
                           (string_writer->data().length() / 1024));
   return true;
 }
 
 bool URLFetcherCore::GetResponseAsFilePath(bool take_ownership,
                                            base::FilePath* out_response_path) {
-  DCHECK(delegate_task_runner_->BelongsToCurrentThread());
+  DCHECK(delegate_task_runner_->RunsTasksOnCurrentThread());
 
   URLFetcherFileWriter* file_writer =
       response_writer_ ? response_writer_->AsFileWriter() : NULL;
   if (!file_writer)
     return false;
 
   *out_response_path = file_writer->file_path();
 
   if (take_ownership) {
     // Intentionally calling a file_writer_ method directly without posting
@@ skipping 276 matching lines @@
     if (!original_url_throttler_entry_.get()) {
       original_url_throttler_entry_ =
           context->throttler_manager()->RegisterRequestUrl(original_url_);
     }
 
     if (original_url_throttler_entry_.get()) {
       int64_t delay =
           original_url_throttler_entry_->ReserveSendingTimeForNextRequest(
               GetBackoffReleaseTime());
       if (delay != 0) {
-        base::ThreadTaskRunnerHandle::Get()->PostDelayedTask(
+        network_task_runner_->PostDelayedTask(
             FROM_HERE, base::Bind(&URLFetcherCore::StartURLRequest, this),
             base::TimeDelta::FromMilliseconds(delay));
         return;
       }
     }
   }
 
   StartURLRequest();
 }
 
@@ skipping 19 matching lines @@
   // context.
   request_context_getter_ = NULL;
   initiator_.reset();
   url_request_data_key_ = NULL;
   url_request_create_data_callback_.Reset();
   was_cancelled_ = true;
 }
 
 void URLFetcherCore::OnCompletedURLRequest(
     base::TimeDelta backoff_delay) {
-  DCHECK(delegate_task_runner_->BelongsToCurrentThread());
+  DCHECK(delegate_task_runner_->RunsTasksOnCurrentThread());
 
   // Save the status and backoff_delay so that delegates can read it.
   if (delegate_) {
     backoff_delay_ = backoff_delay;
     InformDelegateFetchIsComplete();
   }
 }
 
 void URLFetcherCore::InformDelegateFetchIsComplete() {
-  DCHECK(delegate_task_runner_->BelongsToCurrentThread());
+  DCHECK(delegate_task_runner_->RunsTasksOnCurrentThread());
   if (delegate_)
     delegate_->OnURLFetchComplete(fetcher_);
 }
 
 void URLFetcherCore::NotifyMalformedContent() {
   DCHECK(network_task_runner_->BelongsToCurrentThread());
   if (url_throttler_entry_.get()) {
     int status_code = response_code_;
     if (status_code == URLFetcher::RESPONSE_CODE_INVALID) {
       // The status code will generally be known by the time clients
@@ skipping 170 matching lines @@
       if (!is_chunked_upload_) {
         total = static_cast<int64_t>(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,
+              &URLFetcherCore::InformDelegateUploadProgressInDelegateSequence,
               this, current, total));
     }
   }
 }
 
-void URLFetcherCore::InformDelegateUploadProgressInDelegateThread(
+void URLFetcherCore::InformDelegateUploadProgressInDelegateSequence(
     int64_t current,
     int64_t total) {
-  DCHECK(delegate_task_runner_->BelongsToCurrentThread());
+  DCHECK(delegate_task_runner_->RunsTasksOnCurrentThread());
   if (delegate_)
     delegate_->OnURLFetchUploadProgress(fetcher_, current, total);
 }
 
 void URLFetcherCore::InformDelegateDownloadProgress() {
   DCHECK(network_task_runner_->BelongsToCurrentThread());
 
   // TODO(pkasting): Remove ScopedTracker below once crbug.com/455952 is fixed.
   tracked_objects::ScopedTracker tracking_profile2(
       FROM_HERE_WITH_EXPLICIT_FUNCTION(
           "455952 delegate_task_runner_->PostTask()"));
 
   delegate_task_runner_->PostTask(
       FROM_HERE,
       base::Bind(
-          &URLFetcherCore::InformDelegateDownloadProgressInDelegateThread, this,
-          current_response_bytes_, total_response_bytes_,
+          &URLFetcherCore::InformDelegateDownloadProgressInDelegateSequence,
+          this, current_response_bytes_, total_response_bytes_,
           request_->GetTotalReceivedBytes()));
 }
 
-void URLFetcherCore::InformDelegateDownloadProgressInDelegateThread(
+void URLFetcherCore::InformDelegateDownloadProgressInDelegateSequence(
     int64_t current,
     int64_t total,
     int64_t current_network_bytes) {
-  DCHECK(delegate_task_runner_->BelongsToCurrentThread());
+  DCHECK(delegate_task_runner_->RunsTasksOnCurrentThread());
   if (delegate_)
     delegate_->OnURLFetchDownloadProgress(fetcher_, current, total,
                                           current_network_bytes);
 }
 
 void URLFetcherCore::AssertHasNoUploadData() const {
   DCHECK(!upload_content_set_);
   DCHECK(upload_content_.empty());
   DCHECK(upload_file_path_.empty());
   DCHECK(upload_stream_factory_.is_null());
 }
 
 }  // namespace net