Rename TaskRunner::RunsTasksOnCurrentThread() in //storage

storage/browser/fileapi/plugin_private_file_system_backend.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/plugin_private_file_system_backend.h"
 
 #include <stdint.h>
 
 #include <map>
 #include <memory>
@@ skipping 19 matching lines @@
 
 namespace storage {
 
 class PluginPrivateFileSystemBackend::FileSystemIDToPluginMap {
  public:
   explicit FileSystemIDToPluginMap(base::SequencedTaskRunner* task_runner)
       : task_runner_(task_runner) {}
   ~FileSystemIDToPluginMap() {}
 
   std::string GetPluginIDForURL(const FileSystemURL& url) {
-    DCHECK(task_runner_->RunsTasksOnCurrentThread());
+    DCHECK(task_runner_->RunsTasksInCurrentSequence());
     Map::iterator found = map_.find(url.filesystem_id());
     if (url.type() != kFileSystemTypePluginPrivate || found == map_.end()) {
       NOTREACHED() << "Unsupported url is given: " << url.DebugString();
       return std::string();
     }
     return found->second;
   }
 
   void RegisterFileSystem(const std::string& filesystem_id,
                           const std::string& plugin_id) {
-    DCHECK(task_runner_->RunsTasksOnCurrentThread());
+    DCHECK(task_runner_->RunsTasksInCurrentSequence());
     DCHECK(!filesystem_id.empty());
     DCHECK(!base::ContainsKey(map_, filesystem_id)) << filesystem_id;
     map_[filesystem_id] = plugin_id;
   }
 
   void RemoveFileSystem(const std::string& filesystem_id) {
-    DCHECK(task_runner_->RunsTasksOnCurrentThread());
+    DCHECK(task_runner_->RunsTasksInCurrentSequence());
     map_.erase(filesystem_id);
   }
 
  private:
   typedef std::map<std::string, std::string> Map;
   scoped_refptr<base::SequencedTaskRunner> task_runner_;
   Map map_;
 };
 
 namespace {
@@ skipping 37 matching lines @@
           special_storage_policy,
           base_path_, file_system_options.env_override(),
           file_task_runner,
           base::Bind(&FileSystemIDToPluginMap::GetPluginIDForURL,
                      base::Owned(plugin_map_)),
           std::set<std::string>(),
           NULL)));
 }
 
 PluginPrivateFileSystemBackend::~PluginPrivateFileSystemBackend() {
-  if (!file_task_runner_->RunsTasksOnCurrentThread()) {
+  if (!file_task_runner_->RunsTasksInCurrentSequence()) {
     AsyncFileUtil* file_util = file_util_.release();
     if (!file_task_runner_->DeleteSoon(FROM_HERE, file_util))
       delete file_util;
   }
 }
 
 void PluginPrivateFileSystemBackend::OpenPrivateFileSystem(
     const GURL& origin_url,
     FileSystemType type,
     const std::string& filesystem_id,
@@ skipping 134 matching lines @@
   while (!(origin = enumerator->Next()).is_empty()) {
     if (host == net::GetHostOrSpecFromURL(origin))
       origins->insert(origin);
   }
 }
 
 int64_t PluginPrivateFileSystemBackend::GetOriginUsageOnFileTaskRunner(
     FileSystemContext* context,
     const GURL& origin_url,
     FileSystemType type) {
-  DCHECK(file_task_runner_->RunsTasksOnCurrentThread());
+  DCHECK(file_task_runner_->RunsTasksInCurrentSequence());
 
   if (!CanHandleType(type))
     return 0;
 
   int64_t total_size;
   base::Time last_modified_time;
   GetOriginDetailsOnFileTaskRunner(context, origin_url, &total_size,
                                    &last_modified_time);
   return total_size;
 }
 
 void PluginPrivateFileSystemBackend::GetOriginDetailsOnFileTaskRunner(
     FileSystemContext* context,
     const GURL& origin_url,
     int64_t* total_size,
     base::Time* last_modified_time) {
-  DCHECK(file_task_runner_->RunsTasksOnCurrentThread());
+  DCHECK(file_task_runner_->RunsTasksInCurrentSequence());
 
   *total_size = 0;
   *last_modified_time = base::Time::UnixEpoch();
   std::string fsid =
       storage::IsolatedContext::GetInstance()->RegisterFileSystemForVirtualPath(
           storage::kFileSystemTypePluginPrivate, "pluginprivate",
           base::FilePath());
   DCHECK(storage::ValidateIsolatedFileSystemId(fsid));
 
   std::string root = storage::GetIsolatedFileSystemRootURIString(
@@ skipping 63 matching lines @@
     FileSystemType type) const {
   return NULL;
 }
 
 ObfuscatedFileUtil* PluginPrivateFileSystemBackend::obfuscated_file_util() {
   return static_cast<ObfuscatedFileUtil*>(
       static_cast<AsyncFileUtilAdapter*>(file_util_.get())->sync_file_util());
 }
 
 }  // namespace storage