Rename TaskRunner::RunsTasksOnCurrentThread() in //net

net/cert_net/cert_net_fetcher_impl.cc

 // Copyright 2015 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.
 //
 // Overview
 //
 // The main entry point is CertNetFetcherImpl. This is an implementation of
 // CertNetFetcher that provides a service for fetching network requests.
 //
 // The interface for CertNetFetcher is synchronous, however allows
@@ skipping 187 matching lines @@
 // RequestCore tracks an outstanding call to Fetch(). It is
 // reference-counted for ease of sharing between threads.
 class RequestCore : public base::RefCountedThreadSafe<RequestCore> {
  public:
   explicit RequestCore(scoped_refptr<base::SingleThreadTaskRunner> task_runner)
       : completion_event_(base::WaitableEvent::ResetPolicy::MANUAL,
                           base::WaitableEvent::InitialState::NOT_SIGNALED),
         task_runner_(std::move(task_runner)) {}
 
   void AttachedToJob(Job* job) {
-    DCHECK(task_runner_->RunsTasksOnCurrentThread());
+    DCHECK(task_runner_->RunsTasksInCurrentSequence());
     DCHECK(!job_);
     // Requests should not be attached to jobs after they have been signalled
     // with a cancellation error (which happens via either Cancel() or
     // SignalImmediateError()).
     DCHECK_NE(error_, ERR_ABORTED);
     job_ = job;
   }
 
   void OnJobCompleted(Job* job,
                       Error error,
                       const std::vector<uint8_t>& response_body) {
-    DCHECK(task_runner_->RunsTasksOnCurrentThread());
+    DCHECK(task_runner_->RunsTasksInCurrentSequence());
 
     DCHECK_EQ(job_, job);
     job_ = nullptr;
 
     error_ = error;
     bytes_ = response_body;
     completion_event_.Signal();
   }
 
   // Detaches this request from its job (if it is attached to any) and
   // signals completion with ERR_ABORTED. Can be called from any thread.
   void CancelJob();
 
   // Can be used to signal that an error was encountered before the request was
   // attached to a job. Can be called from any thread.
   void SignalImmediateError();
 
   // Should only be called once.
   void WaitForResult(Error* error, std::vector<uint8_t>* bytes) {
-    DCHECK(!task_runner_->RunsTasksOnCurrentThread());
+    DCHECK(!task_runner_->RunsTasksInCurrentSequence());
 
     completion_event_.Wait();
     *bytes = std::move(bytes_);
     *error = error_;
 
     error_ = ERR_UNEXPECTED;
   }
 
  private:
   friend class base::RefCountedThreadSafe<RequestCore>;
@@ skipping 126 matching lines @@
   // also used for notifying a failure to start the URLRequest.
   base::OneShotTimer timer_;
 
   // Non-owned pointer to the AsyncCertNetFetcherImpl that created this job.
   AsyncCertNetFetcherImpl* parent_;
 
   DISALLOW_COPY_AND_ASSIGN(Job);
 };
 
 void RequestCore::CancelJob() {
-  if (!task_runner_->RunsTasksOnCurrentThread()) {
+  if (!task_runner_->RunsTasksInCurrentSequence()) {
     task_runner_->PostTask(FROM_HERE,
                            base::Bind(&RequestCore::CancelJob, this));
     return;
   }
 
   if (job_) {
     auto* job = job_;
     job_ = nullptr;
     job->DetachRequest(this);
   }
@@ skipping 306 matching lines @@
  private:
   scoped_refptr<RequestCore> core_;
 };
 
 class CertNetFetcherImpl : public CertNetFetcher {
  public:
   explicit CertNetFetcherImpl(URLRequestContext* context)
       : task_runner_(base::ThreadTaskRunnerHandle::Get()), context_(context) {}
 
   void Shutdown() override {
-    DCHECK(task_runner_->RunsTasksOnCurrentThread());
+    DCHECK(task_runner_->RunsTasksInCurrentSequence());
     if (impl_) {
       impl_->Shutdown();
       impl_.reset();
     }
     context_ = nullptr;
   }
 
   std::unique_ptr<Request> FetchCaIssuers(const GURL& url,
                                           int timeout_milliseconds,
                                           int max_response_bytes) override {
@@ skipping 37 matching lines @@
     return DoFetch(std::move(request_params));
   }
 
  private:
   ~CertNetFetcherImpl() override {
     // The fetcher must be shutdown (at which point |context_| will be set to
     // null) before destruction.
     DCHECK(!context_);
   }
 
-  void DoFetchOnNetworkThread(std::unique_ptr<RequestParams> request_params,
-                              scoped_refptr<RequestCore> request) {
-    DCHECK(task_runner_->RunsTasksOnCurrentThread());
+  void DoFetchOnNetworkSequence(std::unique_ptr<RequestParams> request_params,
+                                scoped_refptr<RequestCore> request) {
+    DCHECK(task_runner_->RunsTasksInCurrentSequence());
 
     if (!context_) {
       // The fetcher might have been shutdown between when this task was posted
       // and when it is running. In this case, signal the request and do not
       // start a network request.
       request->SignalImmediateError();
       return;
     }
 
     if (!impl_) {
       impl_.reset(new AsyncCertNetFetcherImpl(context_));
     }
 
     impl_->Fetch(std::move(request_params), request);
   }
 
   std::unique_ptr<Request> DoFetch(
       std::unique_ptr<RequestParams> request_params) {
     scoped_refptr<RequestCore> request_core = new RequestCore(task_runner_);
 
-    // If the fetcher has already been shutdown, DoFetchOnNetworkThread will
+    // If the fetcher has already been shutdown, DoFetchOnNetworkSequence will
     // signal the request with an error. However, if the fetcher shuts down
-    // before DoFetchOnNetworkThread runs and PostTask still returns true, then
-    // the request will hang (that is, WaitForResult will not return).
+    // before DoFetchOnNetworkSequence runs and PostTask still returns true,
+    // then the request will hang (that is, WaitForResult will not return).
     if (!task_runner_->PostTask(
             FROM_HERE,
-            base::Bind(&CertNetFetcherImpl::DoFetchOnNetworkThread, this,
+            base::Bind(&CertNetFetcherImpl::DoFetchOnNetworkSequence, this,
                        base::Passed(&request_params), request_core))) {
       request_core->SignalImmediateError();
     }
 
     return base::MakeUnique<CertNetFetcherRequestImpl>(std::move(request_core));
   }
 
  private:
   scoped_refptr<base::SingleThreadTaskRunner> task_runner_;
   // Not owned. |context_| must stay valid until Shutdown() is called.
   URLRequestContext* context_ = nullptr;
   std::unique_ptr<AsyncCertNetFetcherImpl> impl_;
 };
 
 }  // namespace
 
 scoped_refptr<CertNetFetcher> CreateCertNetFetcher(URLRequestContext* context) {
   return make_scoped_refptr(new CertNetFetcherImpl(context));
 }
 
 }  // namespace net