Rename TaskRunner::RunsTasksOnCurrentThread() in //storage

storage/browser/fileapi/file_system_context.cc

 // Copyright (c) 2012 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 "storage/browser/fileapi/file_system_context.h"
 
 #include <stddef.h>
 #include <stdint.h>
 
 #include <memory>
@@ skipping 190 matching lines @@
   // Additional mount points must be added before regular system-wide
   // mount points.
   if (external_mount_points)
     url_crackers_.push_back(external_mount_points);
   url_crackers_.push_back(ExternalMountPoints::GetSystemInstance());
   url_crackers_.push_back(IsolatedContext::GetInstance());
 }
 
 bool FileSystemContext::DeleteDataForOriginOnFileTaskRunner(
     const GURL& origin_url) {
-  DCHECK(default_file_task_runner()->RunsTasksOnCurrentThread());
+  DCHECK(default_file_task_runner()->RunsTasksInCurrentSequence());
   DCHECK(origin_url == origin_url.GetOrigin());
 
   bool success = true;
   for (FileSystemBackendMap::iterator iter = backend_map_.begin();
        iter != backend_map_.end();
        ++iter) {
     FileSystemBackend* backend = iter->second;
     if (!backend->GetQuotaUtil())
       continue;
     if (backend->GetQuotaUtil()->DeleteOriginDataOnFileTaskRunner(
             this, quota_manager_proxy(), origin_url, iter->first)
             != base::File::FILE_OK) {
       // Continue the loop, but record the failure.
       success = false;
     }
   }
 
   return success;
 }
 
 scoped_refptr<QuotaReservation>
 FileSystemContext::CreateQuotaReservationOnFileTaskRunner(
     const GURL& origin_url,
     FileSystemType type) {
-  DCHECK(default_file_task_runner()->RunsTasksOnCurrentThread());
+  DCHECK(default_file_task_runner()->RunsTasksInCurrentSequence());
   FileSystemBackend* backend = GetFileSystemBackend(type);
   if (!backend || !backend->GetQuotaUtil())
     return scoped_refptr<QuotaReservation>();
   return backend->GetQuotaUtil()->CreateQuotaReservationOnFileTaskRunner(
       origin_url, type);
 }
 
 void FileSystemContext::Shutdown() {
-  if (!io_task_runner_->RunsTasksOnCurrentThread()) {
+  if (!io_task_runner_->RunsTasksInCurrentSequence()) {
     io_task_runner_->PostTask(
         FROM_HERE, base::Bind(&FileSystemContext::Shutdown,
                               make_scoped_refptr(this)));
     return;
   }
   operation_runner_->Shutdown();
 }
 
 FileSystemQuotaUtil*
 FileSystemContext::GetQuotaUtil(FileSystemType type) const {
@@ skipping 75 matching lines @@
 FileSystemContext::external_backend() const {
   return static_cast<ExternalFileSystemBackend*>(
       GetFileSystemBackend(kFileSystemTypeExternal));
 }
 
 void FileSystemContext::OpenFileSystem(
     const GURL& origin_url,
     FileSystemType type,
     OpenFileSystemMode mode,
     const OpenFileSystemCallback& callback) {
-  DCHECK(io_task_runner_->RunsTasksOnCurrentThread());
+  DCHECK(io_task_runner_->RunsTasksInCurrentSequence());
   DCHECK(!callback.is_null());
 
   if (!FileSystemContext::IsSandboxFileSystem(type)) {
     // Disallow opening a non-sandboxed filesystem.
     callback.Run(GURL(), std::string(), base::File::FILE_ERROR_SECURITY);
     return;
   }
 
   FileSystemBackend* backend = GetFileSystemBackend(type);
   if (!backend) {
     callback.Run(GURL(), std::string(), base::File::FILE_ERROR_SECURITY);
     return;
   }
 
   backend->ResolveURL(
       CreateCrackedFileSystemURL(origin_url, type, base::FilePath()),
       mode,
       callback);
 }
 
 void FileSystemContext::ResolveURL(
     const FileSystemURL& url,
     const ResolveURLCallback& callback) {
   DCHECK(!callback.is_null());
 
   // If not on IO thread, forward before passing the task to the backend.
-  if (!io_task_runner_->RunsTasksOnCurrentThread()) {
+  if (!io_task_runner_->RunsTasksInCurrentSequence()) {
     ResolveURLCallback relay_callback =
         base::Bind(&RelayResolveURLCallback,
                    base::ThreadTaskRunnerHandle::Get(), callback);
     io_task_runner_->PostTask(
         FROM_HERE,
         base::Bind(&FileSystemContext::ResolveURL, this, url, relay_callback));
     return;
   }
 
   FileSystemBackend* backend = GetFileSystemBackend(url.type());
@@ skipping 26 matching lines @@
       }
     }
   }
   callback.Run(base::File::FILE_ERROR_NOT_FOUND);
 }
 
 void FileSystemContext::DeleteFileSystem(
     const GURL& origin_url,
     FileSystemType type,
     const StatusCallback& callback) {
-  DCHECK(io_task_runner_->RunsTasksOnCurrentThread());
+  DCHECK(io_task_runner_->RunsTasksInCurrentSequence());
   DCHECK(origin_url == origin_url.GetOrigin());
   DCHECK(!callback.is_null());
 
   FileSystemBackend* backend = GetFileSystemBackend(type);
   if (!backend) {
     callback.Run(base::File::FILE_ERROR_SECURITY);
     return;
   }
   if (!backend->GetQuotaUtil()) {
     callback.Run(base::File::FILE_ERROR_INVALID_OPERATION);
@@ skipping 77 matching lines @@
     OpenFileSystemMode mode,
     const StatusCallback& callback) {
   DCHECK(plugin_private_backend_);
   plugin_private_backend_->OpenPrivateFileSystem(
       origin_url, type, filesystem_id, plugin_id, mode, callback);
 }
 
 FileSystemContext::~FileSystemContext() {
 }
 
-void FileSystemContext::DeleteOnCorrectThread() const {
-  if (!io_task_runner_->RunsTasksOnCurrentThread() &&
+void FileSystemContext::DeleteOnCorrectSequence() const {
+  if (!io_task_runner_->RunsTasksInCurrentSequence() &&
       io_task_runner_->DeleteSoon(FROM_HERE, this)) {
     return;
   }
   delete this;
 }
 
 FileSystemOperation* FileSystemContext::CreateFileSystemOperation(
     const FileSystemURL& url, base::File::Error* error_code) {
   if (!url.is_valid()) {
     if (error_code)
@@ skipping 70 matching lines @@
     }
   }
 }
 
 void FileSystemContext::DidOpenFileSystemForResolveURL(
     const FileSystemURL& url,
     const FileSystemContext::ResolveURLCallback& callback,
     const GURL& filesystem_root,
     const std::string& filesystem_name,
     base::File::Error error) {
-  DCHECK(io_task_runner_->RunsTasksOnCurrentThread());
+  DCHECK(io_task_runner_->RunsTasksInCurrentSequence());
 
   if (error != base::File::FILE_OK) {
     callback.Run(error, FileSystemInfo(), base::FilePath(),
                  FileSystemContext::RESOLVED_ENTRY_NOT_FOUND);
     return;
   }
 
   storage::FileSystemInfo info(
       filesystem_name, filesystem_root, url.mount_type());
 
@@ skipping 11 matching lines @@
 
   // TODO(mtomasz): Not all fields should be required for ResolveURL.
   operation_runner()->GetMetadata(
       url, FileSystemOperation::GET_METADATA_FIELD_IS_DIRECTORY |
                FileSystemOperation::GET_METADATA_FIELD_SIZE |
                FileSystemOperation::GET_METADATA_FIELD_LAST_MODIFIED,
       base::Bind(&DidGetMetadataForResolveURL, path, callback, info));
 }
 
 }  // namespace storage