Rename TaskRunner::RunsTasksOnCurrentThread() in //chrome

chrome/browser/sync_file_system/local/local_file_sync_context.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/local_file_sync_context.h"
 
 #include <utility>
 
 #include "base/bind.h"
 #include "base/files/file_util.h"
@@ skipping 42 matching lines @@
     base::SingleThreadTaskRunner* ui_task_runner,
     base::SingleThreadTaskRunner* io_task_runner)
     : local_base_path_(base_path.Append(FILE_PATH_LITERAL("local"))),
       env_override_(env_override),
       ui_task_runner_(ui_task_runner),
       io_task_runner_(io_task_runner),
       shutdown_on_ui_(false),
       shutdown_on_io_(false),
       mock_notify_changes_duration_in_sec_(-1) {
   DCHECK(base_path.IsAbsolute());
-  DCHECK(ui_task_runner_->RunsTasksOnCurrentThread());
+  DCHECK(ui_task_runner_->RunsTasksInCurrentSequence());
 }
 
 void LocalFileSyncContext::MaybeInitializeFileSystemContext(
     const GURL& source_url,
     FileSystemContext* file_system_context,
     const SyncStatusCallback& callback) {
-  DCHECK(ui_task_runner_->RunsTasksOnCurrentThread());
+  DCHECK(ui_task_runner_->RunsTasksInCurrentSequence());
   if (base::ContainsKey(file_system_contexts_, file_system_context)) {
     // The context has been already initialized. Just dispatch the callback
     // with SYNC_STATUS_OK.
     ui_task_runner_->PostTask(FROM_HERE,
                               base::BindOnce(callback, SYNC_STATUS_OK));
     return;
   }
 
   StatusCallbackQueue& callback_queue =
       pending_initialize_callbacks_[file_system_context];
@@ skipping 11 matching lines @@
   io_task_runner_->PostTask(
       FROM_HERE,
       base::BindOnce(&storage::SandboxFileSystemBackendDelegate::OpenFileSystem,
                      base::Unretained(file_system_context->sandbox_delegate()),
                      source_url, storage::kFileSystemTypeSyncable,
                      storage::OPEN_FILE_SYSTEM_CREATE_IF_NONEXISTENT,
                      open_filesystem_callback, GURL()));
 }
 
 void LocalFileSyncContext::ShutdownOnUIThread() {
-  DCHECK(ui_task_runner_->RunsTasksOnCurrentThread());
+  DCHECK(ui_task_runner_->RunsTasksInCurrentSequence());
   shutdown_on_ui_ = true;
   io_task_runner_->PostTask(
       FROM_HERE,
       base::BindOnce(&LocalFileSyncContext::ShutdownOnIOThread, this));
 }
 
 void LocalFileSyncContext::GetFileForLocalSync(
     FileSystemContext* file_system_context,
     const LocalFileSyncInfoCallback& callback) {
   DCHECK(file_system_context);
-  DCHECK(ui_task_runner_->RunsTasksOnCurrentThread());
+  DCHECK(ui_task_runner_->RunsTasksInCurrentSequence());
 
   base::PostTaskAndReplyWithResult(
       file_system_context->default_file_task_runner(), FROM_HERE,
       base::Bind(&LocalFileSyncContext::GetNextURLsForSyncOnFileThread, this,
                  base::RetainedRef(file_system_context)),
       base::Bind(&LocalFileSyncContext::TryPrepareForLocalSync, this,
                  base::RetainedRef(file_system_context), callback));
 }
 
 void LocalFileSyncContext::ClearChangesForURL(
     FileSystemContext* file_system_context,
     const FileSystemURL& url,
     const base::Closure& done_callback) {
   // This is initially called on UI thread and to be relayed to FILE thread.
   DCHECK(file_system_context);
   if (!file_system_context->default_file_task_runner()->
-          RunsTasksOnCurrentThread()) {
-    DCHECK(ui_task_runner_->RunsTasksOnCurrentThread());
+          RunsTasksInCurrentSequence()) {
+    DCHECK(ui_task_runner_->RunsTasksInCurrentSequence());
     file_system_context->default_file_task_runner()->PostTask(
         FROM_HERE, base::BindOnce(&LocalFileSyncContext::ClearChangesForURL,
                                   this, base::RetainedRef(file_system_context),
                                   url, done_callback));
     return;
   }
 
   SyncFileSystemBackend* backend =
       SyncFileSystemBackend::GetBackend(file_system_context);
   DCHECK(backend);
   DCHECK(backend->change_tracker());
   backend->change_tracker()->ClearChangesForURL(url);
 
   // Call the completion callback on UI thread.
   ui_task_runner_->PostTask(FROM_HERE, done_callback);
 }
 
 void LocalFileSyncContext::FinalizeSnapshotSync(
     storage::FileSystemContext* file_system_context,
     const storage::FileSystemURL& url,
     SyncStatusCode sync_finish_status,
     const base::Closure& done_callback) {
   DCHECK(file_system_context);
   DCHECK(url.is_valid());
   if (!file_system_context->default_file_task_runner()->
-          RunsTasksOnCurrentThread()) {
+          RunsTasksInCurrentSequence()) {
     file_system_context->default_file_task_runner()->PostTask(
         FROM_HERE, base::BindOnce(&LocalFileSyncContext::FinalizeSnapshotSync,
                                   this, base::RetainedRef(file_system_context),
                                   url, sync_finish_status, done_callback));
     return;
   }
 
   SyncFileSystemBackend* backend =
       SyncFileSystemBackend::GetBackend(file_system_context);
   DCHECK(backend);
@@ skipping 44 matching lines @@
 
   done_callback.Run();
 }
 
 void LocalFileSyncContext::PrepareForSync(
     FileSystemContext* file_system_context,
     const FileSystemURL& url,
     SyncMode sync_mode,
     const LocalFileSyncInfoCallback& callback) {
   // This is initially called on UI thread and to be relayed to IO thread.
-  if (!io_task_runner_->RunsTasksOnCurrentThread()) {
-    DCHECK(ui_task_runner_->RunsTasksOnCurrentThread());
+  if (!io_task_runner_->RunsTasksInCurrentSequence()) {
+    DCHECK(ui_task_runner_->RunsTasksInCurrentSequence());
     io_task_runner_->PostTask(
         FROM_HERE, base::BindOnce(&LocalFileSyncContext::PrepareForSync, this,
                                   base::RetainedRef(file_system_context), url,
                                   sync_mode, callback));
     return;
   }
-  DCHECK(io_task_runner_->RunsTasksOnCurrentThread());
+  DCHECK(io_task_runner_->RunsTasksInCurrentSequence());
   const bool syncable = sync_status()->IsSyncable(url);
   // Disable writing if it's ready to be synced.
   if (syncable)
     sync_status()->StartSyncing(url);
   ui_task_runner_->PostTask(
       FROM_HERE,
       base::BindOnce(&LocalFileSyncContext::DidGetWritingStatusForSync, this,
                      base::RetainedRef(file_system_context),
                      syncable ? SYNC_STATUS_OK : SYNC_STATUS_FILE_BUSY, url,
                      sync_mode, callback));
 }
 
 void LocalFileSyncContext::RegisterURLForWaitingSync(
     const FileSystemURL& url,
     const base::Closure& on_syncable_callback) {
   // This is initially called on UI thread and to be relayed to IO thread.
-  if (!io_task_runner_->RunsTasksOnCurrentThread()) {
-    DCHECK(ui_task_runner_->RunsTasksOnCurrentThread());
+  if (!io_task_runner_->RunsTasksInCurrentSequence()) {
+    DCHECK(ui_task_runner_->RunsTasksInCurrentSequence());
     io_task_runner_->PostTask(
         FROM_HERE,
         base::BindOnce(&LocalFileSyncContext::RegisterURLForWaitingSync, this,
                        url, on_syncable_callback));
     return;
   }
-  DCHECK(io_task_runner_->RunsTasksOnCurrentThread());
+  DCHECK(io_task_runner_->RunsTasksInCurrentSequence());
   if (shutdown_on_io_)
     return;
   if (sync_status()->IsSyncable(url)) {
     // No need to register; fire the callback now.
     ui_task_runner_->PostTask(FROM_HERE, on_syncable_callback);
     return;
   }
   url_waiting_sync_on_io_ = url;
   url_syncable_callback_ = on_syncable_callback;
 }
 
 void LocalFileSyncContext::ApplyRemoteChange(
     FileSystemContext* file_system_context,
     const FileChange& change,
     const base::FilePath& local_path,
     const FileSystemURL& url,
     const SyncStatusCallback& callback) {
-  if (!io_task_runner_->RunsTasksOnCurrentThread()) {
-    DCHECK(ui_task_runner_->RunsTasksOnCurrentThread());
+  if (!io_task_runner_->RunsTasksInCurrentSequence()) {
+    DCHECK(ui_task_runner_->RunsTasksInCurrentSequence());
     io_task_runner_->PostTask(
         FROM_HERE, base::BindOnce(&LocalFileSyncContext::ApplyRemoteChange,
                                   this, base::RetainedRef(file_system_context),
                                   change, local_path, url, callback));
     return;
   }
-  DCHECK(io_task_runner_->RunsTasksOnCurrentThread());
+  DCHECK(io_task_runner_->RunsTasksInCurrentSequence());
   DCHECK(!sync_status()->IsWritable(url));
   DCHECK(!sync_status()->IsWriting(url));
 
   FileSystemOperation::StatusCallback operation_callback;
   switch (change.change()) {
     case FileChange::FILE_CHANGE_DELETE:
       HandleRemoteDelete(file_system_context, url, callback);
       return;
     case FileChange::FILE_CHANGE_ADD_OR_UPDATE:
       HandleRemoteAddOrUpdate(
@@ skipping 58 matching lines @@
     const SyncStatusCallback& callback,
     base::File::Error error) {
   // Remove() may fail if the target entry does not exist (which is ok),
   // so we ignore |error| here.
 
   if (shutdown_on_io_) {
     callback.Run(SYNC_FILE_ERROR_ABORT);
     return;
   }
 
-  DCHECK(io_task_runner_->RunsTasksOnCurrentThread());
+  DCHECK(io_task_runner_->RunsTasksInCurrentSequence());
   DCHECK(!sync_status()->IsWritable(url));
   DCHECK(!sync_status()->IsWriting(url));
 
   FileSystemURL url_for_sync = CreateSyncableFileSystemURLForSync(
       file_system_context, url);
   FileSystemOperation::StatusCallback operation_callback = base::Bind(
       &LocalFileSyncContext::DidApplyRemoteChange, this, url, callback);
 
   DCHECK_EQ(FileChange::FILE_CHANGE_ADD_OR_UPDATE, change.change());
   switch (change.file_type()) {
@@ skipping 29 matching lines @@
 }
 
 void LocalFileSyncContext::RecordFakeLocalChange(
     FileSystemContext* file_system_context,
     const FileSystemURL& url,
     const FileChange& change,
     const SyncStatusCallback& callback) {
   // This is called on UI thread and to be relayed to FILE thread.
   DCHECK(file_system_context);
   if (!file_system_context->default_file_task_runner()->
-          RunsTasksOnCurrentThread()) {
-    DCHECK(ui_task_runner_->RunsTasksOnCurrentThread());
+          RunsTasksInCurrentSequence()) {
+    DCHECK(ui_task_runner_->RunsTasksInCurrentSequence());
     file_system_context->default_file_task_runner()->PostTask(
         FROM_HERE, base::BindOnce(&LocalFileSyncContext::RecordFakeLocalChange,
                                   this, base::RetainedRef(file_system_context),
                                   url, change, callback));
     return;
   }
 
   SyncFileSystemBackend* backend =
       SyncFileSystemBackend::GetBackend(file_system_context);
   DCHECK(backend);
   DCHECK(backend->change_tracker());
   backend->change_tracker()->MarkDirtyOnDatabase(url);
   backend->change_tracker()->RecordChange(url, change);
 
   // Fire the callback on UI thread.
   ui_task_runner_->PostTask(FROM_HERE,
                             base::BindOnce(callback, SYNC_STATUS_OK));
 }
 
 void LocalFileSyncContext::GetFileMetadata(
     FileSystemContext* file_system_context,
     const FileSystemURL& url,
     const SyncFileMetadataCallback& callback) {
   // This is initially called on UI thread and to be relayed to IO thread.
-  if (!io_task_runner_->RunsTasksOnCurrentThread()) {
-    DCHECK(ui_task_runner_->RunsTasksOnCurrentThread());
+  if (!io_task_runner_->RunsTasksInCurrentSequence()) {
+    DCHECK(ui_task_runner_->RunsTasksInCurrentSequence());
     io_task_runner_->PostTask(
         FROM_HERE,
         base::BindOnce(&LocalFileSyncContext::GetFileMetadata, this,
                        base::RetainedRef(file_system_context), url, callback));
     return;
   }
-  DCHECK(io_task_runner_->RunsTasksOnCurrentThread());
+  DCHECK(io_task_runner_->RunsTasksInCurrentSequence());
 
   FileSystemURL url_for_sync = CreateSyncableFileSystemURLForSync(
       file_system_context, url);
   file_system_context->operation_runner()->GetMetadata(
       url_for_sync, FileSystemOperation::GET_METADATA_FIELD_IS_DIRECTORY |
                         FileSystemOperation::GET_METADATA_FIELD_SIZE |
                         FileSystemOperation::GET_METADATA_FIELD_LAST_MODIFIED,
       base::Bind(&LocalFileSyncContext::DidGetFileMetadata, this, callback));
 }
 
 void LocalFileSyncContext::HasPendingLocalChanges(
     FileSystemContext* file_system_context,
     const FileSystemURL& url,
     const HasPendingLocalChangeCallback& callback) {
   // This gets called on UI thread and relays the task on FILE thread.
   DCHECK(file_system_context);
   if (!file_system_context->default_file_task_runner()->
-          RunsTasksOnCurrentThread()) {
-    DCHECK(ui_task_runner_->RunsTasksOnCurrentThread());
+          RunsTasksInCurrentSequence()) {
+    DCHECK(ui_task_runner_->RunsTasksInCurrentSequence());
     file_system_context->default_file_task_runner()->PostTask(
         FROM_HERE,
         base::BindOnce(&LocalFileSyncContext::HasPendingLocalChanges, this,
                        base::RetainedRef(file_system_context), url, callback));
     return;
   }
 
   SyncFileSystemBackend* backend =
       SyncFileSystemBackend::GetBackend(file_system_context);
   DCHECK(backend);
   DCHECK(backend->change_tracker());
   FileChangeList changes;
   backend->change_tracker()->GetChangesForURL(url, &changes);
 
   // Fire the callback on UI thread.
   ui_task_runner_->PostTask(
       FROM_HERE, base::BindOnce(callback, SYNC_STATUS_OK, !changes.empty()));
 }
 
 void LocalFileSyncContext::PromoteDemotedChanges(
     const GURL& origin,
     storage::FileSystemContext* file_system_context,
     const base::Closure& callback) {
   // This is initially called on UI thread and to be relayed to FILE thread.
   DCHECK(file_system_context);
   if (!file_system_context->default_file_task_runner()->
-          RunsTasksOnCurrentThread()) {
-    DCHECK(ui_task_runner_->RunsTasksOnCurrentThread());
+          RunsTasksInCurrentSequence()) {
+    DCHECK(ui_task_runner_->RunsTasksInCurrentSequence());
     file_system_context->default_file_task_runner()->PostTask(
         FROM_HERE,
         base::BindOnce(&LocalFileSyncContext::PromoteDemotedChanges, this,
                        origin, base::RetainedRef(file_system_context),
                        callback));
     return;
   }
 
   SyncFileSystemBackend* backend =
       SyncFileSystemBackend::GetBackend(file_system_context);
   DCHECK(backend);
   DCHECK(backend->change_tracker());
   if (!backend->change_tracker()->PromoteDemotedChanges()) {
     ui_task_runner_->PostTask(FROM_HERE, callback);
     return;
   }
 
   io_task_runner_->PostTask(
       FROM_HERE, base::BindOnce(&LocalFileSyncContext::UpdateChangesForOrigin,
                                 this, origin, callback));
 }
 
 void LocalFileSyncContext::UpdateChangesForOrigin(
     const GURL& origin,
     const base::Closure& callback) {
-  DCHECK(io_task_runner_->RunsTasksOnCurrentThread());
+  DCHECK(io_task_runner_->RunsTasksInCurrentSequence());
   if (shutdown_on_io_)
     return;
   origins_with_pending_changes_.insert(origin);
   ScheduleNotifyChangesUpdatedOnIOThread(callback);
 }
 
 void LocalFileSyncContext::AddOriginChangeObserver(
     LocalOriginChangeObserver* observer) {
   origin_change_observers_.AddObserver(observer);
 }
 
 void LocalFileSyncContext::RemoveOriginChangeObserver(
     LocalOriginChangeObserver* observer) {
   origin_change_observers_.RemoveObserver(observer);
 }
 
 base::WeakPtr<SyncableFileOperationRunner>
 LocalFileSyncContext::operation_runner() const {
-  DCHECK(io_task_runner_->RunsTasksOnCurrentThread());
+  DCHECK(io_task_runner_->RunsTasksInCurrentSequence());
   if (operation_runner_)
     return operation_runner_->AsWeakPtr();
   return base::WeakPtr<SyncableFileOperationRunner>();
 }
 
 LocalFileSyncStatus* LocalFileSyncContext::sync_status() const {
-  DCHECK(io_task_runner_->RunsTasksOnCurrentThread());
+  DCHECK(io_task_runner_->RunsTasksInCurrentSequence());
   return sync_status_.get();
 }
 
 void LocalFileSyncContext::OnSyncEnabled(const FileSystemURL& url) {
-  DCHECK(io_task_runner_->RunsTasksOnCurrentThread());
+  DCHECK(io_task_runner_->RunsTasksInCurrentSequence());
   if (shutdown_on_io_)
     return;
   UpdateChangesForOrigin(url.origin(), NoopClosure());
   if (url_syncable_callback_.is_null() ||
       sync_status()->IsWriting(url_waiting_sync_on_io_)) {
     return;
   }
   // TODO(kinuko): may want to check how many pending tasks we have.
   ui_task_runner_->PostTask(FROM_HERE, url_syncable_callback_);
   url_syncable_callback_.Reset();
 }
 
 void LocalFileSyncContext::OnWriteEnabled(const FileSystemURL& url) {
-  DCHECK(io_task_runner_->RunsTasksOnCurrentThread());
+  DCHECK(io_task_runner_->RunsTasksInCurrentSequence());
   // Nothing to do for now.
 }
 
 LocalFileSyncContext::~LocalFileSyncContext() {
 }
 
 void LocalFileSyncContext::ScheduleNotifyChangesUpdatedOnIOThread(
     const base::Closure& callback) {
-  DCHECK(io_task_runner_->RunsTasksOnCurrentThread());
+  DCHECK(io_task_runner_->RunsTasksInCurrentSequence());
   if (shutdown_on_io_)
     return;
   pending_completion_callbacks_.push_back(callback);
   if (base::Time::Now() > last_notified_changes_ + NotifyChangesDuration()) {
     NotifyAvailableChangesOnIOThread();
   } else if (!timer_on_io_->IsRunning()) {
     timer_on_io_->Start(
         FROM_HERE, NotifyChangesDuration(),
         base::Bind(&LocalFileSyncContext::NotifyAvailableChangesOnIOThread,
                    base::Unretained(this)));
   }
 }
 
 void LocalFileSyncContext::NotifyAvailableChangesOnIOThread() {
-  DCHECK(io_task_runner_->RunsTasksOnCurrentThread());
+  DCHECK(io_task_runner_->RunsTasksInCurrentSequence());
   if (shutdown_on_io_)
     return;
 
   std::vector<base::Closure> completion_callbacks;
   completion_callbacks.swap(pending_completion_callbacks_);
 
   ui_task_runner_->PostTask(
       FROM_HERE,
       base::BindOnce(&LocalFileSyncContext::NotifyAvailableChanges, this,
                      origins_with_pending_changes_, completion_callbacks));
   last_notified_changes_ = base::Time::Now();
   origins_with_pending_changes_.clear();
 }
 
 void LocalFileSyncContext::NotifyAvailableChanges(
     const std::set<GURL>& origins,
     const std::vector<base::Closure>& callbacks) {
   for (auto& observer : origin_change_observers_)
     observer.OnChangesAvailableInOrigins(origins);
   for (const auto& callback : callbacks)
     callback.Run();
 }
 
 void LocalFileSyncContext::ShutdownOnIOThread() {
-  DCHECK(io_task_runner_->RunsTasksOnCurrentThread());
+  DCHECK(io_task_runner_->RunsTasksInCurrentSequence());
   shutdown_on_io_ = true;
   operation_runner_.reset();
   root_delete_helper_.reset();
   sync_status_.reset();
   timer_on_io_.reset();
 }
 
 void LocalFileSyncContext::InitializeFileSystemContextOnIOThread(
     const GURL& source_url,
     FileSystemContext* file_system_context,
     const GURL& /* root */,
     const std::string& /* name */,
     base::File::Error error) {
-  DCHECK(io_task_runner_->RunsTasksOnCurrentThread());
+  DCHECK(io_task_runner_->RunsTasksInCurrentSequence());
   if (shutdown_on_io_)
     error = base::File::FILE_ERROR_ABORT;
   if (error != base::File::FILE_OK) {
     DidInitialize(source_url, file_system_context,
                   FileErrorToSyncStatusCode(error));
     return;
   }
   DCHECK(file_system_context);
   SyncFileSystemBackend* backend =
       SyncFileSystemBackend::GetBackend(file_system_context);
@@ skipping 58 matching lines @@
 
   return status;
 }
 
 void LocalFileSyncContext::DidInitializeChangeTrackerOnIOThread(
     std::unique_ptr<LocalFileChangeTracker>* tracker_ptr,
     const GURL& source_url,
     FileSystemContext* file_system_context,
     std::set<GURL>* origins_with_changes,
     SyncStatusCode status) {
-  DCHECK(io_task_runner_->RunsTasksOnCurrentThread());
+  DCHECK(io_task_runner_->RunsTasksInCurrentSequence());
   DCHECK(file_system_context);
   DCHECK(origins_with_changes);
   if (shutdown_on_io_)
     status = SYNC_STATUS_ABORT;
   if (status != SYNC_STATUS_OK) {
     DidInitialize(source_url, file_system_context, status);
     return;
   }
 
   SyncFileSystemBackend* backend =
       SyncFileSystemBackend::GetBackend(file_system_context);
   DCHECK(backend);
   backend->SetLocalFileChangeTracker(std::move(*tracker_ptr));
 
   origins_with_pending_changes_.insert(origins_with_changes->begin(),
                                        origins_with_changes->end());
   ScheduleNotifyChangesUpdatedOnIOThread(NoopClosure());
 
   InitializeFileSystemContextOnIOThread(source_url, file_system_context,
                                         GURL(), std::string(),
                                         base::File::FILE_OK);
 }
 
 void LocalFileSyncContext::DidInitialize(
     const GURL& source_url,
     FileSystemContext* file_system_context,
     SyncStatusCode status) {
-  if (!ui_task_runner_->RunsTasksOnCurrentThread()) {
+  if (!ui_task_runner_->RunsTasksInCurrentSequence()) {
     ui_task_runner_->PostTask(
         FROM_HERE,
         base::BindOnce(&LocalFileSyncContext::DidInitialize, this, source_url,
                        base::RetainedRef(file_system_context), status));
     return;
   }
-  DCHECK(ui_task_runner_->RunsTasksOnCurrentThread());
+  DCHECK(ui_task_runner_->RunsTasksInCurrentSequence());
   DCHECK(!base::ContainsKey(file_system_contexts_, file_system_context));
   DCHECK(base::ContainsKey(pending_initialize_callbacks_, file_system_context));
 
   SyncFileSystemBackend* backend =
       SyncFileSystemBackend::GetBackend(file_system_context);
   DCHECK(backend);
   DCHECK(backend->change_tracker());
 
   file_system_contexts_.insert(file_system_context);
 
   StatusCallbackQueue& callback_queue =
       pending_initialize_callbacks_[file_system_context];
   for (StatusCallbackQueue::iterator iter = callback_queue.begin();
        iter != callback_queue.end(); ++iter) {
     ui_task_runner_->PostTask(FROM_HERE, base::BindOnce(*iter, status));
   }
   pending_initialize_callbacks_.erase(file_system_context);
 }
 
 std::unique_ptr<LocalFileSyncContext::FileSystemURLQueue>
 LocalFileSyncContext::GetNextURLsForSyncOnFileThread(
     FileSystemContext* file_system_context) {
   DCHECK(file_system_context);
   DCHECK(file_system_context->default_file_task_runner()->
-             RunsTasksOnCurrentThread());
+             RunsTasksInCurrentSequence());
   SyncFileSystemBackend* backend =
       SyncFileSystemBackend::GetBackend(file_system_context);
   DCHECK(backend);
   DCHECK(backend->change_tracker());
   std::unique_ptr<FileSystemURLQueue> urls(new FileSystemURLQueue);
   backend->change_tracker()->GetNextChangedURLs(
       urls.get(), kMaxURLsToFetchForLocalSync);
   for (FileSystemURLQueue::iterator iter = urls->begin();
        iter != urls->end(); ++iter)
     backend->change_tracker()->DemoteChangesForURL(*iter);
 
   return urls;
 }
 
 void LocalFileSyncContext::TryPrepareForLocalSync(
     FileSystemContext* file_system_context,
     const LocalFileSyncInfoCallback& callback,
     std::unique_ptr<FileSystemURLQueue> urls) {
-  DCHECK(ui_task_runner_->RunsTasksOnCurrentThread());
+  DCHECK(ui_task_runner_->RunsTasksInCurrentSequence());
   DCHECK(urls);
 
   if (shutdown_on_ui_) {
     callback.Run(SYNC_STATUS_ABORT, LocalFileSyncInfo(), storage::ScopedFile());
     return;
   }
 
   if (urls->empty()) {
     callback.Run(SYNC_STATUS_NO_CHANGE_TO_SYNC,
                  LocalFileSyncInfo(),
@@ skipping 10 matching lines @@
                             base::Passed(&urls), callback));
 }
 
 void LocalFileSyncContext::DidTryPrepareForLocalSync(
     FileSystemContext* file_system_context,
     std::unique_ptr<FileSystemURLQueue> remaining_urls,
     const LocalFileSyncInfoCallback& callback,
     SyncStatusCode status,
     const LocalFileSyncInfo& sync_file_info,
     storage::ScopedFile snapshot) {
-  DCHECK(ui_task_runner_->RunsTasksOnCurrentThread());
+  DCHECK(ui_task_runner_->RunsTasksInCurrentSequence());
   if (status != SYNC_STATUS_FILE_BUSY) {
     PromoteDemotedChangesForURLs(file_system_context,
                                  std::move(remaining_urls));
     callback.Run(status, sync_file_info, std::move(snapshot));
     return;
   }
 
   PromoteDemotedChangesForURL(file_system_context, sync_file_info.url);
 
   // Recursively call TryPrepareForLocalSync with remaining_urls.
   TryPrepareForLocalSync(file_system_context, callback,
                          std::move(remaining_urls));
 }
 
 void LocalFileSyncContext::PromoteDemotedChangesForURL(
     FileSystemContext* file_system_context,
     const FileSystemURL& url) {
   DCHECK(file_system_context);
   if (!file_system_context->default_file_task_runner()->
-          RunsTasksOnCurrentThread()) {
-    DCHECK(ui_task_runner_->RunsTasksOnCurrentThread());
+          RunsTasksInCurrentSequence()) {
+    DCHECK(ui_task_runner_->RunsTasksInCurrentSequence());
     if (shutdown_on_ui_)
       return;
     file_system_context->default_file_task_runner()->PostTask(
         FROM_HERE,
         base::BindOnce(&LocalFileSyncContext::PromoteDemotedChangesForURL, this,
                        base::RetainedRef(file_system_context), url));
     return;
   }
 
   SyncFileSystemBackend* backend =
       SyncFileSystemBackend::GetBackend(file_system_context);
   DCHECK(backend);
   DCHECK(backend->change_tracker());
   backend->change_tracker()->PromoteDemotedChangesForURL(url);
 }
 
 void LocalFileSyncContext::PromoteDemotedChangesForURLs(
     FileSystemContext* file_system_context,
     std::unique_ptr<FileSystemURLQueue> urls) {
   DCHECK(file_system_context);
   if (!file_system_context->default_file_task_runner()->
-          RunsTasksOnCurrentThread()) {
-    DCHECK(ui_task_runner_->RunsTasksOnCurrentThread());
+          RunsTasksInCurrentSequence()) {
+    DCHECK(ui_task_runner_->RunsTasksInCurrentSequence());
     if (shutdown_on_ui_)
       return;
     file_system_context->default_file_task_runner()->PostTask(
         FROM_HERE,
         base::BindOnce(&LocalFileSyncContext::PromoteDemotedChangesForURLs,
                        this, base::RetainedRef(file_system_context),
                        base::Passed(&urls)));
     return;
   }
 
   for (FileSystemURLQueue::iterator iter = urls->begin();
        iter != urls->end(); ++iter)
     PromoteDemotedChangesForURL(file_system_context, *iter);
 }
 
 void LocalFileSyncContext::DidGetWritingStatusForSync(
     FileSystemContext* file_system_context,
     SyncStatusCode status,
     const FileSystemURL& url,
     SyncMode sync_mode,
     const LocalFileSyncInfoCallback& callback) {
   // This gets called on UI thread and relays the task on FILE thread.
   DCHECK(file_system_context);
   if (!file_system_context->default_file_task_runner()->
-          RunsTasksOnCurrentThread()) {
-    DCHECK(ui_task_runner_->RunsTasksOnCurrentThread());
+          RunsTasksInCurrentSequence()) {
+    DCHECK(ui_task_runner_->RunsTasksInCurrentSequence());
     if (shutdown_on_ui_) {
       callback.Run(
           SYNC_STATUS_ABORT, LocalFileSyncInfo(), storage::ScopedFile());
       return;
     }
     file_system_context->default_file_task_runner()->PostTask(
         FROM_HERE,
         base::BindOnce(&LocalFileSyncContext::DidGetWritingStatusForSync, this,
                        base::RetainedRef(file_system_context), status, url,
                        sync_mode, callback));
@@ skipping 71 matching lines @@
   }
 
   ui_task_runner_->PostTask(FROM_HERE,
                             base::BindOnce(callback, status, sync_file_info,
                                            base::Passed(&snapshot)));
 }
 
 void LocalFileSyncContext::ClearSyncFlagOnIOThread(
     const FileSystemURL& url,
     bool for_snapshot_sync) {
-  DCHECK(io_task_runner_->RunsTasksOnCurrentThread());
+  DCHECK(io_task_runner_->RunsTasksInCurrentSequence());
   if (shutdown_on_io_)
     return;
   sync_status()->EndSyncing(url);
 
   if (for_snapshot_sync) {
     // The caller will hold shared lock on this one.
     sync_status()->StartWriting(url);
     return;
   }
 
   // Since a sync has finished the number of changes must have been updated.
   UpdateChangesForOrigin(url.origin(), NoopClosure());
 }
 
 void LocalFileSyncContext::FinalizeSnapshotSyncOnIOThread(
     const FileSystemURL& url) {
-  DCHECK(io_task_runner_->RunsTasksOnCurrentThread());
+  DCHECK(io_task_runner_->RunsTasksInCurrentSequence());
   if (shutdown_on_io_)
     return;
   sync_status()->EndWriting(url);
 
   // Since a sync has finished the number of changes must have been updated.
   UpdateChangesForOrigin(url.origin(), NoopClosure());
 }
 
 void LocalFileSyncContext::DidApplyRemoteChange(
     const FileSystemURL& url,
     const SyncStatusCallback& callback_on_ui,
     base::File::Error file_error) {
-  DCHECK(io_task_runner_->RunsTasksOnCurrentThread());
+  DCHECK(io_task_runner_->RunsTasksInCurrentSequence());
   root_delete_helper_.reset();
   ui_task_runner_->PostTask(
       FROM_HERE,
       base::BindOnce(callback_on_ui, FileErrorToSyncStatusCode(file_error)));
 }
 
 void LocalFileSyncContext::DidGetFileMetadata(
     const SyncFileMetadataCallback& callback,
     base::File::Error file_error,
     const base::File::Info& file_info) {
-  DCHECK(io_task_runner_->RunsTasksOnCurrentThread());
+  DCHECK(io_task_runner_->RunsTasksInCurrentSequence());
   SyncFileMetadata metadata;
   if (file_error == base::File::FILE_OK) {
     metadata.file_type = file_info.is_directory ?
         SYNC_FILE_TYPE_DIRECTORY : SYNC_FILE_TYPE_FILE;
     metadata.size = file_info.size;
     metadata.last_modified = file_info.last_modified;
   }
   ui_task_runner_->PostTask(
       FROM_HERE, base::BindOnce(callback, FileErrorToSyncStatusCode(file_error),
                                 metadata));
@@ skipping 16 matching lines @@
     return;
   }
 
   FileSystemURL url_for_sync = CreateSyncableFileSystemURLForSync(
       file_system_context, dest_url);
   file_system_context->operation_runner()->CopyInForeignFile(
       local_path, url_for_sync, callback);
 }
 
 }  // namespace sync_file_system