Rename GDataCache* to DriveCache*

chrome/browser/chromeos/gdata/drive_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/gdata/gdata_cache.h"
+#include "chrome/browser/chromeos/gdata/drive_cache.h"
 
 #include <vector>
 
 #include "base/chromeos/chromeos_version.h"
 #include "base/file_util.h"
 #include "base/logging.h"
 #include "base/path_service.h"
 #include "base/stringprintf.h"
 #include "base/string_util.h"
 #include "base/sys_info.h"
 #include "chrome/browser/chromeos/gdata/drive.pb.h"
-#include "chrome/browser/chromeos/gdata/gdata_cache_metadata.h"
+#include "chrome/browser/chromeos/gdata/drive_cache_metadata.h"
 #include "chrome/browser/chromeos/gdata/gdata_util.h"
 #include "chrome/browser/profiles/profile.h"
 #include "chrome/common/chrome_constants.h"
 #include "chrome/common/chrome_paths_internal.h"
 #include "content/public/browser/browser_thread.h"
 
 using content::BrowserThread;
 
 namespace gdata {
 namespace {
 
-const FilePath::CharType kGDataCacheVersionDir[] = FILE_PATH_LITERAL("v1");
-const FilePath::CharType kGDataCacheMetaDir[] = FILE_PATH_LITERAL("meta");
-const FilePath::CharType kGDataCachePinnedDir[] = FILE_PATH_LITERAL("pinned");
-const FilePath::CharType kGDataCacheOutgoingDir[] =
+const FilePath::CharType kDriveCacheVersionDir[] = FILE_PATH_LITERAL("v1");
+const FilePath::CharType kDriveCacheMetaDir[] = FILE_PATH_LITERAL("meta");
+const FilePath::CharType kDriveCachePinnedDir[] = FILE_PATH_LITERAL("pinned");
+const FilePath::CharType kDriveCacheOutgoingDir[] =
     FILE_PATH_LITERAL("outgoing");
-const FilePath::CharType kGDataCachePersistentDir[] =
+const FilePath::CharType kDriveCachePersistentDir[] =
     FILE_PATH_LITERAL("persistent");
-const FilePath::CharType kGDataCacheTmpDir[] = FILE_PATH_LITERAL("tmp");
-const FilePath::CharType kGDataCacheTmpDownloadsDir[] =
+const FilePath::CharType kDriveCacheTmpDir[] = FILE_PATH_LITERAL("tmp");
+const FilePath::CharType kDriveCacheTmpDownloadsDir[] =
     FILE_PATH_LITERAL("tmp/downloads");
-const FilePath::CharType kGDataCacheTmpDocumentsDir[] =
+const FilePath::CharType kDriveCacheTmpDocumentsDir[] =
     FILE_PATH_LITERAL("tmp/documents");
 
 // Used to tweak GetAmountOfFreeDiskSpace() behavior for testing.
 FreeDiskSpaceGetterInterface* global_free_disk_getter_for_testing = NULL;
 
 // Gets the amount of free disk space. Use
 // |global_free_disk_getter_for_testing| if set.
 int64 GetAmountOfFreeDiskSpace() {
   if (global_free_disk_getter_for_testing)
     return global_free_disk_getter_for_testing->AmountOfFreeDiskSpace();
@@ skipping 10 matching lines @@
 // bytes, while keeping kMinFreeSpace bytes on the disk.
 bool HasEnoughSpaceFor(int64 num_bytes) {
   int64 free_space = GetAmountOfFreeDiskSpace();
   // Subtract this as if this portion does not exist.
   free_space -= kMinFreeSpace;
   return (free_space >= num_bytes);
 }
 
 // Create cache directory paths and set permissions.
 void InitCachePaths(const std::vector<FilePath>& cache_paths) {
-  if (cache_paths.size() < GDataCache::NUM_CACHE_TYPES) {
+  if (cache_paths.size() < DriveCache::NUM_CACHE_TYPES) {
     NOTREACHED();
     LOG(ERROR) << "Size of cache_paths is invalid.";
     return;
   }
 
-  if (!GDataCache::CreateCacheDirectories(cache_paths))
+  if (!DriveCache::CreateCacheDirectories(cache_paths))
     return;
 
   // Change permissions of cache persistent directory to u+rwx,og+x (711) in
   // order to allow archive files in that directory to be mounted by cros-disks.
   file_util::SetPosixFilePermissions(
-      cache_paths[GDataCache::CACHE_TYPE_PERSISTENT],
+      cache_paths[DriveCache::CACHE_TYPE_PERSISTENT],
       file_util::FILE_PERMISSION_USER_MASK |
       file_util::FILE_PERMISSION_EXECUTE_BY_GROUP |
       file_util::FILE_PERMISSION_EXECUTE_BY_OTHERS);
 }
 
 // Remove all files under the given directory, non-recursively.
 // Do not remove recursively as we don't want to touch <gcache>/tmp/downloads,
 // which is used for user initiated downloads like "Save As"
 void RemoveAllFiles(const FilePath& directory) {
   using file_util::FileEnumerator;
@@ skipping 10 matching lines @@
 
 // Modifies cache state of file on blocking pool, which involves:
 // - moving or copying file (per |file_operation_type|) from |source_path| to
 //  |dest_path| if they're different
 // - deleting symlink if |symlink_path| is not empty
 // - creating symlink if |symlink_path| is not empty and |create_symlink| is
 //   true.
 GDataFileError ModifyCacheState(
     const FilePath& source_path,
     const FilePath& dest_path,
-    GDataCache::FileOperationType file_operation_type,
+    DriveCache::FileOperationType file_operation_type,
     const FilePath& symlink_path,
     bool create_symlink) {
   // Move or copy |source_path| to |dest_path| if they are different.
   if (source_path != dest_path) {
     bool success = false;
-    if (file_operation_type == GDataCache::FILE_OPERATION_MOVE)
+    if (file_operation_type == DriveCache::FILE_OPERATION_MOVE)
       success = file_util::Move(source_path, dest_path);
-    else if (file_operation_type == GDataCache::FILE_OPERATION_COPY)
+    else if (file_operation_type == DriveCache::FILE_OPERATION_COPY)
       success = file_util::CopyFile(source_path, dest_path);
     if (!success) {
       LOG(ERROR) << "Failed to "
-                 << (file_operation_type == GDataCache::FILE_OPERATION_MOVE ?
+                 << (file_operation_type == DriveCache::FILE_OPERATION_MOVE ?
                      "move " : "copy ")
                  << source_path.value()
                  << " to " << dest_path.value();
       return GDATA_FILE_ERROR_FAILED;
     } else {
-      DVLOG(1) << (file_operation_type == GDataCache::FILE_OPERATION_MOVE ?
+      DVLOG(1) << (file_operation_type == DriveCache::FILE_OPERATION_MOVE ?
                    "Moved " : "Copied ")
                << source_path.value()
                << " to " << dest_path.value();
     }
   } else {
     DVLOG(1) << "No need to move file: source = destination";
   }
 
   if (symlink_path.empty())
     return GDATA_FILE_OK;
@@ skipping 159 matching lines @@
     DriveCacheEntry* cache_entry) {
   DCHECK(success);
   DCHECK(cache_entry);
 
   if (!callback.is_null())
     callback.Run(*success, *cache_entry);
 }
 
 }  // namespace
 
-GDataCache::GDataCache(const FilePath& cache_root_path,
+DriveCache::DriveCache(const FilePath& cache_root_path,
                        base::SequencedTaskRunner* blocking_task_runner)
     : cache_root_path_(cache_root_path),
       cache_paths_(GetCachePaths(cache_root_path_)),
       blocking_task_runner_(blocking_task_runner),
       weak_ptr_factory_(ALLOW_THIS_IN_INITIALIZER_LIST(this)) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 }
 
-GDataCache::~GDataCache() {
+DriveCache::~DriveCache() {
   AssertOnSequencedWorkerPool();
 }
 
-FilePath GDataCache::GetCacheDirectoryPath(
+FilePath DriveCache::GetCacheDirectoryPath(
     CacheSubDirectoryType sub_dir_type) const {
   DCHECK_LE(0, sub_dir_type);
   DCHECK_GT(NUM_CACHE_TYPES, sub_dir_type);
   return cache_paths_[sub_dir_type];
 }
 
-FilePath GDataCache::GetCacheFilePath(const std::string& resource_id,
+FilePath DriveCache::GetCacheFilePath(const std::string& resource_id,
                                       const std::string& md5,
                                       CacheSubDirectoryType sub_dir_type,
                                       CachedFileOrigin file_origin) const {
   DCHECK(sub_dir_type != CACHE_TYPE_META);
 
   // Runs on any thread.
   // Filename is formatted as resource_id.md5, i.e. resource_id is the base
   // name and md5 is the extension.
   std::string base_name = util::EscapeCacheFileName(resource_id);
   if (file_origin == CACHED_FILE_LOCALLY_MODIFIED) {
     DCHECK(sub_dir_type == CACHE_TYPE_PERSISTENT);
     base_name += FilePath::kExtensionSeparator;
     base_name += util::kLocallyModifiedFileExtension;
   } else if (!md5.empty()) {
     base_name += FilePath::kExtensionSeparator;
     base_name += util::EscapeCacheFileName(md5);
   }
   // For mounted archives the filename is formatted as resource_id.md5.mounted,
   // i.e. resource_id.md5 is the base name and ".mounted" is the extension
   if (file_origin == CACHED_FILE_MOUNTED) {
     DCHECK(sub_dir_type == CACHE_TYPE_PERSISTENT);
     base_name += FilePath::kExtensionSeparator;
     base_name += util::kMountedArchiveFileExtension;
   }
   return GetCacheDirectoryPath(sub_dir_type).Append(base_name);
 }
 
-void GDataCache::AssertOnSequencedWorkerPool() {
+void DriveCache::AssertOnSequencedWorkerPool() {
   DCHECK(!blocking_task_runner_ ||
          blocking_task_runner_->RunsTasksOnCurrentThread());
 }
 
-bool GDataCache::IsUnderGDataCacheDirectory(const FilePath& path) const {
+bool DriveCache::IsUnderDriveCacheDirectory(const FilePath& path) const {
   return cache_root_path_ == path || cache_root_path_.IsParent(path);
 }
 
-void GDataCache::AddObserver(Observer* observer) {
+void DriveCache::AddObserver(Observer* observer) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   observers_.AddObserver(observer);
 }
 
-void GDataCache::RemoveObserver(Observer* observer) {
+void DriveCache::RemoveObserver(Observer* observer) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   observers_.RemoveObserver(observer);
 }
 
-void GDataCache::GetCacheEntryOnUIThread(
+void DriveCache::GetCacheEntryOnUIThread(
     const std::string& resource_id,
     const std::string& md5,
     const GetCacheEntryCallback& callback) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 
   bool* success = new bool(false);
   DriveCacheEntry* cache_entry = new DriveCacheEntry;
   blocking_task_runner_->PostTaskAndReply(
       FROM_HERE,
-      base::Bind(&GDataCache::GetCacheEntryHelper,
+      base::Bind(&DriveCache::GetCacheEntryHelper,
                  base::Unretained(this),
                  resource_id,
                  md5,
                  success,
                  cache_entry),
       base::Bind(&RunGetCacheEntryCallback,
                  callback,
                  base::Owned(success),
                  base::Owned(cache_entry)));
 }
 
-void GDataCache::GetResourceIdsOfBacklogOnUIThread(
+void DriveCache::GetResourceIdsOfBacklogOnUIThread(
     const GetResourceIdsOfBacklogCallback& callback) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 
   std::vector<std::string>* to_fetch = new std::vector<std::string>;
   std::vector<std::string>* to_upload = new std::vector<std::string>;
   blocking_task_runner_->PostTaskAndReply(
       FROM_HERE,
-      base::Bind(&GDataCache::GetResourceIdsOfBacklog,
+      base::Bind(&DriveCache::GetResourceIdsOfBacklog,
                  base::Unretained(this),
                  to_fetch,
                  to_upload),
       base::Bind(&RunGetResourceIdsOfBacklogCallback,
                  callback,
                  base::Owned(to_fetch),
                  base::Owned(to_upload)));
 }
 
-void GDataCache::GetResourceIdsOfExistingPinnedFilesOnUIThread(
+void DriveCache::GetResourceIdsOfExistingPinnedFilesOnUIThread(
     const GetResourceIdsCallback& callback) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 
   std::vector<std::string>* resource_ids = new std::vector<std::string>;
   blocking_task_runner_->PostTaskAndReply(
       FROM_HERE,
-      base::Bind(&GDataCache::GetResourceIdsOfExistingPinnedFiles,
+      base::Bind(&DriveCache::GetResourceIdsOfExistingPinnedFiles,
                  base::Unretained(this),
                  resource_ids),
       base::Bind(&RunGetResourceIdsCallback,
                  callback,
                  base::Owned(resource_ids)));
 }
 
-void GDataCache::GetResourceIdsOfAllFilesOnUIThread(
+void DriveCache::GetResourceIdsOfAllFilesOnUIThread(
     const GetResourceIdsCallback& callback) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 
   std::vector<std::string>* resource_ids = new std::vector<std::string>;
   blocking_task_runner_->PostTaskAndReply(
       FROM_HERE,
-      base::Bind(&GDataCache::GetResourceIdsOfAllFiles,
+      base::Bind(&DriveCache::GetResourceIdsOfAllFiles,
                  base::Unretained(this),
                  resource_ids),
       base::Bind(&RunGetResourceIdsCallback,
                  callback,
                  base::Owned(resource_ids)));
 }
 
-void GDataCache::FreeDiskSpaceIfNeededFor(int64 num_bytes,
+void DriveCache::FreeDiskSpaceIfNeededFor(int64 num_bytes,
                                           bool* has_enough_space) {
   AssertOnSequencedWorkerPool();
 
   // Do nothing and return if we have enough space.
   *has_enough_space = HasEnoughSpaceFor(num_bytes);
   if (*has_enough_space)
     return;
 
   // Otherwise, try to free up the disk space.
   DVLOG(1) << "Freeing up disk space for " << num_bytes;
   // First remove temporary files from the cache map.
   metadata_->RemoveTemporaryFiles();
   // Then remove all files under "tmp" directory.
-  RemoveAllFiles(GetCacheDirectoryPath(GDataCache::CACHE_TYPE_TMP));
+  RemoveAllFiles(GetCacheDirectoryPath(DriveCache::CACHE_TYPE_TMP));
 
   // Check the disk space again.
   *has_enough_space = HasEnoughSpaceFor(num_bytes);
 }
 
-void GDataCache::GetFileOnUIThread(const std::string& resource_id,
+void DriveCache::GetFileOnUIThread(const std::string& resource_id,
                                    const std::string& md5,
                                    const GetFileFromCacheCallback& callback) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 
   GDataFileError* error =
       new GDataFileError(GDATA_FILE_OK);
   FilePath* cache_file_path = new FilePath;
   blocking_task_runner_->PostTaskAndReply(
       FROM_HERE,
-      base::Bind(&GDataCache::GetFile,
+      base::Bind(&DriveCache::GetFile,
                  base::Unretained(this),
                  resource_id,
                  md5,
                  error,
                  cache_file_path),
       base::Bind(&RunGetFileFromCacheCallback,
                  callback,
                  base::Owned(error),
                  resource_id,
                  md5,
                  base::Owned(cache_file_path)));
 }
 
-void GDataCache::StoreOnUIThread(const std::string& resource_id,
+void DriveCache::StoreOnUIThread(const std::string& resource_id,
                                  const std::string& md5,
                                  const FilePath& source_path,
                                  FileOperationType file_operation_type,
                                  const CacheOperationCallback& callback) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 
   GDataFileError* error =
       new GDataFileError(GDATA_FILE_OK);
   blocking_task_runner_->PostTaskAndReply(
       FROM_HERE,
-      base::Bind(&GDataCache::Store,
+      base::Bind(&DriveCache::Store,
                  base::Unretained(this),
                  resource_id,
                  md5,
                  source_path,
                  file_operation_type,
                  error),
       base::Bind(&RunCacheOperationCallback,
                  callback,
                  base::Owned(error),
                  resource_id,
                  md5));
 }
 
-void GDataCache::PinOnUIThread(const std::string& resource_id,
+void DriveCache::PinOnUIThread(const std::string& resource_id,
                                const std::string& md5,
                                const CacheOperationCallback& callback) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 
   GDataFileError* error =
       new GDataFileError(GDATA_FILE_OK);
   blocking_task_runner_->PostTaskAndReply(
       FROM_HERE,
-      base::Bind(&GDataCache::Pin,
+      base::Bind(&DriveCache::Pin,
                  base::Unretained(this),
                  resource_id,
                  md5,
-                 GDataCache::FILE_OPERATION_MOVE,
+                 DriveCache::FILE_OPERATION_MOVE,
                  error),
-      base::Bind(&GDataCache::OnPinned,
+      base::Bind(&DriveCache::OnPinned,
                  weak_ptr_factory_.GetWeakPtr(),
                  base::Owned(error),
                  resource_id,
                  md5,
                  callback));
 }
 
-void GDataCache::UnpinOnUIThread(const std::string& resource_id,
+void DriveCache::UnpinOnUIThread(const std::string& resource_id,
                                  const std::string& md5,
                                  const CacheOperationCallback& callback) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   GDataFileError* error =
       new GDataFileError(GDATA_FILE_OK);
   blocking_task_runner_->PostTaskAndReply(
       FROM_HERE,
-      base::Bind(&GDataCache::Unpin,
+      base::Bind(&DriveCache::Unpin,
                  base::Unretained(this),
                  resource_id,
                  md5,
-                 GDataCache::FILE_OPERATION_MOVE,
+                 DriveCache::FILE_OPERATION_MOVE,
                  error),
-      base::Bind(&GDataCache::OnUnpinned,
+      base::Bind(&DriveCache::OnUnpinned,
                  weak_ptr_factory_.GetWeakPtr(),
                  base::Owned(error),
                  resource_id,
                  md5,
                  callback));
 }
 
-void GDataCache::SetMountedStateOnUIThread(
+void DriveCache::SetMountedStateOnUIThread(
     const FilePath& file_path,
     bool to_mount,
     const ChangeCacheStateCallback& callback) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 
   GDataFileError* error =
       new GDataFileError(GDATA_FILE_OK);
   FilePath* cache_file_path = new FilePath;
   blocking_task_runner_->PostTaskAndReply(
       FROM_HERE,
-      base::Bind(&GDataCache::SetMountedState,
+      base::Bind(&DriveCache::SetMountedState,
                  base::Unretained(this),
                  file_path,
                  to_mount,
                  error,
                  cache_file_path),
       base::Bind(&RunChangeCacheStateCallback,
                  callback,
                  base::Owned(error),
                  base::Owned(cache_file_path)));
 }
 
-void GDataCache::MarkDirtyOnUIThread(const std::string& resource_id,
+void DriveCache::MarkDirtyOnUIThread(const std::string& resource_id,
                                      const std::string& md5,
                                      const GetFileFromCacheCallback& callback) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 
   GDataFileError* error =
       new GDataFileError(GDATA_FILE_OK);
   FilePath* cache_file_path = new FilePath;
   blocking_task_runner_->PostTaskAndReply(
       FROM_HERE,
-      base::Bind(&GDataCache::MarkDirty,
+      base::Bind(&DriveCache::MarkDirty,
                  base::Unretained(this),
                  resource_id,
                  md5,
-                 GDataCache::FILE_OPERATION_MOVE,
+                 DriveCache::FILE_OPERATION_MOVE,
                  error,
                  cache_file_path),
       base::Bind(&RunGetFileFromCacheCallback,
                  callback,
                  base::Owned(error),
                  resource_id,
                  md5,
                  base::Owned(cache_file_path)));
 }
 
-void GDataCache::CommitDirtyOnUIThread(const std::string& resource_id,
+void DriveCache::CommitDirtyOnUIThread(const std::string& resource_id,
                                        const std::string& md5,
                                        const CacheOperationCallback& callback) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 
   GDataFileError* error = new GDataFileError(GDATA_FILE_OK);
   blocking_task_runner_->PostTaskAndReply(
       FROM_HERE,
-      base::Bind(&GDataCache::CommitDirty,
+      base::Bind(&DriveCache::CommitDirty,
                  base::Unretained(this),
                  resource_id,
                  md5,
-                 GDataCache::FILE_OPERATION_MOVE,
+                 DriveCache::FILE_OPERATION_MOVE,
                  error),
-      base::Bind(&GDataCache::OnCommitDirty,
+      base::Bind(&DriveCache::OnCommitDirty,
                  weak_ptr_factory_.GetWeakPtr(),
                  base::Owned(error),
                  resource_id,
                  md5,
                  callback));
 }
 
-void GDataCache::ClearDirtyOnUIThread(const std::string& resource_id,
+void DriveCache::ClearDirtyOnUIThread(const std::string& resource_id,
                                       const std::string& md5,
                                       const CacheOperationCallback& callback) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 
   GDataFileError* error =
       new GDataFileError(GDATA_FILE_OK);
   blocking_task_runner_->PostTaskAndReply(
       FROM_HERE,
-      base::Bind(&GDataCache::ClearDirty,
+      base::Bind(&DriveCache::ClearDirty,
                  base::Unretained(this),
                  resource_id,
                  md5,
-                 GDataCache::FILE_OPERATION_MOVE,
+                 DriveCache::FILE_OPERATION_MOVE,
                  error),
       base::Bind(&RunCacheOperationCallback,
                  callback,
                  base::Owned(error),
                  resource_id,
                  md5));
 }
 
-void GDataCache::RemoveOnUIThread(const std::string& resource_id,
+void DriveCache::RemoveOnUIThread(const std::string& resource_id,
                                   const CacheOperationCallback& callback) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 
   GDataFileError* error =
       new GDataFileError(GDATA_FILE_OK);
 
   blocking_task_runner_->PostTaskAndReply(
       FROM_HERE,
-      base::Bind(&GDataCache::Remove,
+      base::Bind(&DriveCache::Remove,
                  base::Unretained(this),
                  resource_id,
                  error),
       base::Bind(&RunCacheOperationCallback,
                  callback,
                  base::Owned(error),
                  resource_id,
                  ""  /* md5 */));
 }
 
-void GDataCache::ClearAllOnUIThread(const ChangeCacheStateCallback& callback) {
+void DriveCache::ClearAllOnUIThread(const ChangeCacheStateCallback& callback) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 
   GDataFileError* error = new GDataFileError(GDATA_FILE_OK);
 
   blocking_task_runner_->PostTaskAndReply(
       FROM_HERE,
-      base::Bind(&GDataCache::ClearAll,
+      base::Bind(&DriveCache::ClearAll,
                  base::Unretained(this),
                  error),
       base::Bind(&RunChangeCacheStateCallback,
                  callback,
                  base::Owned(error),
                  &cache_root_path_));
 }
 
-void GDataCache::RequestInitializeOnUIThread() {
+void DriveCache::RequestInitializeOnUIThread() {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 
   blocking_task_runner_->PostTask(
       FROM_HERE,
-      base::Bind(&GDataCache::Initialize, base::Unretained(this)));
+      base::Bind(&DriveCache::Initialize, base::Unretained(this)));
 }
 
-void GDataCache::RequestInitializeOnUIThreadForTesting() {
+void DriveCache::RequestInitializeOnUIThreadForTesting() {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 
   blocking_task_runner_->PostTask(
       FROM_HERE,
-      base::Bind(&GDataCache::InitializeForTesting, base::Unretained(this)));
+      base::Bind(&DriveCache::InitializeForTesting, base::Unretained(this)));
 }
 
-void GDataCache::ForceRescanOnUIThreadForTesting() {
+void DriveCache::ForceRescanOnUIThreadForTesting() {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 
   blocking_task_runner_->PostTask(
       FROM_HERE,
-      base::Bind(&GDataCache::ForceRescanForTesting, base::Unretained(this)));
+      base::Bind(&DriveCache::ForceRescanForTesting, base::Unretained(this)));
 }
 
-bool GDataCache::GetCacheEntry(const std::string& resource_id,
+bool DriveCache::GetCacheEntry(const std::string& resource_id,
                                const std::string& md5,
                                DriveCacheEntry* entry) {
   DCHECK(entry);
   AssertOnSequencedWorkerPool();
   return metadata_->GetCacheEntry(resource_id, md5, entry);
 }
 
 // static
-GDataCache* GDataCache::CreateGDataCacheOnUIThread(
+DriveCache* DriveCache::CreateDriveCacheOnUIThread(
     const FilePath& cache_root_path,
     base::SequencedTaskRunner* blocking_task_runner) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
-  return new GDataCache(cache_root_path, blocking_task_runner);
+  return new DriveCache(cache_root_path, blocking_task_runner);
 }
 
-void GDataCache::DestroyOnUIThread() {
+void DriveCache::DestroyOnUIThread() {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 
   // Invalidate the weak pointer.
   weak_ptr_factory_.InvalidateWeakPtrs();
 
   // Destroy myself on the blocking pool.
   blocking_task_runner_->PostTask(
       FROM_HERE,
-      base::Bind(&GDataCache::Destroy,
+      base::Bind(&DriveCache::Destroy,
                  base::Unretained(this)));
 }
 
-void GDataCache::Initialize() {
+void DriveCache::Initialize() {
   AssertOnSequencedWorkerPool();
 
   InitCachePaths(cache_paths_);
-  metadata_ = GDataCacheMetadata::CreateGDataCacheMetadata(
+  metadata_ = DriveCacheMetadata::CreateDriveCacheMetadata(
       blocking_task_runner_).Pass();
   metadata_->Initialize(cache_paths_);
 }
 
-void GDataCache::InitializeForTesting() {
+void DriveCache::InitializeForTesting() {
   AssertOnSequencedWorkerPool();
 
   InitCachePaths(cache_paths_);
-  metadata_ = GDataCacheMetadata::CreateGDataCacheMetadataForTesting(
+  metadata_ = DriveCacheMetadata::CreateDriveCacheMetadataForTesting(
       blocking_task_runner_).Pass();
   metadata_->Initialize(cache_paths_);
 }
 
-void GDataCache::Destroy() {
+void DriveCache::Destroy() {
   AssertOnSequencedWorkerPool();
   delete this;
 }
 
-void GDataCache::ForceRescanForTesting() {
+void DriveCache::ForceRescanForTesting() {
   AssertOnSequencedWorkerPool();
   metadata_->ForceRescanForTesting(cache_paths_);
 }
 
-void GDataCache::GetResourceIdsOfBacklog(
+void DriveCache::GetResourceIdsOfBacklog(
     std::vector<std::string>* to_fetch,
     std::vector<std::string>* to_upload) {
   AssertOnSequencedWorkerPool();
   DCHECK(to_fetch);
   DCHECK(to_upload);
 
   metadata_->Iterate(base::Bind(&CollectBacklog, to_fetch, to_upload));
 }
 
-void GDataCache::GetResourceIdsOfExistingPinnedFiles(
+void DriveCache::GetResourceIdsOfExistingPinnedFiles(
     std::vector<std::string>* resource_ids) {
   AssertOnSequencedWorkerPool();
   DCHECK(resource_ids);
 
   metadata_->Iterate(base::Bind(&CollectExistingPinnedFile, resource_ids));
 }
 
-void GDataCache::GetResourceIdsOfAllFiles(
+void DriveCache::GetResourceIdsOfAllFiles(
     std::vector<std::string>* resource_ids) {
   AssertOnSequencedWorkerPool();
   DCHECK(resource_ids);
 
   metadata_->Iterate(base::Bind(&CollectAnyFile, resource_ids));
 }
 
-void GDataCache::GetFile(const std::string& resource_id,
+void DriveCache::GetFile(const std::string& resource_id,
                          const std::string& md5,
                          GDataFileError* error,
                          FilePath* cache_file_path) {
   AssertOnSequencedWorkerPool();
   DCHECK(error);
   DCHECK(cache_file_path);
 
   DriveCacheEntry cache_entry;
   if (GetCacheEntry(resource_id, md5, &cache_entry) &&
       cache_entry.is_present()) {
     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;
     }
     *cache_file_path = GetCacheFilePath(
         resource_id,
         md5,
         GetSubDirectoryType(cache_entry),
         file_origin);
     *error = GDATA_FILE_OK;
   } else {
     *error = GDATA_FILE_ERROR_NOT_FOUND;
   }
 }
 
-void GDataCache::Store(const std::string& resource_id,
+void DriveCache::Store(const std::string& resource_id,
                        const std::string& md5,
                        const FilePath& source_path,
                        FileOperationType file_operation_type,
                        GDataFileError* error) {
   AssertOnSequencedWorkerPool();
   DCHECK(error);
 
   if (file_operation_type == FILE_OPERATION_COPY) {
     int64 file_size;
     if (!file_util::GetFileSize(source_path, &file_size)) {
@@ skipping 76 matching lines @@
 
   if (*error == GDATA_FILE_OK) {
     // Now that file operations have completed, update cache map.
     cache_entry.set_md5(md5);
     cache_entry.set_is_present(true);
     cache_entry.set_is_persistent(sub_dir_type == CACHE_TYPE_PERSISTENT);
     metadata_->AddOrUpdateCacheEntry(resource_id, cache_entry);
   }
 }
 
-void GDataCache::Pin(const std::string& resource_id,
+void DriveCache::Pin(const std::string& resource_id,
                      const std::string& md5,
                      FileOperationType file_operation_type,
                      GDataFileError* error) {
   AssertOnSequencedWorkerPool();
   DCHECK(error);
 
   FilePath source_path;
   FilePath dest_path;
   FilePath symlink_path;
   bool create_symlink = true;
@@ skipping 66 matching lines @@
 
   if (*error == GDATA_FILE_OK) {
     // Now that file operations have completed, update cache map.
     cache_entry.set_md5(md5);
     cache_entry.set_is_pinned(true);
     cache_entry.set_is_persistent(sub_dir_type == CACHE_TYPE_PERSISTENT);
     metadata_->AddOrUpdateCacheEntry(resource_id, cache_entry);
   }
 }
 
-void GDataCache::Unpin(const std::string& resource_id,
+void DriveCache::Unpin(const std::string& resource_id,
                        const std::string& md5,
                        FileOperationType file_operation_type,
                        GDataFileError* error) {
   AssertOnSequencedWorkerPool();
   DCHECK(error);
 
   // Unpinning a file means its entry must exist in cache.
   DriveCacheEntry cache_entry;
   if (!GetCacheEntry(resource_id, md5, &cache_entry)) {
     LOG(WARNING) << "Can't unpin a file that wasn't pinned or cached: res_id="
@@ skipping 64 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);
     }
   }
 }
 
-void GDataCache::SetMountedState(const FilePath& file_path,
+void DriveCache::SetMountedState(const FilePath& file_path,
                                  bool to_mount,
                                  GDataFileError *error,
                                  FilePath* cache_file_path) {
   AssertOnSequencedWorkerPool();
   DCHECK(error);
   DCHECK(cache_file_path);
 
   // Parse file path to obtain resource_id, md5 and extra_extension.
   std::string resource_id;
   std::string md5;
@@ skipping 43 matching lines @@
   *error = ModifyCacheState(source_path, *cache_file_path,
                             FILE_OPERATION_MOVE, FilePath(), false);
   if (*error == GDATA_FILE_OK) {
     // Now that cache operation is complete, update cache map
     cache_entry.set_md5(md5);
     cache_entry.set_is_persistent(dest_subdir == CACHE_TYPE_PERSISTENT);
     metadata_->AddOrUpdateCacheEntry(resource_id, cache_entry);
   }
 }
 
-void GDataCache::MarkDirty(const std::string& resource_id,
+void DriveCache::MarkDirty(const std::string& resource_id,
                            const std::string& md5,
                            FileOperationType file_operation_type,
                            GDataFileError* error,
                            FilePath* cache_file_path) {
   AssertOnSequencedWorkerPool();
   DCHECK(error);
   DCHECK(cache_file_path);
 
   // 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
@@ skipping 84 matching lines @@
 
   if (*error == GDATA_FILE_OK) {
     // Now that file operations have completed, update cache map.
     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);
   }
 }
 
-void GDataCache::CommitDirty(const std::string& resource_id,
+void DriveCache::CommitDirty(const std::string& resource_id,
                              const std::string& md5,
                              FileOperationType file_operation_type,
                              GDataFileError* error) {
   AssertOnSequencedWorkerPool();
   DCHECK(error);
 
   // 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.
@@ skipping 38 matching lines @@
   // Since there's no need to move files, use |target_path| for both
   // |source_path| and |dest_path|, because ModifyCacheState only moves files
   // if source and destination are different.
   *error = ModifyCacheState(target_path,  // source
                             target_path,  // destination
                             file_operation_type,
                             symlink_path,
                             true /* create symlink */);
 }
 
-void GDataCache::ClearDirty(const std::string& resource_id,
+void DriveCache::ClearDirty(const std::string& resource_id,
                             const std::string& md5,
                             FileOperationType file_operation_type,
                             GDataFileError* error) {
   AssertOnSequencedWorkerPool();
   DCHECK(error);
 
   // |md5| is the new .<md5> extension to rename the file to.
   // So, search for entry in cache without comparing md5.
   DriveCacheEntry cache_entry;
 
@@ skipping 68 matching lines @@
 
   if (*error == GDATA_FILE_OK) {
     // Now that file operations have completed, update cache map.
     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);
   }
 }
 
-void GDataCache::Remove(const std::string& resource_id,
+void DriveCache::Remove(const std::string& resource_id,
                         GDataFileError* error) {
   AssertOnSequencedWorkerPool();
   DCHECK(error);
 
   // 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.
   DriveCacheEntry cache_entry;
 
   // If entry doesn't exist or is dirty or mounted in cache, nothing to do.
@@ skipping 42 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 cache map.
   metadata_->RemoveCacheEntry(resource_id);
 
   *error = GDATA_FILE_OK;
 }
 
-void GDataCache::ClearAll(GDataFileError* error) {
+void DriveCache::ClearAll(GDataFileError* error) {
   AssertOnSequencedWorkerPool();
   DCHECK(error);
 
   bool success = file_util::Delete(cache_root_path_, true);
   Initialize();
 
   *error = success ? GDATA_FILE_OK : GDATA_FILE_ERROR_FAILED;
 }
 
-void GDataCache::OnPinned(GDataFileError* error,
+void DriveCache::OnPinned(GDataFileError* error,
                           const std::string& resource_id,
                           const std::string& md5,
                           const CacheOperationCallback& callback) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   DCHECK(error);
 
   if (!callback.is_null())
     callback.Run(*error, resource_id, md5);
 
   if (*error == GDATA_FILE_OK)
     FOR_EACH_OBSERVER(Observer, observers_, OnCachePinned(resource_id, md5));
 }
 
-void GDataCache::OnUnpinned(GDataFileError* error,
+void DriveCache::OnUnpinned(GDataFileError* error,
                             const std::string& resource_id,
                             const std::string& md5,
                             const CacheOperationCallback& callback) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   DCHECK(error);
 
   if (!callback.is_null())
     callback.Run(*error, resource_id, md5);
 
   if (*error == GDATA_FILE_OK)
     FOR_EACH_OBSERVER(Observer, 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.
   bool* has_enough_space = new bool(false);
   blocking_task_runner_->PostTask(
       FROM_HERE,
-      base::Bind(&GDataCache::FreeDiskSpaceIfNeededFor,
+      base::Bind(&DriveCache::FreeDiskSpaceIfNeededFor,
                  base::Unretained(this),
                  0,
                  base::Owned(has_enough_space)));
 }
 
-void GDataCache::OnCommitDirty(GDataFileError* error,
+void DriveCache::OnCommitDirty(GDataFileError* error,
                                const std::string& resource_id,
                                const std::string& md5,
                                const CacheOperationCallback& callback) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   DCHECK(error);
 
   if (!callback.is_null())
     callback.Run(*error, resource_id, md5);
 
   if (*error == GDATA_FILE_OK)
     FOR_EACH_OBSERVER(Observer, observers_, OnCacheCommitted(resource_id));
 }
 
-void GDataCache::GetCacheEntryHelper(const std::string& resource_id,
+void DriveCache::GetCacheEntryHelper(const std::string& resource_id,
                                      const std::string& md5,
                                      bool* success,
                                      DriveCacheEntry* cache_entry) {
   AssertOnSequencedWorkerPool();
   DCHECK(success);
   DCHECK(cache_entry);
 
   *success = GetCacheEntry(resource_id, md5, cache_entry);
 }
 
 // static
-FilePath GDataCache::GetCacheRootPath(Profile* profile) {
+FilePath DriveCache::GetCacheRootPath(Profile* profile) {
   FilePath cache_base_path;
   chrome::GetUserCacheDirectory(profile->GetPath(), &cache_base_path);
   FilePath cache_root_path =
-      cache_base_path.Append(chrome::kGDataCacheDirname);
-  return cache_root_path.Append(kGDataCacheVersionDir);
+      cache_base_path.Append(chrome::kDriveCacheDirname);
+  return cache_root_path.Append(kDriveCacheVersionDir);
 }
 
 // static
-std::vector<FilePath> GDataCache::GetCachePaths(
+std::vector<FilePath> DriveCache::GetCachePaths(
     const FilePath& cache_root_path) {
   std::vector<FilePath> cache_paths;
-  // The order should match GDataCache::CacheSubDirectoryType enum.
-  cache_paths.push_back(cache_root_path.Append(kGDataCacheMetaDir));
-  cache_paths.push_back(cache_root_path.Append(kGDataCachePinnedDir));
-  cache_paths.push_back(cache_root_path.Append(kGDataCacheOutgoingDir));
-  cache_paths.push_back(cache_root_path.Append(kGDataCachePersistentDir));
-  cache_paths.push_back(cache_root_path.Append(kGDataCacheTmpDir));
-  cache_paths.push_back(cache_root_path.Append(kGDataCacheTmpDownloadsDir));
-  cache_paths.push_back(cache_root_path.Append(kGDataCacheTmpDocumentsDir));
+  // The order should match DriveCache::CacheSubDirectoryType enum.
+  cache_paths.push_back(cache_root_path.Append(kDriveCacheMetaDir));
+  cache_paths.push_back(cache_root_path.Append(kDriveCachePinnedDir));
+  cache_paths.push_back(cache_root_path.Append(kDriveCacheOutgoingDir));
+  cache_paths.push_back(cache_root_path.Append(kDriveCachePersistentDir));
+  cache_paths.push_back(cache_root_path.Append(kDriveCacheTmpDir));
+  cache_paths.push_back(cache_root_path.Append(kDriveCacheTmpDownloadsDir));
+  cache_paths.push_back(cache_root_path.Append(kDriveCacheTmpDocumentsDir));
   return cache_paths;
 }
 
 // static
-bool GDataCache::CreateCacheDirectories(
+bool DriveCache::CreateCacheDirectories(
     const std::vector<FilePath>& paths_to_create) {
   bool success = true;
 
   for (size_t i = 0; i < paths_to_create.size(); ++i) {
     if (file_util::DirectoryExists(paths_to_create[i]))
       continue;
 
     if (!file_util::CreateDirectory(paths_to_create[i])) {
       // Error creating this directory, record error and proceed with next one.
       success = false;
       PLOG(ERROR) << "Error creating directory " << paths_to_create[i].value();
     } else {
       DVLOG(1) << "Created directory " << paths_to_create[i].value();
     }
   }
   return success;
 }
 
 // static
-GDataCache::CacheSubDirectoryType GDataCache::GetSubDirectoryType(
+DriveCache::CacheSubDirectoryType DriveCache::GetSubDirectoryType(
     const DriveCacheEntry& cache_entry) {
   return cache_entry.is_persistent() ? CACHE_TYPE_PERSISTENT : CACHE_TYPE_TMP;
 }
 
 void SetFreeDiskSpaceGetterForTesting(FreeDiskSpaceGetterInterface* getter) {
   delete global_free_disk_getter_for_testing;  // Safe to delete NULL;
   global_free_disk_getter_for_testing = getter;
 }
 
 }  // namespace gdata