FileAPI: Rename *OnFileThread to *OnFileTaskRunner

webkit/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 "webkit/browser/fileapi/plugin_private_file_system_backend.h"
 
 #include <map>
 
 #include "base/stl_util.h"
 #include "base/synchronization/lock.h"
@@ skipping 48 matching lines @@
   Map map_;
 };
 
 namespace {
 
 const base::FilePath::CharType* kFileSystemDirectory =
     SandboxFileSystemBackendDelegate::kFileSystemDirectory;
 const base::FilePath::CharType* kPluginPrivateDirectory =
     FILE_PATH_LITERAL("Plugins");
 
-base::PlatformFileError OpenFileSystemOnFileThread(
+base::PlatformFileError OpenFileSystemOnFileTaskRunner(
     ObfuscatedFileUtil* file_util,
     PluginPrivateFileSystemBackend::FileSystemIDToPluginMap* plugin_map,
     const GURL& origin_url,
     const std::string& filesystem_id,
     const std::string& plugin_id,
     OpenFileSystemMode mode) {
   base::PlatformFileError error = base::PLATFORM_FILE_ERROR_FAILED;
   const bool create = (mode == OPEN_FILE_SYSTEM_CREATE_IF_NONEXISTENT);
   file_util->GetDirectoryForOriginAndType(
       origin_url, plugin_id, create, &error);
@@ skipping 43 matching lines @@
     const StatusCallback& callback) {
   if (!CanHandleType(type) || file_system_options_.is_incognito()) {
     base::MessageLoopProxy::current()->PostTask(
         FROM_HERE, base::Bind(callback, base::PLATFORM_FILE_ERROR_SECURITY));
     return;
   }
 
   PostTaskAndReplyWithResult(
       file_task_runner_.get(),
       FROM_HERE,
-      base::Bind(&OpenFileSystemOnFileThread,
+      base::Bind(&OpenFileSystemOnFileTaskRunner,
                  obfuscated_file_util(), plugin_map_,
                  origin_url, filesystem_id, plugin_id, mode),
       callback);
 }
 
 bool PluginPrivateFileSystemBackend::CanHandleType(FileSystemType type) const {
   return type == kFileSystemTypePluginPrivate;
 }
 
 void PluginPrivateFileSystemBackend::Initialize(FileSystemContext* context) {
@@ skipping 50 matching lines @@
     int64 offset,
     FileSystemContext* context) const {
   return scoped_ptr<FileStreamWriter>();
 }
 
 FileSystemQuotaUtil* PluginPrivateFileSystemBackend::GetQuotaUtil() {
   return this;
 }
 
 base::PlatformFileError
-PluginPrivateFileSystemBackend::DeleteOriginDataOnFileThread(
+PluginPrivateFileSystemBackend::DeleteOriginDataOnFileTaskRunner(
     FileSystemContext* context,
     quota::QuotaManagerProxy* proxy,
     const GURL& origin_url,
     FileSystemType type) {
   if (!CanHandleType(type))
     return base::PLATFORM_FILE_ERROR_SECURITY;
   bool result = obfuscated_file_util()->DeleteDirectoryForOriginAndType(
       origin_url, std::string());
   if (result)
     return base::PLATFORM_FILE_OK;
   return base::PLATFORM_FILE_ERROR_FAILED;
 }
 
-void PluginPrivateFileSystemBackend::GetOriginsForTypeOnFileThread(
+void PluginPrivateFileSystemBackend::GetOriginsForTypeOnFileTaskRunner(
     FileSystemType type,
     std::set<GURL>* origins) {
   if (!CanHandleType(type))
     return;
   scoped_ptr<ObfuscatedFileUtil::AbstractOriginEnumerator> enumerator(
       obfuscated_file_util()->CreateOriginEnumerator());
   GURL origin;
   while (!(origin = enumerator->Next()).is_empty())
     origins->insert(origin);
 }
 
-void PluginPrivateFileSystemBackend::GetOriginsForHostOnFileThread(
+void PluginPrivateFileSystemBackend::GetOriginsForHostOnFileTaskRunner(
     FileSystemType type,
     const std::string& host,
     std::set<GURL>* origins) {
   if (!CanHandleType(type))
     return;
   scoped_ptr<ObfuscatedFileUtil::AbstractOriginEnumerator> enumerator(
       obfuscated_file_util()->CreateOriginEnumerator());
   GURL origin;
   while (!(origin = enumerator->Next()).is_empty()) {
     if (host == net::GetHostOrSpecFromURL(origin))
       origins->insert(origin);
   }
 }
 
-int64 PluginPrivateFileSystemBackend::GetOriginUsageOnFileThread(
+int64 PluginPrivateFileSystemBackend::GetOriginUsageOnFileTaskRunner(
     FileSystemContext* context,
     const GURL& origin_url,
     FileSystemType type) {
   // We don't track usage on this filesystem.
   return 0;
 }
 
 scoped_refptr<QuotaReservation>
 PluginPrivateFileSystemBackend::CreateQuotaReservationOnFileTaskRunner(
     const GURL& origin_url,
@@ skipping 32 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 fileapi