Rename TaskRunner::RunsTasksOnCurrentThread() in //extensions, //headless, //mojo

headless/public/util/generic_url_request_job.cc

 // Copyright 2016 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 "headless/public/util/generic_url_request_job.h"
 
 #include <string.h>
 #include <algorithm>
 
 #include "base/logging.h"
@@ skipping 30 matching lines @@
       url_fetcher_(std::move(url_fetcher)),
       origin_task_runner_(base::ThreadTaskRunnerHandle::Get()),
       delegate_(delegate),
       headless_browser_context_(headless_browser_context),
       request_resource_info_(
           content::ResourceRequestInfo::ForRequest(request_)),
       request_id_(next_request_id_++),
       weak_factory_(this) {}
 
 GenericURLRequestJob::~GenericURLRequestJob() {
-  DCHECK(origin_task_runner_->RunsTasksOnCurrentThread());
+  DCHECK(origin_task_runner_->RunsTasksInCurrentSequence());
 }
 
 void GenericURLRequestJob::SetExtraRequestHeaders(
     const net::HttpRequestHeaders& headers) {
-  DCHECK(origin_task_runner_->RunsTasksOnCurrentThread());
+  DCHECK(origin_task_runner_->RunsTasksInCurrentSequence());
   extra_request_headers_ = headers;
 }
 
 void GenericURLRequestJob::Start() {
   PrepareCookies(request_->url(), request_->method(),
                  url::Origin(request_->first_party_for_cookies()),
                  base::Bind(&Delegate::OnPendingRequest,
                             base::Unretained(delegate_), this));
 }
 
 void GenericURLRequestJob::PrepareCookies(const GURL& rewritten_url,
                                           const std::string& method,
                                           const url::Origin& site_for_cookies,
                                           const base::Closure& done_callback) {
-  DCHECK(origin_task_runner_->RunsTasksOnCurrentThread());
+  DCHECK(origin_task_runner_->RunsTasksInCurrentSequence());
   net::CookieStore* cookie_store = request_->context()->cookie_store();
   net::CookieOptions options;
   options.set_include_httponly();
 
   // See net::URLRequestHttpJob::AddCookieHeaderAndStart().
   url::Origin requested_origin(rewritten_url);
   if (net::registry_controlled_domains::SameDomainOrHost(
           requested_origin, site_for_cookies,
           net::registry_controlled_domains::INCLUDE_PRIVATE_REGISTRIES)) {
     if (net::registry_controlled_domains::SameDomainOrHost(
@@ skipping 12 matching lines @@
       base::Bind(&GenericURLRequestJob::OnCookiesAvailable,
                  weak_factory_.GetWeakPtr(), rewritten_url, method,
                  done_callback));
 }
 
 void GenericURLRequestJob::OnCookiesAvailable(
     const GURL& rewritten_url,
     const std::string& method,
     const base::Closure& done_callback,
     const net::CookieList& cookie_list) {
-  DCHECK(origin_task_runner_->RunsTasksOnCurrentThread());
+  DCHECK(origin_task_runner_->RunsTasksInCurrentSequence());
   // TODO(alexclarke): Set user agent.
   // Pass cookies, the referrer and any extra headers into the fetch request.
   std::string cookie = net::CookieStore::BuildCookieLine(cookie_list);
   if (!cookie.empty())
     extra_request_headers_.SetHeader(net::HttpRequestHeaders::kCookie, cookie);
 
   if (!request_->referrer().empty()) {
     extra_request_headers_.SetHeader(net::HttpRequestHeaders::kReferer,
                                      request_->referrer());
   }
 
   done_callback.Run();
 }
 
 void GenericURLRequestJob::OnFetchStartError(net::Error error) {
-  DCHECK(origin_task_runner_->RunsTasksOnCurrentThread());
+  DCHECK(origin_task_runner_->RunsTasksInCurrentSequence());
   DispatchStartError(error);
   delegate_->OnResourceLoadFailed(this, error);
 }
 
 void GenericURLRequestJob::OnFetchComplete(
     const GURL& final_url,
     scoped_refptr<net::HttpResponseHeaders> response_headers,
     const char* body,
     size_t body_size) {
-  DCHECK(origin_task_runner_->RunsTasksOnCurrentThread());
+  DCHECK(origin_task_runner_->RunsTasksInCurrentSequence());
   response_time_ = base::TimeTicks::Now();
   response_headers_ = response_headers;
   body_ = body;
   body_size_ = body_size;
 
   DispatchHeadersComplete();
 
   delegate_->OnResourceLoadComplete(this, final_url, response_headers_, body_,
                                     body_size_);
 }
 
 int GenericURLRequestJob::ReadRawData(net::IOBuffer* buf, int buf_size) {
-  DCHECK(origin_task_runner_->RunsTasksOnCurrentThread());
+  DCHECK(origin_task_runner_->RunsTasksInCurrentSequence());
   // TODO(skyostil): Implement ranged fetches.
   // TODO(alexclarke): Add coverage for all the cases below.
   size_t bytes_available = body_size_ - read_offset_;
   size_t bytes_to_copy =
       std::min(static_cast<size_t>(buf_size), bytes_available);
   if (bytes_to_copy) {
     std::memcpy(buf->data(), &body_[read_offset_], bytes_to_copy);
     read_offset_ += bytes_to_copy;
   }
   return bytes_to_copy;
@@ skipping 119 matching lines @@
   const net::UploadBytesElementReader* reader =
       (*stream->GetElementReaders())[0]->AsBytesReader();
   return std::string(reader->bytes(), reader->length());
 }
 
 const Request* GenericURLRequestJob::GetRequest() const {
   return this;
 }
 
 void GenericURLRequestJob::AllowRequest() {
-  if (!origin_task_runner_->RunsTasksOnCurrentThread()) {
+  if (!origin_task_runner_->RunsTasksInCurrentSequence()) {
     origin_task_runner_->PostTask(
         FROM_HERE, base::Bind(&GenericURLRequestJob::AllowRequest,
                               weak_factory_.GetWeakPtr()));
     return;
   }
 
   url_fetcher_->StartFetch(request_->url(), request_->method(), GetPostData(),
                            extra_request_headers_, this);
 }
 
 void GenericURLRequestJob::BlockRequest(net::Error error) {
-  if (!origin_task_runner_->RunsTasksOnCurrentThread()) {
+  if (!origin_task_runner_->RunsTasksInCurrentSequence()) {
     origin_task_runner_->PostTask(
         FROM_HERE, base::Bind(&GenericURLRequestJob::BlockRequest,
                               weak_factory_.GetWeakPtr(), error));
     return;
   }
 
   DispatchStartError(error);
 }
 
 void GenericURLRequestJob::ModifyRequest(
     const GURL& url,
     const std::string& method,
     const std::string& post_data,
     const net::HttpRequestHeaders& request_headers) {
-  if (!origin_task_runner_->RunsTasksOnCurrentThread()) {
+  if (!origin_task_runner_->RunsTasksInCurrentSequence()) {
     origin_task_runner_->PostTask(
         FROM_HERE, base::Bind(&GenericURLRequestJob::ModifyRequest,
                               weak_factory_.GetWeakPtr(), url, method,
                               post_data, request_headers));
     return;
   }
 
   extra_request_headers_ = request_headers;
   PrepareCookies(
       request_->url(), request_->method(),
       url::Origin(request_->first_party_for_cookies()),
       base::Bind(&URLFetcher::StartFetch, base::Unretained(url_fetcher_.get()),
                  url, method, post_data, request_headers, this));
 }
 
 void GenericURLRequestJob::MockResponse(
     std::unique_ptr<MockResponseData> mock_response) {
-  if (!origin_task_runner_->RunsTasksOnCurrentThread()) {
+  if (!origin_task_runner_->RunsTasksInCurrentSequence()) {
     origin_task_runner_->PostTask(
         FROM_HERE, base::Bind(&GenericURLRequestJob::MockResponse,
                               weak_factory_.GetWeakPtr(),
                               base::Passed(std::move(mock_response))));
     return;
   }
 
   mock_response_ = std::move(mock_response);
 
   OnFetchCompleteExtractHeaders(request_->url(),
                                 mock_response_->response_data.data(),
                                 mock_response_->response_data.size());
 }
 
 }  // namespace headless