Rename TaskRunner::RunsTasksOnCurrentThread() in //storage

storage/browser/fileapi/sandbox_file_system_backend_delegate.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 "storage/browser/fileapi/sandbox_file_system_backend_delegate.h"
 
 #include <stddef.h>
 #include <stdint.h>
 
 #include <memory>
@@ skipping 185 matching lines @@
           std::unique_ptr<QuotaReservationManager::QuotaBackend>(
               new QuotaBackendImpl(file_task_runner_.get(),
                                    obfuscated_file_util(),
                                    usage_cache(),
                                    quota_manager_proxy)))),
       special_storage_policy_(special_storage_policy),
       file_system_options_(file_system_options),
       is_filesystem_opened_(false),
       weak_factory_(this) {
   // Prepopulate database only if it can run asynchronously (i.e. the current
-  // thread is not file_task_runner). Usually this is the case but may not
+  // sequence is not file_task_runner). Usually this is the case but may not
   // in test code.
   if (!file_system_options.is_incognito() &&
-      !file_task_runner_->RunsTasksOnCurrentThread()) {
+      !file_task_runner_->RunsTasksInCurrentSequence()) {
     std::vector<std::string> types_to_prepopulate(
         &kPrepopulateTypes[0],
         &kPrepopulateTypes[arraysize(kPrepopulateTypes)]);
     file_task_runner_->PostTask(
         FROM_HERE,
         base::Bind(&ObfuscatedFileUtil::MaybePrepopulateDatabase,
                   base::Unretained(obfuscated_file_util()),
                   types_to_prepopulate));
   }
 }
 
 SandboxFileSystemBackendDelegate::~SandboxFileSystemBackendDelegate() {
   io_thread_checker_.DetachFromThread();
 
-  if (!file_task_runner_->RunsTasksOnCurrentThread()) {
+  if (!file_task_runner_->RunsTasksInCurrentSequence()) {
     DeleteSoon(file_task_runner_.get(), quota_reservation_manager_.release());
     DeleteSoon(file_task_runner_.get(), sandbox_file_util_.release());
     DeleteSoon(file_task_runner_.get(), quota_observer_.release());
     DeleteSoon(file_task_runner_.get(), file_system_usage_cache_.release());
   }
 }
 
 SandboxFileSystemBackendDelegate::OriginEnumerator*
 SandboxFileSystemBackendDelegate::CreateOriginEnumerator() {
   return new ObfuscatedOriginEnumerator(obfuscated_file_util());
@@ skipping 89 matching lines @@
   return std::unique_ptr<FileStreamWriter>(
       new SandboxFileStreamWriter(context, url, offset, *observers));
 }
 
 base::File::Error
 SandboxFileSystemBackendDelegate::DeleteOriginDataOnFileTaskRunner(
     FileSystemContext* file_system_context,
     storage::QuotaManagerProxy* proxy,
     const GURL& origin_url,
     FileSystemType type) {
-  DCHECK(file_task_runner_->RunsTasksOnCurrentThread());
+  DCHECK(file_task_runner_->RunsTasksInCurrentSequence());
   int64_t usage =
       GetOriginUsageOnFileTaskRunner(file_system_context, origin_url, type);
   usage_cache()->CloseCacheFiles();
   bool result = obfuscated_file_util()->DeleteDirectoryForOriginAndType(
       origin_url, GetTypeString(type));
   if (result && proxy) {
     proxy->NotifyStorageModified(storage::QuotaClient::kFileSystem,
                                  origin_url,
                                  FileSystemTypeToQuotaStorageType(type),
                                  -usage);
   }
 
   if (result)
     return base::File::FILE_OK;
   return base::File::FILE_ERROR_FAILED;
 }
 
 void SandboxFileSystemBackendDelegate::GetOriginsForTypeOnFileTaskRunner(
     FileSystemType type, std::set<GURL>* origins) {
-  DCHECK(file_task_runner_->RunsTasksOnCurrentThread());
+  DCHECK(file_task_runner_->RunsTasksInCurrentSequence());
   DCHECK(origins);
   std::unique_ptr<OriginEnumerator> enumerator(CreateOriginEnumerator());
   GURL origin;
   while (!(origin = enumerator->Next()).is_empty()) {
     if (enumerator->HasFileSystemType(type))
       origins->insert(origin);
   }
   switch (type) {
     case kFileSystemTypeTemporary:
       UMA_HISTOGRAM_COUNTS(kTemporaryOriginsCountLabel, origins->size());
       break;
     case kFileSystemTypePersistent:
       UMA_HISTOGRAM_COUNTS(kPersistentOriginsCountLabel, origins->size());
       break;
     default:
       break;
   }
 }
 
 void SandboxFileSystemBackendDelegate::GetOriginsForHostOnFileTaskRunner(
     FileSystemType type, const std::string& host,
     std::set<GURL>* origins) {
-  DCHECK(file_task_runner_->RunsTasksOnCurrentThread());
+  DCHECK(file_task_runner_->RunsTasksInCurrentSequence());
   DCHECK(origins);
   std::unique_ptr<OriginEnumerator> enumerator(CreateOriginEnumerator());
   GURL origin;
   while (!(origin = enumerator->Next()).is_empty()) {
     if (host == net::GetHostOrSpecFromURL(origin) &&
         enumerator->HasFileSystemType(type))
       origins->insert(origin);
   }
 }
 
 int64_t SandboxFileSystemBackendDelegate::GetOriginUsageOnFileTaskRunner(
     FileSystemContext* file_system_context,
     const GURL& origin_url,
     FileSystemType type) {
-  DCHECK(file_task_runner_->RunsTasksOnCurrentThread());
+  DCHECK(file_task_runner_->RunsTasksInCurrentSequence());
 
   // Don't use usage cache and return recalculated usage for sticky invalidated
   // origins.
   if (base::ContainsKey(sticky_dirty_origins_,
                         std::make_pair(origin_url, type)))
     return RecalculateUsage(file_system_context, origin_url, type);
 
   base::FilePath base_path =
       GetBaseDirectoryForOriginAndType(origin_url, type, false);
   if (base_path.empty() || !base::DirectoryExists(base_path))
@@ skipping 20 matching lines @@
 
   // This clears the dirty flag too.
   usage_cache()->UpdateUsage(usage_file_path, usage);
   return usage;
 }
 
 scoped_refptr<QuotaReservation>
 SandboxFileSystemBackendDelegate::CreateQuotaReservationOnFileTaskRunner(
     const GURL& origin,
     FileSystemType type) {
-  DCHECK(file_task_runner_->RunsTasksOnCurrentThread());
+  DCHECK(file_task_runner_->RunsTasksInCurrentSequence());
   DCHECK(quota_reservation_manager_);
   return quota_reservation_manager_->CreateReservation(origin, type);
 }
 
 void SandboxFileSystemBackendDelegate::AddFileUpdateObserver(
     FileSystemType type,
     FileUpdateObserver* observer,
     base::SequencedTaskRunner* task_runner) {
   DCHECK(!is_filesystem_opened_ || io_thread_checker_.CalledOnValidThread());
   update_observers_[type] =
@@ skipping 207 matching lines @@
       REPORT(kUnknownError);
       break;
   }
 #undef REPORT
 }
 
 void SandboxFileSystemBackendDelegate::CopyFileSystem(
     const GURL& origin_url,
     FileSystemType type,
     SandboxFileSystemBackendDelegate* destination) {
-  DCHECK(file_task_runner()->RunsTasksOnCurrentThread());
+  DCHECK(file_task_runner()->RunsTasksInCurrentSequence());
 
   base::FilePath base_path =
       GetBaseDirectoryForOriginAndType(origin_url, type, false /* create */);
   if (base::PathExists(base_path)) {
     // Delete any existing file system directories in the destination. A
     // previously failed migration
     // may have left behind partially copied directories.
     base::FilePath dest_path = destination->GetBaseDirectoryForOriginAndType(
         origin_url, type, false /* create */);
 
@@ skipping 24 matching lines @@
   return new ObfuscatedFileUtil(special_storage_policy,
                                 file_system_directory,
                                 env_override,
                                 file_task_runner,
                                 base::Bind(&GetTypeStringForURL),
                                 GetKnownTypeStrings(),
                                 NULL);
 }
 
 }  // namespace storage