Rename TaskRunner::RunsTasksOnCurrentThread() in //android_webview, //tools

android_webview/browser/net/aw_cookie_store_wrapper.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 "android_webview/browser/net/aw_cookie_store_wrapper.h"
 
 #include <string>
 
 #include "android_webview/browser/net/init_native_callback.h"
 #include "base/memory/ref_counted_delete_on_sequence.h"
@@ skipping 184 matching lines @@
     : client_task_runner_(base::ThreadTaskRunnerHandle::Get()),
       weak_factory_(this) {}
 
 AwCookieStoreWrapper::~AwCookieStoreWrapper() {}
 
 void AwCookieStoreWrapper::SetCookieWithOptionsAsync(
     const GURL& url,
     const std::string& cookie_line,
     const net::CookieOptions& options,
     const net::CookieStore::SetCookiesCallback& callback) {
-  DCHECK(client_task_runner_->RunsTasksOnCurrentThread());
+  DCHECK(client_task_runner_->RunsTasksInCurrentSequence());
   PostTaskToCookieStoreTaskRunner(
       base::Bind(&SetCookieWithOptionsAsyncOnCookieThread, url, cookie_line,
                  options, CreateWrappedCallback<bool>(callback)));
 }
 
 void AwCookieStoreWrapper::SetCookieWithDetailsAsync(
     const GURL& url,
     const std::string& name,
     const std::string& value,
     const std::string& domain,
     const std::string& path,
     base::Time creation_time,
     base::Time expiration_time,
     base::Time last_access_time,
     bool secure,
     bool http_only,
     net::CookieSameSite same_site,
     net::CookiePriority priority,
     const SetCookiesCallback& callback) {
-  DCHECK(client_task_runner_->RunsTasksOnCurrentThread());
+  DCHECK(client_task_runner_->RunsTasksInCurrentSequence());
   PostTaskToCookieStoreTaskRunner(
       base::Bind(&SetCookieWithDetailsAsyncOnCookieThread, url, name, value,
                  domain, path, creation_time, expiration_time, last_access_time,
                  secure, http_only, same_site, priority,
                  CreateWrappedCallback<bool>(callback)));
 }
 
 void AwCookieStoreWrapper::GetCookiesWithOptionsAsync(
     const GURL& url,
     const net::CookieOptions& options,
     const GetCookiesCallback& callback) {
-  DCHECK(client_task_runner_->RunsTasksOnCurrentThread());
+  DCHECK(client_task_runner_->RunsTasksInCurrentSequence());
   PostTaskToCookieStoreTaskRunner(
       base::Bind(&GetCookiesWithOptionsAsyncOnCookieThread, url, options,
                  CreateWrappedCallback<const std::string&>(callback)));
 }
 
 void AwCookieStoreWrapper::GetCookieListWithOptionsAsync(
     const GURL& url,
     const net::CookieOptions& options,
     const GetCookieListCallback& callback) {
-  DCHECK(client_task_runner_->RunsTasksOnCurrentThread());
+  DCHECK(client_task_runner_->RunsTasksInCurrentSequence());
   PostTaskToCookieStoreTaskRunner(
       base::Bind(&GetCookieListWithOptionsAsyncOnCookieThread, url, options,
                  CreateWrappedCallback<const net::CookieList&>(callback)));
 }
 
 void AwCookieStoreWrapper::GetAllCookiesAsync(
     const GetCookieListCallback& callback) {
-  DCHECK(client_task_runner_->RunsTasksOnCurrentThread());
+  DCHECK(client_task_runner_->RunsTasksInCurrentSequence());
   PostTaskToCookieStoreTaskRunner(
       base::Bind(&GetAllCookiesAsyncOnCookieThread,
                  CreateWrappedCallback<const net::CookieList&>(callback)));
 }
 
 void AwCookieStoreWrapper::DeleteCookieAsync(const GURL& url,
                                              const std::string& cookie_name,
                                              const base::Closure& callback) {
-  DCHECK(client_task_runner_->RunsTasksOnCurrentThread());
+  DCHECK(client_task_runner_->RunsTasksInCurrentSequence());
   PostTaskToCookieStoreTaskRunner(
       base::Bind(&DeleteCookieAsyncOnCookieThread, url, cookie_name,
                  CreateWrappedClosureCallback(callback)));
 }
 
 void AwCookieStoreWrapper::DeleteCanonicalCookieAsync(
     const net::CanonicalCookie& cookie,
     const DeleteCallback& callback) {
-  DCHECK(client_task_runner_->RunsTasksOnCurrentThread());
+  DCHECK(client_task_runner_->RunsTasksInCurrentSequence());
   PostTaskToCookieStoreTaskRunner(
       base::Bind(&DeleteCanonicalCookieAsyncOnCookieThread, cookie,
                  CreateWrappedCallback<int>(callback)));
 }
 
 void AwCookieStoreWrapper::DeleteAllCreatedBetweenAsync(
     const base::Time& delete_begin,
     const base::Time& delete_end,
     const DeleteCallback& callback) {
-  DCHECK(client_task_runner_->RunsTasksOnCurrentThread());
+  DCHECK(client_task_runner_->RunsTasksInCurrentSequence());
   PostTaskToCookieStoreTaskRunner(
       base::Bind(&DeleteAllCreatedBetweenAsyncOnCookieThread, delete_begin,
                  delete_end, CreateWrappedCallback<int>(callback)));
 }
 
 void AwCookieStoreWrapper::DeleteAllCreatedBetweenWithPredicateAsync(
     const base::Time& delete_begin,
     const base::Time& delete_end,
     const CookiePredicate& predicate,
     const DeleteCallback& callback) {
-  DCHECK(client_task_runner_->RunsTasksOnCurrentThread());
+  DCHECK(client_task_runner_->RunsTasksInCurrentSequence());
   PostTaskToCookieStoreTaskRunner(base::Bind(
       &DeleteAllCreatedBetweenWithPredicateAsyncOnCookieThread, delete_begin,
       delete_end, predicate, CreateWrappedCallback<int>(callback)));
 }
 
 void AwCookieStoreWrapper::DeleteSessionCookiesAsync(
     const DeleteCallback& callback) {
-  DCHECK(client_task_runner_->RunsTasksOnCurrentThread());
+  DCHECK(client_task_runner_->RunsTasksInCurrentSequence());
   PostTaskToCookieStoreTaskRunner(
       base::Bind(&DeleteSessionCookiesAsyncOnCookieThread,
                  CreateWrappedCallback<int>(callback)));
 }
 
 void AwCookieStoreWrapper::FlushStore(const base::Closure& callback) {
-  DCHECK(client_task_runner_->RunsTasksOnCurrentThread());
+  DCHECK(client_task_runner_->RunsTasksInCurrentSequence());
   PostTaskToCookieStoreTaskRunner(base::Bind(
       &FlushStoreOnCookieThread, CreateWrappedClosureCallback(callback)));
 }
 
 void AwCookieStoreWrapper::SetForceKeepSessionState() {
-  DCHECK(client_task_runner_->RunsTasksOnCurrentThread());
+  DCHECK(client_task_runner_->RunsTasksInCurrentSequence());
   PostTaskToCookieStoreTaskRunner(
       base::Bind(&SetForceKeepSessionStateOnCookieThread));
 }
 
 std::unique_ptr<net::CookieStore::CookieChangedSubscription>
 AwCookieStoreWrapper::AddCallbackForCookie(
     const GURL& url,
     const std::string& name,
     const CookieChangedCallback& callback) {
-  DCHECK(client_task_runner_->RunsTasksOnCurrentThread());
+  DCHECK(client_task_runner_->RunsTasksInCurrentSequence());
 
   // The SubscriptionWrapper is owned by the subscription itself, and has no
   // connection to the AwCookieStoreWrapper after creation. Other CookieStore
   // implementations DCHECK if a subscription outlasts the cookie store,
   // unfortunately, this design makes DCHECKing if there's an outstanding
   // subscription when the AwCookieStoreWrapper is destroyed a bit ugly.
   // TODO(mmenke):  Still worth adding a DCHECK?
   SubscriptionWrapper* subscription = new SubscriptionWrapper();
   return subscription->Subscribe(url, name, callback);
 }
 
 bool AwCookieStoreWrapper::IsEphemeral() {
   return GetCookieStore()->IsEphemeral();
 }
 
 base::Closure AwCookieStoreWrapper::CreateWrappedClosureCallback(
     const base::Closure& callback) {
   if (callback.is_null())
     return callback;
   return base::Bind(base::IgnoreResult(&base::TaskRunner::PostTask),
                     client_task_runner_, FROM_HERE,
                     base::Bind(&AwCookieStoreWrapper::RunClosureCallback,
                                weak_factory_.GetWeakPtr(), callback));
 }
 
 void AwCookieStoreWrapper::RunClosureCallback(const base::Closure& callback) {
-  DCHECK(client_task_runner_->RunsTasksOnCurrentThread());
+  DCHECK(client_task_runner_->RunsTasksInCurrentSequence());
   callback.Run();
 }
 
 }  // namespace android_webview