Rename GDataErrorCode to DriveErrorCode, GDataFileError to DriveFileError

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/drive_cache.h"
 
 #include <vector>
 
 #include "base/chromeos/chromeos_version.h"
 #include "base/file_util.h"
@@ skipping 89 matching lines @@
       LOG(WARNING) << "Failed to delete " << file_path.value();
   }
 }
 
 // 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(
+DriveFileError ModifyCacheState(
     const FilePath& source_path,
     const FilePath& dest_path,
     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 == DriveCache::FILE_OPERATION_MOVE)
       success = file_util::Move(source_path, dest_path);
     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 == DriveCache::FILE_OPERATION_MOVE ?
                      "move " : "copy ")
                  << source_path.value()
                  << " to " << dest_path.value();
-      return GDATA_FILE_ERROR_FAILED;
+      return DRIVE_FILE_ERROR_FAILED;
     } else {
       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;
+    return DRIVE_FILE_OK;
 
   // Remove symlink regardless of |create_symlink| because creating a link will
   // not overwrite an existing one.
   // We try to save one file operation by not checking if link exists before
   // deleting it, so unlink may return error if link doesn't exist, but it
   // doesn't really matter to us.
   file_util::Delete(symlink_path, false);
 
   if (!create_symlink)
-    return GDATA_FILE_OK;
+    return DRIVE_FILE_OK;
 
   // Create new symlink to |dest_path|.
   if (!file_util::CreateSymbolicLink(dest_path, symlink_path)) {
     LOG(ERROR) << "Failed to create a symlink from " << symlink_path.value()
                << " to " << dest_path.value();
-    return GDATA_FILE_ERROR_FAILED;
+    return DRIVE_FILE_ERROR_FAILED;
   }
 
-  return GDATA_FILE_OK;
+  return DRIVE_FILE_OK;
 }
 
 // Deletes all files that match |path_to_delete_pattern| except for
 // |path_to_keep| on blocking pool.
 // If |path_to_keep| is empty, all files in |path_to_delete_pattern| are
 // deleted.
 void DeleteFilesSelectively(const FilePath& path_to_delete_pattern,
                             const FilePath& path_to_keep) {
   // Enumerate all files in directory of |path_to_delete_pattern| that match
   // base name of |path_to_delete_pattern|.
@@ skipping 51 matching lines @@
                     const std::string& resource_id,
                     const DriveCacheEntry& /* cache_entry */) {
   DCHECK(resource_ids);
 
   resource_ids->push_back(resource_id);
 }
 
 // Runs callback with pointers dereferenced.
 // Used to implement SetMountedStateOnUIThread and ClearAllOnUIThread.
 void RunChangeCacheStateCallback(const ChangeCacheStateCallback& callback,
-                                 const GDataFileError* error,
+                                 const DriveFileError* error,
                                  const FilePath* cache_file_path) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   DCHECK(error);
   DCHECK(cache_file_path);
 
   if (!callback.is_null())
     callback.Run(*error, *cache_file_path);
 }
 
 // Runs callback with pointers dereferenced.
 // Used to implement *OnUIThread methods.
 void RunCacheOperationCallback(const CacheOperationCallback& callback,
-                               GDataFileError* error,
+                               DriveFileError* error,
                                const std::string& resource_id,
                                const std::string& md5) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   DCHECK(error);
 
   if (!callback.is_null())
     callback.Run(*error, resource_id, md5);
 }
 
 // Runs callback with pointers dereferenced.
 // Used to implement *OnUIThread methods.
 void RunGetFileFromCacheCallback(const GetFileFromCacheCallback& callback,
-                                 GDataFileError* error,
+                                 DriveFileError* error,
                                  const std::string& resource_id,
                                  const std::string& md5,
                                  FilePath* cache_file_path) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   DCHECK(error);
   DCHECK(cache_file_path);
 
   if (!callback.is_null())
     callback.Run(*error, resource_id, md5, *cache_file_path);
 }
