Rename TaskRunner::RunsTasksOnCurrentThread() in //components

components/update_client/url_request_post_interceptor.cc

 // Copyright 2013 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 "components/update_client/url_request_post_interceptor.h"
 
 #include <memory>
 
 #include "base/files/file_util.h"
 #include "base/macros.h"
@@ skipping 49 matching lines @@
   DISALLOW_COPY_AND_ASSIGN(URLRequestMockJob);
 };
 
 URLRequestPostInterceptor::URLRequestPostInterceptor(
     const GURL& url,
     const scoped_refptr<base::SequencedTaskRunner>& io_task_runner)
     : url_(url), io_task_runner_(io_task_runner), hit_count_(0) {
 }
 
 URLRequestPostInterceptor::~URLRequestPostInterceptor() {
-  DCHECK(io_task_runner_->RunsTasksOnCurrentThread());
+  DCHECK(io_task_runner_->RunsTasksInCurrentSequence());
   ClearExpectations();
 }
 
 void URLRequestPostInterceptor::ClearExpectations() {
   while (!expectations_.empty()) {
     Expectation expectation(expectations_.front());
     delete expectation.first;
     expectations_.pop();
   }
 }
@@ skipping 66 matching lines @@
 }
 
 class URLRequestPostInterceptor::Delegate : public net::URLRequestInterceptor {
  public:
   Delegate(const std::string& scheme,
            const std::string& hostname,
            const scoped_refptr<base::SequencedTaskRunner>& io_task_runner)
       : scheme_(scheme), hostname_(hostname), io_task_runner_(io_task_runner) {}
 
   void Register() {
-    DCHECK(io_task_runner_->RunsTasksOnCurrentThread());
+    DCHECK(io_task_runner_->RunsTasksInCurrentSequence());
     net::URLRequestFilter::GetInstance()->AddHostnameInterceptor(
         scheme_, hostname_, std::unique_ptr<net::URLRequestInterceptor>(this));
   }
 
   void Unregister() {
-    DCHECK(io_task_runner_->RunsTasksOnCurrentThread());
+    DCHECK(io_task_runner_->RunsTasksInCurrentSequence());
     for (InterceptorMap::iterator it = interceptors_.begin();
          it != interceptors_.end(); ++it)
       delete (*it).second;
     net::URLRequestFilter::GetInstance()->RemoveHostnameHandler(scheme_,
                                                                 hostname_);
   }
 
   void OnCreateInterceptor(URLRequestPostInterceptor* interceptor) {
-    DCHECK(io_task_runner_->RunsTasksOnCurrentThread());
+    DCHECK(io_task_runner_->RunsTasksInCurrentSequence());
     DCHECK(interceptors_.find(interceptor->GetUrl()) == interceptors_.end());
 
     interceptors_.insert(std::make_pair(interceptor->GetUrl(), interceptor));
   }
 
  private:
   ~Delegate() override {}
 
   net::URLRequestJob* MaybeInterceptRequest(
       net::URLRequest* request,
       net::NetworkDelegate* network_delegate) const override {
-    DCHECK(io_task_runner_->RunsTasksOnCurrentThread());
+    DCHECK(io_task_runner_->RunsTasksInCurrentSequence());
 
     // Only intercepts POST.
     if (!request->has_upload())
       return NULL;
 
     GURL url = request->url();
     if (url.has_query()) {
       GURL::Replacements replacements;
       replacements.ClearQuery();
       url = url.ReplaceComponents(replacements);
@@ skipping 106 matching lines @@
   return CreateInterceptorForPath(POST_INTERCEPT_PATH);
 }
 
 URLRequestPostInterceptor* InterceptorFactory::CreateInterceptorForPath(
     const char* url_path) {
   return URLRequestPostInterceptorFactory::CreateInterceptor(
       base::FilePath::FromUTF8Unsafe(url_path));
 }
 
 }  // namespace update_client