Rename TaskRunner::RunsTasksOnCurrentThread() in //chrome

chrome/browser/sync_file_system/local/canned_syncable_file_system.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 "chrome/browser/sync_file_system/local/canned_syncable_file_system.h"
 
 #include <stddef.h>
 #include <algorithm>
 #include <iterator>
 #include <utility>
@@ skipping 71 matching lines @@
   base::RunLoop run_loop;
   task_runner->PostTaskAndReply(location, task,
                                 base::BindOnce(base::IgnoreResult(base::Bind(
                                     &base::SingleThreadTaskRunner::PostTask,
                                     base::ThreadTaskRunnerHandle::Get(),
                                     FROM_HERE, run_loop.QuitClosure()))));
   run_loop.Run();
 }
 
 void EnsureRunningOn(base::SingleThreadTaskRunner* runner) {
-  EXPECT_TRUE(runner->RunsTasksOnCurrentThread());
+  EXPECT_TRUE(runner->RunsTasksInCurrentSequence());
 }
 
 void VerifySameTaskRunner(
     base::SingleThreadTaskRunner* runner1,
     base::SingleThreadTaskRunner* runner2) {
   ASSERT_TRUE(runner1 != nullptr);
   ASSERT_TRUE(runner2 != nullptr);
   runner1->PostTask(
       FROM_HERE, base::BindOnce(&EnsureRunningOn, base::RetainedRef(runner2)));
 }