@@ skipping 194 matching lines @@
 
   // Check the disk space again.
   *has_enough_space = HasEnoughSpaceFor(num_bytes);
 }
 
 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);
+  DriveFileError* error = new DriveFileError(DRIVE_FILE_OK);
   FilePath* cache_file_path = new FilePath;
   blocking_task_runner_->PostTaskAndReply(
       FROM_HERE,
       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 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);
+  DriveFileError* error = new DriveFileError(DRIVE_FILE_OK);
   blocking_task_runner_->PostTaskAndReply(
       FROM_HERE,
       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 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);
+  DriveFileError* error = new DriveFileError(DRIVE_FILE_OK);
   blocking_task_runner_->PostTaskAndReply(
       FROM_HERE,
       base::Bind(&DriveCache::Pin,
                  base::Unretained(this),
                  resource_id,
                  md5,
                  DriveCache::FILE_OPERATION_MOVE,
                  error),
       base::Bind(&DriveCache::OnPinned,
                  weak_ptr_factory_.GetWeakPtr(),
                  base::Owned(error),
                  resource_id,
                  md5,
                  callback));
 }
 
 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);
+  DriveFileError* error = new DriveFileError(DRIVE_FILE_OK);
   blocking_task_runner_->PostTaskAndReply(
       FROM_HERE,
       base::Bind(&DriveCache::Unpin,
                  base::Unretained(this),
                  resource_id,
                  md5,
                  DriveCache::FILE_OPERATION_MOVE,
                  error),
       base::Bind(&DriveCache::OnUnpinned,
                  weak_ptr_factory_.GetWeakPtr(),
                  base::Owned(error),
                  resource_id,
                  md5,
                  callback));
 }
 
 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);
+  DriveFileError* error = new DriveFileError(DRIVE_FILE_OK);
   FilePath* cache_file_path = new FilePath;
   blocking_task_runner_->PostTaskAndReply(
       FROM_HERE,
       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 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);
+  DriveFileError* error = new DriveFileError(DRIVE_FILE_OK);
   FilePath* cache_file_path = new FilePath;
   blocking_task_runner_->PostTaskAndReply(
       FROM_HERE,
       base::Bind(&DriveCache::MarkDirty,
                  base::Unretained(this),
                  resource_id,
                  md5,
                  DriveCache::FILE_OPERATION_MOVE,
                  error,
                  cache_file_path),
       base::Bind(&RunGetFileFromCacheCallback,
                  callback,
                  base::Owned(error),
                  resource_id,
                  md5,
                  base::Owned(cache_file_path)));
 }
 
 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);
+  DriveFileError* error = new DriveFileError(DRIVE_FILE_OK);
   blocking_task_runner_->PostTaskAndReply(
       FROM_HERE,
       base::Bind(&DriveCache::CommitDirty,
                  base::Unretained(this),
                  resource_id,
                  md5,
                  DriveCache::FILE_OPERATION_MOVE,
                  error),
       base::Bind(&DriveCache::OnCommitDirty,
                  weak_ptr_factory_.GetWeakPtr(),
                  base::Owned(error),
                  resource_id,
                  md5,
                  callback));
 }
 
 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);
+  DriveFileError* error = new DriveFileError(DRIVE_FILE_OK);
   blocking_task_runner_->PostTaskAndReply(
       FROM_HERE,
       base::Bind(&DriveCache::ClearDirty,
                  base::Unretained(this),
                  resource_id,
                  md5,
                  DriveCache::FILE_OPERATION_MOVE,
                  error),
       base::Bind(&RunCacheOperationCallback,
                  callback,
                  base::Owned(error),
                  resource_id,
                  md5));
 }
 
 void DriveCache::RemoveOnUIThread(const std::string& resource_id,
                                   const CacheOperationCallback& callback) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 
