drive: Rename FileCache methods in a blocking pool centric manner

chrome/browser/chromeos/drive/file_cache.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 "chrome/browser/chromeos/drive/file_cache.h"
 
 #include <vector>
 
 #include "base/file_util.h"
 #include "base/logging.h"
@@ skipping 231 matching lines @@
 void FileCache::AddObserver(FileCacheObserver* observer) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   observers_.AddObserver(observer);
 }
 
 void FileCache::RemoveObserver(FileCacheObserver* observer) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   observers_.RemoveObserver(observer);
 }
 
-void FileCache::GetCacheEntry(const std::string& resource_id,
-                              const std::string& md5,
-                              const GetCacheEntryCallback& callback) {
+void FileCache::GetCacheEntryOnUIThread(const std::string& resource_id,
+                                        const std::string& md5,
+                                        const GetCacheEntryCallback& callback) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   DCHECK(!callback.is_null());
 
   FileCacheEntry* cache_entry = new FileCacheEntry;
   base::PostTaskAndReplyWithResult(
       blocking_task_runner_,
       FROM_HERE,
-      base::Bind(&FileCache::GetCacheEntryOnBlockingPool,
+      base::Bind(&FileCache::GetCacheEntry,
                  base::Unretained(this), resource_id, md5, cache_entry),
       base::Bind(&RunGetCacheEntryCallback,
                  callback, base::Owned(cache_entry)));
 }
 
-void FileCache::Iterate(const CacheIterateCallback& iteration_callback,
-                        const base::Closure& completion_callback) {
+void FileCache::IterateOnUIThread(
+    const CacheIterateCallback& iteration_callback,
+    const base::Closure& completion_callback) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   DCHECK(!iteration_callback.is_null());
   DCHECK(!completion_callback.is_null());
 
   blocking_task_runner_->PostTaskAndReply(
       FROM_HERE,
-      base::Bind(&FileCache::IterateOnBlockingPool,
+      base::Bind(&FileCache::Iterate,
                  base::Unretained(this),
                  google_apis::CreateRelayCallback(iteration_callback)),
       completion_callback);
 }
 
-void FileCache::FreeDiskSpaceIfNeededFor(
+void FileCache::FreeDiskSpaceIfNeededForOnUIThread(
     int64 num_bytes,
     const InitializeCacheCallback& callback) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   DCHECK(!callback.is_null());
 
   base::PostTaskAndReplyWithResult(
       blocking_task_runner_,
       FROM_HERE,
-      base::Bind(&FileCache::FreeDiskSpaceOnBlockingPoolIfNeededFor,
+      base::Bind(&FileCache::FreeDiskSpaceIfNeededFor,
                  base::Unretained(this),
                  num_bytes),
       callback);
 }
 
-void FileCache::GetFile(const std::string& resource_id,
-                        const std::string& md5,
-                        const GetFileFromCacheCallback& callback) {
+void FileCache::GetFileOnUIThread(const std::string& resource_id,
+                                  const std::string& md5,
+                                  const GetFileFromCacheCallback& callback) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   DCHECK(!callback.is_null());
 
   base::PostTaskAndReplyWithResult(
       blocking_task_runner_,
       FROM_HERE,
-      base::Bind(&FileCache::GetFileOnBlockingPool,
+      base::Bind(&FileCache::GetFile,
                  base::Unretained(this), resource_id, md5),
       base::Bind(&RunGetFileFromCacheCallback, callback));
 }
 
-void FileCache::Store(const std::string& resource_id,
-                      const std::string& md5,
-                      const base::FilePath& source_path,
-                      FileOperationType file_operation_type,
-                      const FileOperationCallback& callback) {
+void FileCache::StoreOnUIThread(const std::string& resource_id,
+                                const std::string& md5,
+                                const base::FilePath& source_path,
+                                FileOperationType file_operation_type,
+                                const FileOperationCallback& callback) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   DCHECK(!callback.is_null());
 
   base::PostTaskAndReplyWithResult(
       blocking_task_runner_,
       FROM_HERE,
-      base::Bind(&FileCache::StoreOnBlockingPool,
+      base::Bind(&FileCache::Store,
                  base::Unretained(this),
                  resource_id, md5, source_path, file_operation_type,
                  CACHED_FILE_FROM_SERVER),
       callback);
 }
 
-void FileCache::StoreLocallyModified(
+void FileCache::StoreLocallyModifiedOnUIThread(
     const std::string& resource_id,
     const std::string& md5,
     const base::FilePath& source_path,
     FileOperationType file_operation_type,
     const FileOperationCallback& callback) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   DCHECK(!callback.is_null());
 
   base::PostTaskAndReplyWithResult(
       blocking_task_runner_,
       FROM_HERE,
-      base::Bind(&FileCache::StoreOnBlockingPool,
+      base::Bind(&FileCache::Store,
                  base::Unretained(this),
                  resource_id, md5, source_path, file_operation_type,
                  CACHED_FILE_LOCALLY_MODIFIED),
       base::Bind(&FileCache::OnCommitDirty,
                  weak_ptr_factory_.GetWeakPtr(), resource_id, callback));
 }
 
-void FileCache::Pin(const std::string& resource_id,
-                    const std::string& md5,
-                    const FileOperationCallback& callback) {
+void FileCache::PinOnUIThread(const std::string& resource_id,
+                              const std::string& md5,
+                              const FileOperationCallback& callback) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   DCHECK(!callback.is_null());
 
   base::PostTaskAndReplyWithResult(
       blocking_task_runner_,
       FROM_HERE,
-      base::Bind(&FileCache::PinOnBlockingPool,
+      base::Bind(&FileCache::Pin,
                  base::Unretained(this), resource_id, md5),
       base::Bind(&FileCache::OnPinned,
                  weak_ptr_factory_.GetWeakPtr(), resource_id, md5, callback));
 }
 
-void FileCache::Unpin(const std::string& resource_id,
-                      const std::string& md5,
-                      const FileOperationCallback& callback) {
-  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
-  DCHECK(!callback.is_null());
-
-  base::PostTaskAndReplyWithResult(
-      blocking_task_runner_,
-      FROM_HERE,
-      base::Bind(&FileCache::UnpinOnBlockingPool,
-                 base::Unretained(this), resource_id, md5),
-      base::Bind(&FileCache::OnUnpinned,
-                 weak_ptr_factory_.GetWeakPtr(), resource_id, md5, callback));
-}
-
-void FileCache::MarkAsMounted(const std::string& resource_id,
-                              const std::string& md5,
-                              const GetFileFromCacheCallback& callback) {
-  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
-  DCHECK(!callback.is_null());
-
-  base::PostTaskAndReplyWithResult(
-      blocking_task_runner_,
-      FROM_HERE,
-      base::Bind(&FileCache::MarkAsMountedOnBlockingPool,
-                 base::Unretained(this), resource_id, md5),
-      base::Bind(RunGetFileFromCacheCallback, callback));
-}
-
-void FileCache::MarkAsUnmounted(const base::FilePath& file_path,
+void FileCache::UnpinOnUIThread(const std::string& resource_id,
+                                const std::string& md5,
                                 const FileOperationCallback& callback) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   DCHECK(!callback.is_null());
 
   base::PostTaskAndReplyWithResult(
       blocking_task_runner_,
       FROM_HERE,
-      base::Bind(&FileCache::MarkAsUnmountedOnBlockingPool,
-                 base::Unretained(this), file_path),
-      callback);
+      base::Bind(&FileCache::Unpin,
+                 base::Unretained(this), resource_id, md5),
+      base::Bind(&FileCache::OnUnpinned,
+                 weak_ptr_factory_.GetWeakPtr(), resource_id, md5, callback));
 }
 
-void FileCache::MarkDirty(const std::string& resource_id,
-                          const std::string& md5,
-                          const FileOperationCallback& callback) {
+void FileCache::MarkAsMountedOnUIThread(
+    const std::string& resource_id,
+    const std::string& md5,
+    const GetFileFromCacheCallback& callback) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   DCHECK(!callback.is_null());
 
   base::PostTaskAndReplyWithResult(
       blocking_task_runner_,
       FROM_HERE,
-      base::Bind(&FileCache::MarkDirtyOnBlockingPool,
+      base::Bind(&FileCache::MarkAsMounted,
                  base::Unretained(this), resource_id, md5),
-      callback);
+      base::Bind(RunGetFileFromCacheCallback, callback));
 }
 
-void FileCache::CommitDirty(const std::string& resource_id,
-                            const std::string& md5,
-                            const FileOperationCallback& callback) {
+void FileCache::MarkAsUnmountedOnUIThread(
+    const base::FilePath& file_path,
+    const FileOperationCallback& callback) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   DCHECK(!callback.is_null());
 
   base::PostTaskAndReplyWithResult(
       blocking_task_runner_,
       FROM_HERE,
-      base::Bind(&FileCache::CommitDirtyOnBlockingPool,
-                 base::Unretained(this), resource_id, md5),
-      base::Bind(&FileCache::OnCommitDirty,
-                 weak_ptr_factory_.GetWeakPtr(), resource_id, callback));
+      base::Bind(&FileCache::MarkAsUnmounted,
+                 base::Unretained(this), file_path),
+      callback);
 }
 
-void FileCache::ClearDirty(const std::string& resource_id,
-                           const std::string& md5,
-                           const FileOperationCallback& callback) {
+void FileCache::MarkDirtyOnUIThread(const std::string& resource_id,
+                                    const std::string& md5,
+                                    const FileOperationCallback& callback) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   DCHECK(!callback.is_null());
 
   base::PostTaskAndReplyWithResult(
       blocking_task_runner_,
       FROM_HERE,
-      base::Bind(&FileCache::ClearDirtyOnBlockingPool,
+      base::Bind(&FileCache::MarkDirty,
                  base::Unretained(this), resource_id, md5),
       callback);
 }
 
-void FileCache::Remove(const std::string& resource_id,
-                       const FileOperationCallback& callback) {
+void FileCache::CommitDirtyOnUIThread(const std::string& resource_id,
+                                      const std::string& md5,
+                                      const FileOperationCallback& callback) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   DCHECK(!callback.is_null());
 
   base::PostTaskAndReplyWithResult(
       blocking_task_runner_,
       FROM_HERE,
-      base::Bind(&FileCache::RemoveOnBlockingPool,
-                 base::Unretained(this), resource_id),
-      callback);
+      base::Bind(&FileCache::CommitDirty,
+                 base::Unretained(this), resource_id, md5),
+      base::Bind(&FileCache::OnCommitDirty,
+                 weak_ptr_factory_.GetWeakPtr(), resource_id, callback));
 }
 
-void FileCache::ClearAll(const InitializeCacheCallback& callback) {
+void FileCache::ClearDirtyOnUIThread(const std::string& resource_id,
+                                     const std::string& md5,
+                                     const FileOperationCallback& callback) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   DCHECK(!callback.is_null());
 
   base::PostTaskAndReplyWithResult(
       blocking_task_runner_,
       FROM_HERE,
-      base::Bind(&FileCache::ClearAllOnBlockingPool, base::Unretained(this)),
+      base::Bind(&FileCache::ClearDirty,
+                 base::Unretained(this), resource_id, md5),
       callback);
 }
 
+void FileCache::RemoveOnUIThread(const std::string& resource_id,
+                                 const FileOperationCallback& callback) {
+  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
+  DCHECK(!callback.is_null());
+
+  base::PostTaskAndReplyWithResult(
+      blocking_task_runner_,
+      FROM_HERE,
+      base::Bind(&FileCache::Remove,
+                 base::Unretained(this), resource_id),
+      callback);
+}
+
+void FileCache::ClearAllOnUIThread(const InitializeCacheCallback& callback) {
+  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
+  DCHECK(!callback.is_null());
+
+  base::PostTaskAndReplyWithResult(
+      blocking_task_runner_,
+      FROM_HERE,
+      base::Bind(&FileCache::ClearAll, base::Unretained(this)),
+      callback);
+}
+
 void FileCache::RequestInitialize(const InitializeCacheCallback& callback) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   DCHECK(!callback.is_null());
 
   base::PostTaskAndReplyWithResult(
       blocking_task_runner_,
       FROM_HERE,
       base::Bind(&FileCache::InitializeOnBlockingPool, base::Unretained(this)),
       callback);
 }
@@ skipping 39 matching lines @@
   metadata_ = FileCacheMetadata::CreateCacheMetadataForTesting(
       blocking_task_runner_);
   metadata_->Initialize(cache_paths_);
 }
 
 void FileCache::DestroyOnBlockingPool() {
   AssertOnSequencedWorkerPool();
   delete this;
 }
 
-bool FileCache::GetCacheEntryOnBlockingPool(const std::string& resource_id,
-                                            const std::string& md5,
-                                            FileCacheEntry* entry) {
+bool FileCache::GetCacheEntry(const std::string& resource_id,
+                              const std::string& md5,
+                              FileCacheEntry* entry) {
   DCHECK(entry);
   AssertOnSequencedWorkerPool();
   return metadata_->GetCacheEntry(resource_id, md5, entry);
 }
 
-void FileCache::IterateOnBlockingPool(
-    const CacheIterateCallback& iteration_callback) {
+void FileCache::Iterate(const CacheIterateCallback& iteration_callback) {
   AssertOnSequencedWorkerPool();
   DCHECK(!iteration_callback.is_null());
 
   metadata_->Iterate(iteration_callback);
 }
 
-bool FileCache::FreeDiskSpaceOnBlockingPoolIfNeededFor(int64 num_bytes) {
+bool FileCache::FreeDiskSpaceIfNeededFor(int64 num_bytes) {
   AssertOnSequencedWorkerPool();
 
   // Do nothing and return if we have enough space.
   if (HasEnoughSpaceFor(num_bytes, cache_root_path_))
     return true;
 
   // Otherwise, try to free up the disk space.
   DVLOG(1) << "Freeing up disk space for " << num_bytes;
   // First remove temporary files from the metadata.
   metadata_->RemoveTemporaryFiles();
   // Then remove all files under "tmp" directory.
   RemoveAllFiles(GetCacheDirectoryPath(CACHE_TYPE_TMP));
 
   // Check the disk space again.
   return HasEnoughSpaceFor(num_bytes, cache_root_path_);
 }
 
-scoped_ptr<FileCache::GetFileResult> FileCache::GetFileOnBlockingPool(
+scoped_ptr<FileCache::GetFileResult> FileCache::GetFile(
     const std::string& resource_id,
     const std::string& md5) {
   AssertOnSequencedWorkerPool();
 
   scoped_ptr<GetFileResult> result(new GetFileResult);
 
   FileCacheEntry cache_entry;
-  if (!GetCacheEntryOnBlockingPool(resource_id, md5, &cache_entry) ||
+  if (!GetCacheEntry(resource_id, md5, &cache_entry) ||
       !cache_entry.is_present()) {
     result->first = FILE_ERROR_NOT_FOUND;
     return result.Pass();
   }
 
   CachedFileOrigin file_origin;
   if (cache_entry.is_mounted()) {
     file_origin = CACHED_FILE_MOUNTED;
   } else if (cache_entry.is_dirty()) {
     file_origin = CACHED_FILE_LOCALLY_MODIFIED;
   } else {
     file_origin = CACHED_FILE_FROM_SERVER;
   }
   result->first = FILE_ERROR_OK;
   result->second = GetCacheFilePath(resource_id,
                                     md5,
                                     GetSubDirectoryType(cache_entry),
                                     file_origin);
   return result.Pass();
 }
 
-FileError FileCache::StoreOnBlockingPool(
-    const std::string& resource_id,
-    const std::string& md5,
-    const base::FilePath& source_path,
-    FileOperationType file_operation_type,
-    CachedFileOrigin origin) {
+FileError FileCache::Store(const std::string& resource_id,
+                           const std::string& md5,
+                           const base::FilePath& source_path,
+                           FileOperationType file_operation_type,
+                           CachedFileOrigin origin) {
   AssertOnSequencedWorkerPool();
 
   int64 file_size = 0;
   if (file_operation_type == FILE_OPERATION_COPY) {
     if (!file_util::GetFileSize(source_path, &file_size)) {
       LOG(WARNING) << "Couldn't get file size for: " << source_path.value();
       return FILE_ERROR_FAILED;
     }
   }
-  if (!FreeDiskSpaceOnBlockingPoolIfNeededFor(file_size))
+  if (!FreeDiskSpaceIfNeededFor(file_size))
     return FILE_ERROR_NO_SPACE;
 
   FileCacheEntry cache_entry;
-  GetCacheEntryOnBlockingPool(resource_id, std::string(), &cache_entry);
+  GetCacheEntry(resource_id, std::string(), &cache_entry);
 
   CacheSubDirectoryType sub_dir_type = CACHE_TYPE_TMP;
   if (origin == CACHED_FILE_FROM_SERVER) {
     // If file is dirty or mounted, return error.
     if (cache_entry.is_dirty() || cache_entry.is_mounted()) {
       LOG(WARNING) << "Can't store a file to replace a "
                    << (cache_entry.is_dirty() ? "dirty" : "mounted")
                    << " file: res_id=" << resource_id
                    << ", md5=" << md5;
       return FILE_ERROR_IN_USE;
@@ skipping 45 matching lines @@
   if (success) {
     // Now that file operations have completed, update metadata.
     cache_entry.set_md5(md5);
     cache_entry.set_is_present(true);
     cache_entry.set_is_persistent(sub_dir_type == CACHE_TYPE_PERSISTENT);
     cache_entry.set_is_dirty(origin == CACHED_FILE_LOCALLY_MODIFIED);
     metadata_->AddOrUpdateCacheEntry(resource_id, cache_entry);
 
     // If storing a local modification, commit it.
     if (origin == CACHED_FILE_LOCALLY_MODIFIED)
-      CommitDirtyOnBlockingPool(resource_id, md5);
+      CommitDirty(resource_id, md5);
   }
 
   return success ? FILE_ERROR_OK : FILE_ERROR_FAILED;
 }
 
-FileError FileCache::PinOnBlockingPool(const std::string& resource_id,
-                                       const std::string& md5) {
+FileError FileCache::Pin(const std::string& resource_id,
+                         const std::string& md5) {
   AssertOnSequencedWorkerPool();
 
   bool is_persistent = true;
   FileCacheEntry cache_entry;
-  if (!GetCacheEntryOnBlockingPool(resource_id, md5, &cache_entry)) {
+  if (!GetCacheEntry(resource_id, md5, &cache_entry)) {
     // The file will be first downloaded in 'tmp', then moved to 'persistent'.
     is_persistent = false;
   } else {  // File exists in cache, determines destination path.
     // Determine source and destination paths.
 
     // If file is dirty or mounted, don't move it.
     if (!cache_entry.is_dirty() && !cache_entry.is_mounted()) {
       // If file was pinned before but actual file blob doesn't exist in cache:
       // - don't need to move the file.
       if (!cache_entry.is_present()) {
@@ skipping 17 matching lines @@
   }
 
   // Now that file operations have completed, update metadata.
   cache_entry.set_md5(md5);
   cache_entry.set_is_pinned(true);
   cache_entry.set_is_persistent(is_persistent);
   metadata_->AddOrUpdateCacheEntry(resource_id, cache_entry);
   return FILE_ERROR_OK;
 }
 
-FileError FileCache::UnpinOnBlockingPool(const std::string& resource_id,
-                                         const std::string& md5) {
+FileError FileCache::Unpin(const std::string& resource_id,
+                           const std::string& md5) {
   AssertOnSequencedWorkerPool();
 
   // Unpinning a file means its entry must exist in cache.
   FileCacheEntry cache_entry;
-  if (!GetCacheEntryOnBlockingPool(resource_id, md5, &cache_entry)) {
+  if (!GetCacheEntry(resource_id, md5, &cache_entry)) {
     LOG(WARNING) << "Can't unpin a file that wasn't pinned or cached: res_id="
                  << resource_id
                  << ", md5=" << md5;
     return FILE_ERROR_NOT_FOUND;
   }
 
   CacheSubDirectoryType sub_dir_type = CACHE_TYPE_TMP;
 
   // If file is dirty or mounted, don't move it.
   if (cache_entry.is_dirty() || cache_entry.is_mounted()) {
@@ skipping 26 matching lines @@
     cache_entry.set_is_pinned(false);
     cache_entry.set_is_persistent(sub_dir_type == CACHE_TYPE_PERSISTENT);
     metadata_->AddOrUpdateCacheEntry(resource_id, cache_entry);
   } else {
     // Remove the existing entry if we are unpinning a non-present file.
     metadata_->RemoveCacheEntry(resource_id);
   }
   return FILE_ERROR_OK;
 }
 
-scoped_ptr<FileCache::GetFileResult> FileCache::MarkAsMountedOnBlockingPool(
+scoped_ptr<FileCache::GetFileResult> FileCache::MarkAsMounted(
     const std::string& resource_id,
     const std::string& md5) {
   AssertOnSequencedWorkerPool();
 
   scoped_ptr<GetFileResult> result(new GetFileResult);
 
   // Get cache entry associated with the resource_id and md5
   FileCacheEntry cache_entry;
-  if (!GetCacheEntryOnBlockingPool(resource_id, md5, &cache_entry)) {
+  if (!GetCacheEntry(resource_id, md5, &cache_entry)) {
     result->first = FILE_ERROR_NOT_FOUND;
     return result.Pass();
   }
 
   if (cache_entry.is_mounted()) {
     result->first = FILE_ERROR_INVALID_OPERATION;
     return result.Pass();
   }
 
   // Get the subdir type and path for the unmounted state.
@@ skipping 23 matching lines @@
     cache_entry.set_md5(md5);
     cache_entry.set_is_mounted(true);
     cache_entry.set_is_persistent(true);
     metadata_->AddOrUpdateCacheEntry(resource_id, cache_entry);
   }
   result->first = success ? FILE_ERROR_OK : FILE_ERROR_FAILED;
   result->second = mounted_path;
   return result.Pass();
 }
 
-FileError FileCache::MarkAsUnmountedOnBlockingPool(
-    const base::FilePath& file_path) {
+FileError FileCache::MarkAsUnmounted(const base::FilePath& file_path) {
   AssertOnSequencedWorkerPool();
   DCHECK(IsUnderFileCacheDirectory(file_path));
 
   // Parse file path to obtain resource_id, md5 and extra_extension.
   std::string resource_id;
   std::string md5;
   std::string extra_extension;
   util::ParseCacheFilePath(file_path, &resource_id, &md5, &extra_extension);
   // The extra_extension shall be ".mounted" iff we're unmounting.
   DCHECK_EQ(util::kMountedArchiveFileExtension, extra_extension);
 
   // Get cache entry associated with the resource_id and md5
   FileCacheEntry cache_entry;
-  if (!GetCacheEntryOnBlockingPool(resource_id, md5, &cache_entry))
+  if (!GetCacheEntry(resource_id, md5, &cache_entry))
     return FILE_ERROR_NOT_FOUND;
 
   if (!cache_entry.is_mounted())
     return FILE_ERROR_INVALID_OPERATION;
 
   // Get the subdir type and path for the unmounted state.
   CacheSubDirectoryType unmounted_subdir =
       cache_entry.is_pinned() ? CACHE_TYPE_PERSISTENT : CACHE_TYPE_TMP;
   base::FilePath unmounted_path = GetCacheFilePath(
       resource_id, md5, unmounted_subdir, CACHED_FILE_FROM_SERVER);
 
   // Get the subdir type and path for the mounted state.
   CacheSubDirectoryType mounted_subdir = CACHE_TYPE_PERSISTENT;
   base::FilePath mounted_path = GetCacheFilePath(
       resource_id, md5, mounted_subdir, CACHED_FILE_MOUNTED);
 
   // Move cache file.
   if (!MoveFile(mounted_path, unmounted_path))
     return FILE_ERROR_FAILED;
 
   // Now that cache operation is complete, update metadata.
   cache_entry.set_md5(md5);
   cache_entry.set_is_mounted(false);
   cache_entry.set_is_persistent(unmounted_subdir == CACHE_TYPE_PERSISTENT);
   metadata_->AddOrUpdateCacheEntry(resource_id, cache_entry);
   return FILE_ERROR_OK;
 }
 
-FileError FileCache::MarkDirtyOnBlockingPool(
-    const std::string& resource_id,
-    const std::string& md5) {
+FileError FileCache::MarkDirty(const std::string& resource_id,
+                               const std::string& md5) {
   AssertOnSequencedWorkerPool();
 
   // If file has already been marked dirty in previous instance of chrome, we
   // would have lost the md5 info during cache initialization, because the file
   // would have been renamed to .local extension.
   // So, search for entry in cache without comparing md5.
 
   // Marking a file dirty means its entry and actual file blob must exist in
   // cache.
   FileCacheEntry cache_entry;
-  if (!GetCacheEntryOnBlockingPool(resource_id, std::string(), &cache_entry) ||
+  if (!GetCacheEntry(resource_id, std::string(), &cache_entry) ||
       !cache_entry.is_present()) {
     LOG(WARNING) << "Can't mark dirty a file that wasn't cached: res_id="
                  << resource_id
                  << ", md5=" << md5;
     return FILE_ERROR_NOT_FOUND;
   }
 
   // If a file is already dirty (i.e. MarkDirtyInCache was called before),
   // delete outgoing symlink if it exists.
   // TODO(benchan): We should only delete outgoing symlink if file is currently
@@ skipping 34 matching lines @@
     return FILE_ERROR_FAILED;
 
   // Now that file operations have completed, update metadata.
   cache_entry.set_md5(md5);
   cache_entry.set_is_dirty(true);
   cache_entry.set_is_persistent(sub_dir_type == CACHE_TYPE_PERSISTENT);
   metadata_->AddOrUpdateCacheEntry(resource_id, cache_entry);
   return FILE_ERROR_OK;
 }
 
-FileError FileCache::CommitDirtyOnBlockingPool(
-    const std::string& resource_id,
-    const std::string& md5) {
+FileError FileCache::CommitDirty(const std::string& resource_id,
+                                 const std::string& md5) {
   AssertOnSequencedWorkerPool();
 
   // If file has already been marked dirty in previous instance of chrome, we
   // would have lost the md5 info during cache initialization, because the file
   // would have been renamed to .local extension.
   // So, search for entry in cache without comparing md5.
 
   // Committing a file dirty means its entry and actual file blob must exist in
   // cache.
   FileCacheEntry cache_entry;
-  if (!GetCacheEntryOnBlockingPool(resource_id, std::string(), &cache_entry) ||
+  if (!GetCacheEntry(resource_id, std::string(), &cache_entry) ||
       !cache_entry.is_present()) {
     LOG(WARNING) << "Can't commit dirty a file that wasn't cached: res_id="
                  << resource_id
                  << ", md5=" << md5;
     return FILE_ERROR_NOT_FOUND;
   }
 
   // If a file is not dirty (it should have been marked dirty via
   // MarkDirtyInCache), committing it dirty is an invalid operation.
   if (!cache_entry.is_dirty()) {
@@ skipping 16 matching lines @@
   base::FilePath target_path = GetCacheFilePath(
       resource_id,
       md5,
       GetSubDirectoryType(cache_entry),
       CACHED_FILE_LOCALLY_MODIFIED);
 
   return CreateSymlink(target_path, symlink_path) ?
       FILE_ERROR_OK : FILE_ERROR_FAILED;
 }
 
-FileError FileCache::ClearDirtyOnBlockingPool(
-    const std::string& resource_id,
-    const std::string& md5) {
+FileError FileCache::ClearDirty(const std::string& resource_id,
+                                const std::string& md5) {
   AssertOnSequencedWorkerPool();
 
   // |md5| is the new .<md5> extension to rename the file to.
   // So, search for entry in cache without comparing md5.
   FileCacheEntry cache_entry;
 
   // Clearing a dirty file means its entry and actual file blob must exist in
   // cache.
-  if (!GetCacheEntryOnBlockingPool(resource_id, std::string(), &cache_entry) ||
+  if (!GetCacheEntry(resource_id, std::string(), &cache_entry) ||
       !cache_entry.is_present()) {
     LOG(WARNING) << "Can't clear dirty state of a file that wasn't cached: "
                  << "res_id=" << resource_id
                  << ", md5=" << md5;
     return FILE_ERROR_NOT_FOUND;
   }
 
   // If a file is not dirty (it should have been marked dirty via
   // MarkDirtyInCache), clearing its dirty state is an invalid operation.
   if (!cache_entry.is_dirty()) {
@@ skipping 34 matching lines @@
   DeleteSymlink(symlink_path);
 
   // Now that file operations have completed, update metadata.
   cache_entry.set_md5(md5);
   cache_entry.set_is_dirty(false);
   cache_entry.set_is_persistent(sub_dir_type == CACHE_TYPE_PERSISTENT);
   metadata_->AddOrUpdateCacheEntry(resource_id, cache_entry);
   return FILE_ERROR_OK;
 }
 
-FileError FileCache::RemoveOnBlockingPool(
-    const std::string& resource_id) {
+FileError FileCache::Remove(const std::string& resource_id) {
   AssertOnSequencedWorkerPool();
 
   // MD5 is not passed into RemoveCacheEntry because we would delete all
   // cache files corresponding to <resource_id> regardless of the md5.
   // So, search for entry in cache without taking md5 into account.
   FileCacheEntry cache_entry;
 
   // If entry doesn't exist or is dirty or mounted in cache, nothing to do.
   const bool entry_found =
-      GetCacheEntryOnBlockingPool(resource_id, std::string(), &cache_entry);
+      GetCacheEntry(resource_id, std::string(), &cache_entry);
   if (!entry_found || cache_entry.is_dirty() || cache_entry.is_mounted()) {
     DVLOG(1) << "Entry is "
              << (entry_found ?
                  (cache_entry.is_dirty() ? "dirty" : "mounted") :
                  "non-existent")
              << " in cache, not removing";
     return FILE_ERROR_OK;
   }
 
   // Determine paths to delete all cache versions of |resource_id| in
@@ skipping 22 matching lines @@
   for (size_t i = 0; i < paths_to_delete.size(); ++i) {
     DeleteFilesSelectively(paths_to_delete[i], path_to_keep);
   }
 
   // Now that all file operations have completed, remove from metadata.
   metadata_->RemoveCacheEntry(resource_id);
 
   return FILE_ERROR_OK;
 }
 
-bool FileCache::ClearAllOnBlockingPool() {
+bool FileCache::ClearAll() {
   AssertOnSequencedWorkerPool();
 
   if (!file_util::Delete(cache_root_path_, true)) {
     LOG(WARNING) << "Failed to delete the cache directory";
     return false;
   }
 
   if (!InitializeOnBlockingPool()) {
     LOG(WARNING) << "Failed to initialize the cache";
     return false;
@@ skipping 28 matching lines @@
   if (error == FILE_ERROR_OK)
     FOR_EACH_OBSERVER(FileCacheObserver,
                       observers_,
                       OnCacheUnpinned(resource_id, md5));
 
   // Now the file is moved from "persistent" to "tmp" directory.
   // It's a chance to free up space if needed.
   blocking_task_runner_->PostTask(
       FROM_HERE,
       base::Bind(
-          base::IgnoreResult(
-              &FileCache::FreeDiskSpaceOnBlockingPoolIfNeededFor),
+          base::IgnoreResult(&FileCache::FreeDiskSpaceIfNeededFor),
           base::Unretained(this), 0));
 }
 
 void FileCache::OnCommitDirty(const std::string& resource_id,
                               const FileOperationCallback& callback,
                               FileError error) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   DCHECK(!callback.is_null());
 
   callback.Run(error);
@@ skipping 52 matching lines @@
 }
 
 // static
 FileCache::CacheSubDirectoryType FileCache::GetSubDirectoryType(
     const FileCacheEntry& cache_entry) {
   return cache_entry.is_persistent() ? CACHE_TYPE_PERSISTENT : CACHE_TYPE_TMP;
 }
 
 }  // namespace internal
 }  // namespace drive