@@ skipping 449 matching lines @@
       FROM_HERE, &LocalFileSyncStatus::Observer::OnSyncEnabled, url);
 }
 
 void CannedSyncableFileSystem::OnWriteEnabled(const FileSystemURL& url) {
   sync_status_observers_->Notify(
       FROM_HERE, &LocalFileSyncStatus::Observer::OnWriteEnabled, url);
 }
 
 void CannedSyncableFileSystem::DoOpenFileSystem(
     const OpenFileSystemCallback& callback) {
-  EXPECT_TRUE(io_task_runner_->RunsTasksOnCurrentThread());
+  EXPECT_TRUE(io_task_runner_->RunsTasksInCurrentSequence());
   EXPECT_FALSE(is_filesystem_opened_);
   file_system_context_->OpenFileSystem(
       origin_,
       type_,
       storage::OPEN_FILE_SYSTEM_CREATE_IF_NONEXISTENT,
       callback);
 }
 
 void CannedSyncableFileSystem::DoCreateDirectory(
     const FileSystemURL& url,
     const StatusCallback& callback) {
-  EXPECT_TRUE(io_task_runner_->RunsTasksOnCurrentThread());
+  EXPECT_TRUE(io_task_runner_->RunsTasksInCurrentSequence());
   EXPECT_TRUE(is_filesystem_opened_);
   operation_runner()->CreateDirectory(
       url, false /* exclusive */, false /* recursive */, callback);
 }
 
 void CannedSyncableFileSystem::DoCreateFile(
     const FileSystemURL& url,
     const StatusCallback& callback) {
-  EXPECT_TRUE(io_task_runner_->RunsTasksOnCurrentThread());
+  EXPECT_TRUE(io_task_runner_->RunsTasksInCurrentSequence());
   EXPECT_TRUE(is_filesystem_opened_);
   operation_runner()->CreateFile(url, false /* exclusive */, callback);
 }
 
 void CannedSyncableFileSystem::DoCopy(
     const FileSystemURL& src_url,
     const FileSystemURL& dest_url,
     const StatusCallback& callback) {
-  EXPECT_TRUE(io_task_runner_->RunsTasksOnCurrentThread());
+  EXPECT_TRUE(io_task_runner_->RunsTasksInCurrentSequence());
   EXPECT_TRUE(is_filesystem_opened_);
   operation_runner()->Copy(
       src_url, dest_url, storage::FileSystemOperation::OPTION_NONE,
       storage::FileSystemOperation::ERROR_BEHAVIOR_ABORT,
       storage::FileSystemOperationRunner::CopyProgressCallback(), callback);
 }
 
 void CannedSyncableFileSystem::DoMove(
     const FileSystemURL& src_url,
     const FileSystemURL& dest_url,
     const StatusCallback& callback) {
-  EXPECT_TRUE(io_task_runner_->RunsTasksOnCurrentThread());
+  EXPECT_TRUE(io_task_runner_->RunsTasksInCurrentSequence());
   EXPECT_TRUE(is_filesystem_opened_);
   operation_runner()->Move(
       src_url, dest_url, storage::FileSystemOperation::OPTION_NONE, callback);
 }
 
 void CannedSyncableFileSystem::DoTruncateFile(const FileSystemURL& url,
                                               int64_t size,
                                               const StatusCallback& callback) {
-  EXPECT_TRUE(io_task_runner_->RunsTasksOnCurrentThread());
+  EXPECT_TRUE(io_task_runner_->RunsTasksInCurrentSequence());
   EXPECT_TRUE(is_filesystem_opened_);
   operation_runner()->Truncate(url, size, callback);
 }
 
 void CannedSyncableFileSystem::DoTouchFile(
     const FileSystemURL& url,
     const base::Time& last_access_time,
     const base::Time& last_modified_time,
     const StatusCallback& callback) {
-  EXPECT_TRUE(io_task_runner_->RunsTasksOnCurrentThread());
+  EXPECT_TRUE(io_task_runner_->RunsTasksInCurrentSequence());
   EXPECT_TRUE(is_filesystem_opened_);
   operation_runner()->TouchFile(url, last_access_time,
                                 last_modified_time, callback);
 }
 
 void CannedSyncableFileSystem::DoRemove(
     const FileSystemURL& url, bool recursive,
     const StatusCallback& callback) {
-  EXPECT_TRUE(io_task_runner_->RunsTasksOnCurrentThread());
+  EXPECT_TRUE(io_task_runner_->RunsTasksInCurrentSequence());
   EXPECT_TRUE(is_filesystem_opened_);
   operation_runner()->Remove(url, recursive, callback);
 }
 
 void CannedSyncableFileSystem::DoFileExists(
     const FileSystemURL& url, const StatusCallback& callback) {
-  EXPECT_TRUE(io_task_runner_->RunsTasksOnCurrentThread());
+  EXPECT_TRUE(io_task_runner_->RunsTasksInCurrentSequence());
   EXPECT_TRUE(is_filesystem_opened_);
   operation_runner()->FileExists(url, callback);
 }
 
 void CannedSyncableFileSystem::DoDirectoryExists(
     const FileSystemURL& url, const StatusCallback& callback) {
-  EXPECT_TRUE(io_task_runner_->RunsTasksOnCurrentThread());
+  EXPECT_TRUE(io_task_runner_->RunsTasksInCurrentSequence());
   EXPECT_TRUE(is_filesystem_opened_);
   operation_runner()->DirectoryExists(url, callback);
 }
 
 void CannedSyncableFileSystem::DoVerifyFile(
     const FileSystemURL& url,
     const std::string& expected_data,
     const StatusCallback& callback) {
-  EXPECT_TRUE(io_task_runner_->RunsTasksOnCurrentThread());
+  EXPECT_TRUE(io_task_runner_->RunsTasksInCurrentSequence());
   EXPECT_TRUE(is_filesystem_opened_);
   operation_runner()->CreateSnapshotFile(
       url,
       base::Bind(&OnCreateSnapshotFileAndVerifyData, expected_data, callback));
 }
 
 void CannedSyncableFileSystem::DoGetMetadataAndPlatformPath(
     const FileSystemURL& url,
     base::File::Info* info,
     base::FilePath* platform_path,
     const StatusCallback& callback) {
-  EXPECT_TRUE(io_task_runner_->RunsTasksOnCurrentThread());
+  EXPECT_TRUE(io_task_runner_->RunsTasksInCurrentSequence());
   EXPECT_TRUE(is_filesystem_opened_);
   operation_runner()->CreateSnapshotFile(
       url, base::Bind(&OnCreateSnapshotFile, info, platform_path, callback));
 }
 
 void CannedSyncableFileSystem::DoReadDirectory(
     const FileSystemURL& url,
     FileEntryList* entries,
     const StatusCallback& callback) {
-  EXPECT_TRUE(io_task_runner_->RunsTasksOnCurrentThread());
+  EXPECT_TRUE(io_task_runner_->RunsTasksInCurrentSequence());
   EXPECT_TRUE(is_filesystem_opened_);
   operation_runner()->ReadDirectory(
       url, base::Bind(&OnReadDirectory, entries, callback));
 }
 
 void CannedSyncableFileSystem::DoWrite(
     net::URLRequestContext* url_request_context,
     const FileSystemURL& url,
     std::unique_ptr<storage::BlobDataHandle> blob_data_handle,
     const WriteCallback& callback) {
-  EXPECT_TRUE(io_task_runner_->RunsTasksOnCurrentThread());
+  EXPECT_TRUE(io_task_runner_->RunsTasksInCurrentSequence());
   EXPECT_TRUE(is_filesystem_opened_);
   WriteHelper* helper = new WriteHelper;
   operation_runner()->Write(
       url_request_context, url, std::move(blob_data_handle), 0,
       base::Bind(&WriteHelper::DidWrite, base::Owned(helper), callback));
 }
 
 void CannedSyncableFileSystem::DoWriteString(
     const FileSystemURL& url,
     const std::string& data,
     const WriteCallback& callback) {
-  EXPECT_TRUE(io_task_runner_->RunsTasksOnCurrentThread());
+  EXPECT_TRUE(io_task_runner_->RunsTasksInCurrentSequence());
   EXPECT_TRUE(is_filesystem_opened_);
   MockBlobURLRequestContext* url_request_context(
       new MockBlobURLRequestContext(file_system_context_.get()));
   WriteHelper* helper = new WriteHelper(url_request_context, data);
   operation_runner()->Write(url_request_context, url,
                             helper->scoped_text_blob()->GetBlobDataHandle(), 0,
                             base::Bind(&WriteHelper::DidWrite,
                                        base::Owned(helper), callback));
 }
 
 void CannedSyncableFileSystem::DoGetUsageAndQuota(
     int64_t* usage,
     int64_t* quota,
     const storage::StatusCallback& callback) {
   // crbug.com/349708
   TRACE_EVENT0("io", "CannedSyncableFileSystem::DoGetUsageAndQuota");
 
-  EXPECT_TRUE(io_task_runner_->RunsTasksOnCurrentThread());
+  EXPECT_TRUE(io_task_runner_->RunsTasksInCurrentSequence());
   EXPECT_TRUE(is_filesystem_opened_);
   DCHECK(quota_manager_.get());
   quota_manager_->GetUsageAndQuota(
       origin_, storage_type(),
       base::Bind(&DidGetUsageAndQuota, callback, usage, quota));
 }
 
 void CannedSyncableFileSystem::DidOpenFileSystem(
     base::SingleThreadTaskRunner* original_task_runner,
     const base::Closure& quit_closure,
     const GURL& root,
     const std::string& name,
     File::Error result) {
-  if (io_task_runner_->RunsTasksOnCurrentThread()) {
+  if (io_task_runner_->RunsTasksInCurrentSequence()) {
     EXPECT_FALSE(is_filesystem_opened_);
     is_filesystem_opened_ = true;
   }
-  if (!original_task_runner->RunsTasksOnCurrentThread()) {
-    DCHECK(io_task_runner_->RunsTasksOnCurrentThread());
+  if (!original_task_runner->RunsTasksInCurrentSequence()) {
+    DCHECK(io_task_runner_->RunsTasksInCurrentSequence());
     original_task_runner->PostTask(
         FROM_HERE, base::BindOnce(&CannedSyncableFileSystem::DidOpenFileSystem,
                                   base::Unretained(this),
                                   base::RetainedRef(original_task_runner),
                                   quit_closure, root, name, result));
     return;
   }
   result_ = result;
   root_url_ = root;
   quit_closure.Run();
 }
 
 void CannedSyncableFileSystem::DidInitializeFileSystemContext(
     const base::Closure& quit_closure,
     SyncStatusCode status) {
   sync_status_ = status;
   quit_closure.Run();
 }
 
 void CannedSyncableFileSystem::InitializeSyncStatusObserver() {
-  ASSERT_TRUE(io_task_runner_->RunsTasksOnCurrentThread());
+  ASSERT_TRUE(io_task_runner_->RunsTasksInCurrentSequence());
   backend()->sync_context()->sync_status()->AddObserver(this);
 }
 
 }  // namespace sync_file_system