-  GDataFileError* error =
-      new GDataFileError(GDATA_FILE_OK);
-
+  DriveFileError* error = new DriveFileError(DRIVE_FILE_OK);
   blocking_task_runner_->PostTaskAndReply(
       FROM_HERE,
       base::Bind(&DriveCache::Remove,
                  base::Unretained(this),
                  resource_id,
                  error),
       base::Bind(&RunCacheOperationCallback,
                  callback,
                  base::Owned(error),
                  resource_id,
                  ""  /* md5 */));
 }
 
 void DriveCache::ClearAllOnUIThread(const ChangeCacheStateCallback& callback) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 
-  GDataFileError* error = new GDataFileError(GDATA_FILE_OK);
-
+  DriveFileError* error = new DriveFileError(DRIVE_FILE_OK);
   blocking_task_runner_->PostTaskAndReply(
       FROM_HERE,
       base::Bind(&DriveCache::ClearAll,
                  base::Unretained(this),
                  error),
       base::Bind(&RunChangeCacheStateCallback,
                  callback,
                  base::Owned(error),
                  &cache_root_path_));
 }
@@ skipping 100 matching lines @@
 void DriveCache::GetResourceIdsOfAllFiles(
     std::vector<std::string>* resource_ids) {
   AssertOnSequencedWorkerPool();
   DCHECK(resource_ids);
 
   metadata_->Iterate(base::Bind(&CollectAnyFile, resource_ids));
 }
 
 void DriveCache::GetFile(const std::string& resource_id,
                          const std::string& md5,
-                         GDataFileError* error,
+                         DriveFileError* 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;
+    *error = DRIVE_FILE_OK;
   } else {
-    *error = GDATA_FILE_ERROR_NOT_FOUND;
+    *error = DRIVE_FILE_ERROR_NOT_FOUND;
   }
 }
 
 void DriveCache::Store(const std::string& resource_id,
                        const std::string& md5,
                        const FilePath& source_path,
                        FileOperationType file_operation_type,
-                       GDataFileError* error) {
+                       DriveFileError* error) {
   AssertOnSequencedWorkerPool();
   DCHECK(error);
 
   if (file_operation_type == FILE_OPERATION_COPY) {
     int64 file_size;
     if (!file_util::GetFileSize(source_path, &file_size)) {
       LOG(WARNING) << "Couldn't get file size for: " << source_path.value();
-      *error = GDATA_FILE_ERROR_FAILED;
+      *error = DRIVE_FILE_ERROR_FAILED;
       return;
     }
 
     bool enough_space = false;
     FreeDiskSpaceIfNeededFor(file_size, &enough_space);
     if (!enough_space) {
-      *error = GDATA_FILE_ERROR_NO_SPACE;
+      *error = DRIVE_FILE_ERROR_NO_SPACE;
       return;
     }
   }
 
   FilePath dest_path;
   FilePath symlink_path;
   CacheSubDirectoryType sub_dir_type = CACHE_TYPE_TMP;
 
   // If file was previously pinned, store it in persistent dir and create
   // symlink in pinned dir.
   DriveCacheEntry cache_entry;
   if (GetCacheEntry(resource_id, md5, &cache_entry)) {  // File exists in cache.
     // 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;
-      *error = GDATA_FILE_ERROR_IN_USE;
+      *error = DRIVE_FILE_ERROR_IN_USE;
       return;
     }
 
     // If file is pinned, determines destination path.
     if (cache_entry.is_pinned()) {
       sub_dir_type = CACHE_TYPE_PERSISTENT;
       dest_path = GetCacheFilePath(resource_id, md5, sub_dir_type,
                                    CACHED_FILE_FROM_SERVER);
       symlink_path = GetCacheFilePath(
           resource_id, std::string(), CACHE_TYPE_PINNED,
@@ skipping 29 matching lines @@
   } else {
     // Replace md5 extension with '*' i.e. "<resource_id>.*".
     // Note that ReplaceExtension automatically prefixes the extension with the
     // extension separator '.'.
     stale_filenames_pattern = dest_path.ReplaceExtension(util::kWildCard);
   }
 
   // Delete files that match |stale_filenames_pattern| except for |dest_path|.
   DeleteFilesSelectively(stale_filenames_pattern, dest_path);
 
-  if (*error == GDATA_FILE_OK) {
+  if (*error == DRIVE_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 DriveCache::Pin(const std::string& resource_id,
                      const std::string& md5,
                      FileOperationType file_operation_type,
-                     GDataFileError* error) {
+                     DriveFileError* error) {
   AssertOnSequencedWorkerPool();
   DCHECK(error);
 
   FilePath source_path;
   FilePath dest_path;
   FilePath symlink_path;
   bool create_symlink = true;
   CacheSubDirectoryType sub_dir_type = CACHE_TYPE_PERSISTENT;
 
   DriveCacheEntry cache_entry;
@@ skipping 54 matching lines @@
                                     CACHE_TYPE_PINNED,
                                     CACHED_FILE_FROM_SERVER);
   }
 
   *error = ModifyCacheState(source_path,
                             dest_path,
                             file_operation_type,
                             symlink_path,
                             create_symlink);
 
-  if (*error == GDATA_FILE_OK) {
+  if (*error == DRIVE_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 DriveCache::Unpin(const std::string& resource_id,
                        const std::string& md5,
                        FileOperationType file_operation_type,
-                       GDataFileError* error) {
+                       DriveFileError* 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="
                  << resource_id
                  << ", md5=" << md5;
-    *error = GDATA_FILE_ERROR_NOT_FOUND;
+    *error = DRIVE_FILE_ERROR_NOT_FOUND;
     return;
   }
 
   // Entry exists in cache, determines source and destination paths.
 
   FilePath source_path;
   FilePath dest_path;
   CacheSubDirectoryType sub_dir_type = CACHE_TYPE_TMP;
 
   // If file is dirty or mounted, don't move it, so determine |dest_path| and
@@ skipping 37 matching lines @@
                                     CACHED_FILE_FROM_SERVER);
   }
 
   *error = ModifyCacheState(
       source_path,
       dest_path,
       file_operation_type,
       symlink_path,  // This will be deleted if it exists.
       false /* don't create symlink*/);
 
-  if (*error == GDATA_FILE_OK) {
+  if (*error == DRIVE_FILE_OK) {
     // Now that file operations have completed, update cache map.
     if (cache_entry.is_present()) {
       cache_entry.set_md5(md5);
       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 DriveCache::SetMountedState(const FilePath& file_path,
                                  bool to_mount,
-                                 GDataFileError *error,
+                                 DriveFileError *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;
   std::string extra_extension;
   util::ParseCacheFilePath(file_path, &resource_id, &md5, &extra_extension);
   // The extra_extension shall be ".mounted" iff we're unmounting.
   DCHECK(!to_mount == (extra_extension == util::kMountedArchiveFileExtension));
 
   // Get cache entry associated with the resource_id and md5
   DriveCacheEntry cache_entry;
   if (!GetCacheEntry(resource_id, md5, &cache_entry)) {
-    *error = GDATA_FILE_ERROR_NOT_FOUND;
+    *error = DRIVE_FILE_ERROR_NOT_FOUND;
     return;
   }
   if (to_mount == cache_entry.is_mounted()) {
-    *error = GDATA_FILE_ERROR_INVALID_OPERATION;
+    *error = DRIVE_FILE_ERROR_INVALID_OPERATION;
     return;
   }
 
   // Get the subdir type and path for the unmounted state.
   CacheSubDirectoryType unmounted_subdir =
       cache_entry.is_pinned() ? CACHE_TYPE_PERSISTENT : CACHE_TYPE_TMP;
   FilePath unmounted_path = GetCacheFilePath(
       resource_id, md5, unmounted_subdir, CACHED_FILE_FROM_SERVER);
 
   // Get the subdir type and path for the mounted state.
@@ skipping 12 matching lines @@
   } else {
     source_path = mounted_path;
     *cache_file_path = unmounted_path;
     dest_subdir = unmounted_subdir;
     cache_entry.set_is_mounted(false);
   }
 
   // Move cache blob from source path to destination path.
   *error = ModifyCacheState(source_path, *cache_file_path,
                             FILE_OPERATION_MOVE, FilePath(), false);
-  if (*error == GDATA_FILE_OK) {
+  if (*error == DRIVE_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 DriveCache::MarkDirty(const std::string& resource_id,
                            const std::string& md5,
                            FileOperationType file_operation_type,
-                           GDataFileError* error,
+                           DriveFileError* 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
   // 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.
   DriveCacheEntry 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;
-    *error = GDATA_FILE_ERROR_NOT_FOUND;
+    *error = DRIVE_FILE_ERROR_NOT_FOUND;
     return;
   }
 
   // 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
   // not being uploaded.  However, for now, cache doesn't know if uploading of a
   // file is in progress.  Per zel, the upload process should be canceled before
   // MarkDirtyInCache is called again.
   if (cache_entry.is_dirty()) {
@@ skipping 11 matching lines @@
     // |source_path| and |dest_path| because ModifyCacheState only move files
     // if source and destination are different.
     *error = ModifyCacheState(
         FilePath(),  // non-applicable source path
         FilePath(),  // non-applicable dest path
         file_operation_type,
         symlink_path,
         false /* don't create symlink */);
 
     // Determine current path of dirty file.
-    if (*error == GDATA_FILE_OK) {
+    if (*error == DRIVE_FILE_OK) {
       *cache_file_path = GetCacheFilePath(
           resource_id,
           md5,
           CACHE_TYPE_PERSISTENT,
           CACHED_FILE_LOCALLY_MODIFIED);
     }
     return;
   }
 
   // Move file to persistent dir with new .local extension.
@@ skipping 21 matching lines @@
                                     CACHED_FILE_FROM_SERVER);
   }
 
   *error = ModifyCacheState(
       source_path,
       *cache_file_path,
       file_operation_type,
       symlink_path,
       !symlink_path.empty() /* create symlink */);
 
-  if (*error == GDATA_FILE_OK) {
+  if (*error == DRIVE_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 DriveCache::CommitDirty(const std::string& resource_id,
                              const std::string& md5,
                              FileOperationType file_operation_type,
-                             GDataFileError* error) {
+                             DriveFileError* 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.
 
   // Committing a file dirty means its entry and actual file blob must exist in
   // cache.
   DriveCacheEntry 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;
-    *error = GDATA_FILE_ERROR_NOT_FOUND;
+    *error = DRIVE_FILE_ERROR_NOT_FOUND;
     return;
   }
 
   // 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()) {
     LOG(WARNING) << "Can't commit a non-dirty file: res_id="
                  << resource_id
                  << ", md5=" << md5;
-    *error = GDATA_FILE_ERROR_INVALID_OPERATION;
+    *error = DRIVE_FILE_ERROR_INVALID_OPERATION;
     return;
   }
 
   // Dirty files must be in persistent dir.
   DCHECK(cache_entry.is_persistent());
 
   // Create symlink in outgoing dir.
   FilePath symlink_path = GetCacheFilePath(resource_id,
                                            std::string(),
                                            CACHE_TYPE_OUTGOING,
@@ skipping 11 matching lines @@
   *error = ModifyCacheState(target_path,  // source
                             target_path,  // destination
                             file_operation_type,
                             symlink_path,
                             true /* create symlink */);
 }
 
 void DriveCache::ClearDirty(const std::string& resource_id,
                             const std::string& md5,
                             FileOperationType file_operation_type,
-                            GDataFileError* error) {
+                            DriveFileError* 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;
 
   // Clearing a dirty file means its entry and actual file blob must exist in
   // cache.
   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;
-    *error = GDATA_FILE_ERROR_NOT_FOUND;
+    *error = DRIVE_FILE_ERROR_NOT_FOUND;
     return;
   }
 
   // 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()) {
     LOG(WARNING) << "Can't clear dirty state of a non-dirty file: res_id="
                  << resource_id
                  << ", md5=" << md5;
-    *error = GDATA_FILE_ERROR_INVALID_OPERATION;
+    *error = DRIVE_FILE_ERROR_INVALID_OPERATION;
     return;
   }
 
   // File must be dirty and hence in persistent dir.
   DCHECK(cache_entry.is_persistent());
 
   // Get the current path of the file in cache.
   FilePath source_path = GetCacheFilePath(resource_id,
                                           md5,
                                           GetSubDirectoryType(cache_entry),
@@ skipping 15 matching lines @@
                                            CACHE_TYPE_OUTGOING,
                                            CACHED_FILE_FROM_SERVER);
 
   *error = ModifyCacheState(source_path,
                             dest_path,
                             file_operation_type,
                             symlink_path,
                             false /* don't create symlink */);
 
   // If file is pinned, update symlink in pinned dir.
-  if (*error == GDATA_FILE_OK && cache_entry.is_pinned()) {
+  if (*error == DRIVE_FILE_OK && cache_entry.is_pinned()) {
     symlink_path = GetCacheFilePath(resource_id,
                                     std::string(),
                                     CACHE_TYPE_PINNED,
                                     CACHED_FILE_FROM_SERVER);
 
     // Since there's no moving of files here, use |dest_path| for both
     // |source_path| and |dest_path|, because ModifyCacheState only moves files
     // if source and destination are different.
     *error = ModifyCacheState(dest_path,  // source path
                               dest_path,  // destination path
                               file_operation_type,
                               symlink_path,
                               true /* create symlink */);
   }
 
-  if (*error == GDATA_FILE_OK) {
+  if (*error == DRIVE_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 DriveCache::Remove(const std::string& resource_id,
-                        GDataFileError* error) {
+                        DriveFileError* 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.
   const bool entry_found =
       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";
-    *error = GDATA_FILE_OK;
+    *error = DRIVE_FILE_OK;
     return;
   }
 
   // Determine paths to delete all cache versions of |resource_id| in
   // persistent, tmp and pinned directories.
   std::vector<FilePath> paths_to_delete;
 
   // For files in persistent and tmp dirs, delete files that match
   // "<resource_id>.*".
   paths_to_delete.push_back(GetCacheFilePath(resource_id,
@@ skipping 20 matching lines @@
                                            CACHE_TYPE_PERSISTENT,
                                            CACHED_FILE_LOCALLY_MODIFIED);
 
   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;
+  *error = DRIVE_FILE_OK;
 }
 
-void DriveCache::ClearAll(GDataFileError* error) {
+void DriveCache::ClearAll(DriveFileError* error) {
   AssertOnSequencedWorkerPool();
   DCHECK(error);
 
   bool success = file_util::Delete(cache_root_path_, true);
   Initialize();
 
-  *error = success ? GDATA_FILE_OK : GDATA_FILE_ERROR_FAILED;
+  *error = success ? DRIVE_FILE_OK : DRIVE_FILE_ERROR_FAILED;
 }
 
-void DriveCache::OnPinned(GDataFileError* error,
+void DriveCache::OnPinned(DriveFileError* 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)
+  if (*error == DRIVE_FILE_OK)
     FOR_EACH_OBSERVER(Observer, observers_, OnCachePinned(resource_id, md5));
 }
 
-void DriveCache::OnUnpinned(GDataFileError* error,
+void DriveCache::OnUnpinned(DriveFileError* 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)
+  if (*error == DRIVE_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(&DriveCache::FreeDiskSpaceIfNeededFor,
                  base::Unretained(this),
                  0,
                  base::Owned(has_enough_space)));
 }
 
-void DriveCache::OnCommitDirty(GDataFileError* error,
+void DriveCache::OnCommitDirty(DriveFileError* 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)
+  if (*error == DRIVE_FILE_OK)
     FOR_EACH_OBSERVER(Observer, observers_, OnCacheCommitted(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);
@@ skipping 50 matching lines @@
     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