Rename GDataErrorCode to DriveErrorCode, GDataFileError to DriveFileError

chrome/browser/chromeos/gdata/gdata_file_system.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_file_system.h"
 
 #include <set>
 #include <utility>
 
 #include "base/bind.h"
@@ skipping 39 matching lines @@
 const int kGDataUpdateCheckIntervalInSec = 5;
 #else
 const int kGDataUpdateCheckIntervalInSec = 60;
 #endif
 
 //================================ Helper functions ============================
 
 // Runs GetFileCallback with pointers dereferenced.
 // Used for PostTaskAndReply().
 void RunGetFileCallbackHelper(const GetFileCallback& callback,
-                              GDataFileError* error,
+                              DriveFileError* error,
                               FilePath* file_path,
                               std::string* mime_type,
                               DriveFileType* file_type) {
   DCHECK(error);
   DCHECK(file_path);
   DCHECK(mime_type);
   DCHECK(file_type);
 
   if (!callback.is_null())
     callback.Run(*error, *file_path, *mime_type, *file_type);
 }
 
 // Ditto for FileOperationCallback
 void RunFileOperationCallbackHelper(
     const FileOperationCallback& callback,
-    GDataFileError* error) {
+    DriveFileError* error) {
   DCHECK(error);
 
   if (!callback.is_null())
     callback.Run(*error);
 }
 
 // Callback for cache file operations invoked by AddUploadedFileOnUIThread.
 void OnCacheUpdatedForAddUploadedFile(
     const base::Closure& callback,
-    GDataFileError /* error */,
+    DriveFileError /* error */,
     const std::string& /* resource_id */,
     const std::string& /* md5 */) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   if (!callback.is_null())
     callback.Run();
 }
 
 // Helper function called upon completion of AddUploadFile invoked by
 // OnTransferCompleted.
 void OnAddUploadFileCompleted(
     const FileOperationCallback& callback,
-    GDataFileError error) {
+    DriveFileError error) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   if (!callback.is_null())
     callback.Run(error);
 }
 
 // The class to wait for the initial load of root feed and runs the callback
 // after the initialization.
 class InitialLoadObserver : public GDataFileSystemInterface::Observer {
  public:
   InitialLoadObserver(GDataFileSystemInterface* file_system,
                       const base::Closure& callback)
       : file_system_(file_system), callback_(callback) {}
 
   virtual void OnInitialLoadFinished() OVERRIDE {
     if (!callback_.is_null())
       base::MessageLoopProxy::current()->PostTask(FROM_HERE, callback_);
     file_system_->RemoveObserver(this);
     base::MessageLoopProxy::current()->DeleteSoon(FROM_HERE, this);
   }
 
  private:
   GDataFileSystemInterface* file_system_;
   base::Closure callback_;
 };
 
 // Gets the file size of |local_file|.
 void GetLocalFileSizeOnBlockingPool(const FilePath& local_file,
-                                    GDataFileError* error,
+                                    DriveFileError* error,
                                     int64* file_size) {
   DCHECK(error);
   DCHECK(file_size);
 
   *file_size = 0;
   *error = file_util::GetFileSize(local_file, file_size) ?
-      GDATA_FILE_OK :
-      GDATA_FILE_ERROR_NOT_FOUND;
+      DRIVE_FILE_OK :
+      DRIVE_FILE_ERROR_NOT_FOUND;
 }
 
 // Gets the file size and the content type of |local_file|.
 void GetLocalFileInfoOnBlockingPool(
     const FilePath& local_file,
-    GDataFileError* error,
+    DriveFileError* error,
     int64* file_size,
     std::string* content_type) {
   DCHECK(error);
   DCHECK(file_size);
   DCHECK(content_type);
 
   if (!net::GetMimeTypeFromExtension(local_file.Extension(), content_type))
     *content_type = kMimeTypeOctetStream;
 
   *file_size = 0;
   *error = file_util::GetFileSize(local_file, file_size) ?
-      GDATA_FILE_OK :
-      GDATA_FILE_ERROR_NOT_FOUND;
+      DRIVE_FILE_OK :
+      DRIVE_FILE_ERROR_NOT_FOUND;
 }
 
 // Checks if a local file at |local_file_path| is a JSON file referencing a
 // hosted document on blocking pool, and if so, gets the resource ID of the
 // document.
 void GetDocumentResourceIdOnBlockingPool(
     const FilePath& local_file_path,
     std::string* resource_id) {
   DCHECK(resource_id);
 
   if (DocumentEntry::HasHostedDocumentExtension(local_file_path)) {
     std::string error;
     DictionaryValue* dict_value = NULL;
     JSONFileValueSerializer serializer(local_file_path);
     scoped_ptr<Value> value(serializer.Deserialize(NULL, &error));
     if (value.get() && value->GetAsDictionary(&dict_value))
       dict_value->GetString("resource_id", resource_id);
   }
 }
 
 // Creates a temporary JSON file representing a document with |edit_url|
 // and |resource_id| under |document_dir| on blocking pool.
 void CreateDocumentJsonFileOnBlockingPool(
     const FilePath& document_dir,
     const GURL& edit_url,
     const std::string& resource_id,
-    GDataFileError* error,
+    DriveFileError* error,
     FilePath* temp_file_path,
     std::string* mime_type,
     DriveFileType* file_type) {
   DCHECK(error);
   DCHECK(temp_file_path);
   DCHECK(mime_type);
   DCHECK(file_type);
 
-  *error = GDATA_FILE_ERROR_FAILED;
+  *error = DRIVE_FILE_ERROR_FAILED;
 
   if (file_util::CreateTemporaryFileInDir(document_dir, temp_file_path)) {
     std::string document_content = base::StringPrintf(
         "{\"url\": \"%s\", \"resource_id\": \"%s\"}",
         edit_url.spec().c_str(), resource_id.c_str());
     int document_size = static_cast<int>(document_content.size());
     if (file_util::WriteFile(*temp_file_path, document_content.data(),
                              document_size) == document_size) {
-      *error = GDATA_FILE_OK;
+      *error = DRIVE_FILE_OK;
     }
   }
 
   *mime_type = kMimeTypeJson;
   *file_type = HOSTED_DOCUMENT;
-  if (*error != GDATA_FILE_OK)
+  if (*error != DRIVE_FILE_OK)
       temp_file_path->clear();
 }
 
 // Gets the information of the file at local path |path|. The information is
 // filled in |file_info|, and if it fails |result| will be assigned false.
 void GetFileInfoOnBlockingPool(const FilePath& path,
                                base::PlatformFileInfo* file_info,
                                bool* result) {
   *result = file_util::GetFileInfo(path, file_info);
 }
 
 // Copies a file from |src_file_path| to |dest_file_path| on the local
 // file system using file_util::CopyFile. |error| is set to
-// GDATA_FILE_OK on success or GDATA_FILE_ERROR_FAILED
+// DRIVE_FILE_OK on success or DRIVE_FILE_ERROR_FAILED
 // otherwise.
 void CopyLocalFileOnBlockingPool(
     const FilePath& src_file_path,
     const FilePath& dest_file_path,
-    GDataFileError* error) {
+    DriveFileError* error) {
   DCHECK(error);
 
   *error = file_util::CopyFile(src_file_path, dest_file_path) ?
-      GDATA_FILE_OK : GDATA_FILE_ERROR_FAILED;
+      DRIVE_FILE_OK : DRIVE_FILE_ERROR_FAILED;
 }
 
 // Callback for GetEntryByResourceIdAsync.
 // Adds |entry| to |results|. Runs |callback| with |results| when
 // |run_callback| is true. When |entry| is not present in our local file system
 // snapshot, it is not added to |results|. Instead, |entry_skipped_callback| is
 // called.
 void AddEntryToSearchResults(
     std::vector<SearchResultInfo>* results,
     const SearchCallback& callback,
     const base::Closure& entry_skipped_callback,
-    GDataFileError error,
+    DriveFileError error,
     bool run_callback,
     const GURL& next_feed,
     DriveEntry* entry) {
   // If a result is not present in our local file system snapshot, invoke
   // |entry_skipped_callback| and refreshes the snapshot with delta feed.
   // For example, this may happen if the entry has recently been added to the
   // drive (and we still haven't received its delta feed).
   if (entry) {
     const bool is_directory = entry->AsDriveDirectory() != NULL;
     results->push_back(SearchResultInfo(entry->GetFilePath(), is_directory));
   } else {
     if (!entry_skipped_callback.is_null())
       entry_skipped_callback.Run();
   }
 
   if (run_callback) {
     scoped_ptr<std::vector<SearchResultInfo> > result_vec(results);
     if (!callback.is_null())
       callback.Run(error, next_feed, result_vec.Pass());
   }
 }
 
 // Helper function for binding |path| to GetEntryInfoWithFilePathCallback and
 // create GetEntryInfoCallback.
 void RunGetEntryInfoWithFilePathCallback(
     const GetEntryInfoWithFilePathCallback& callback,
     const FilePath& path,
-    GDataFileError error,
+    DriveFileError error,
     scoped_ptr<DriveEntryProto> entry_proto) {
   if (!callback.is_null())
     callback.Run(error, path, entry_proto.Pass());
 }
 
 }  // namespace
 
 // GDataFileSystem::CreateDirectoryParams struct implementation.
 struct GDataFileSystem::CreateDirectoryParams {
   CreateDirectoryParams(const FilePath& created_directory_path,
@@ skipping 181 matching lines @@
     feed_loader_->ReloadFromServerIfNeeded(
         initial_origin,
         resource_metadata_->largest_changestamp(),
         base::Bind(&GDataFileSystem::OnUpdateChecked,
                    ui_weak_ptr_,
                    initial_origin));
   }
 }
 
 void GDataFileSystem::OnUpdateChecked(ContentOrigin initial_origin,
-                                      GDataFileError error) {
+                                      DriveFileError error) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 
-  if (error != GDATA_FILE_OK)
+  if (error != DRIVE_FILE_OK)
     resource_metadata_->set_origin(initial_origin);
 }
 
 GDataFileSystem::~GDataFileSystem() {
   // This should be called from UI thread, from GDataSystemService shutdown.
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 
   feed_loader_->RemoveObserver(this);
 
   // Cancel all the in-flight operations.
@@ skipping 70 matching lines @@
   DCHECK(!callback.is_null());
 
   if (entry) {
     scoped_ptr<DriveEntryProto> entry_proto(new DriveEntryProto);
     entry->ToProtoFull(entry_proto.get());
     CheckLocalModificationAndRun(
         entry_proto.Pass(),
         base::Bind(&RunGetEntryInfoWithFilePathCallback,
                    callback, entry->GetFilePath()));
   } else {
-    callback.Run(GDATA_FILE_ERROR_NOT_FOUND,
+    callback.Run(DRIVE_FILE_ERROR_NOT_FOUND,
                  FilePath(),
                  scoped_ptr<DriveEntryProto>());
   }
 }
 
 void GDataFileSystem::LoadFeedIfNeeded(const FileOperationCallback& callback) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   DCHECK(!callback.is_null());
 
   if (resource_metadata_->origin() == INITIALIZING) {
     // If root feed is not initialized but the initialization process has
     // already started, add an observer to execute the remaining task after
     // the end of the initialization.
     AddObserver(new InitialLoadObserver(this,
-                                        base::Bind(callback, GDATA_FILE_OK)));
+                                        base::Bind(callback, DRIVE_FILE_OK)));
     return;
   } else if (resource_metadata_->origin() == UNINITIALIZED) {
     // Load root feed from this disk cache. Upon completion, kick off server
     // fetching.
     resource_metadata_->set_origin(INITIALIZING);
     feed_loader_->LoadFromCache(
         true,  // should_load_from_server
         base::Bind(&GDataFileSystem::NotifyInitialLoadFinishedAndRun,
                    ui_weak_ptr_,
                    callback));
     return;
   }
 
   // The feed has already been loaded, so we have nothing to do, but post a
   // task to the same thread, rather than calling it here, as
   // LoadFeedIfNeeded() is asynchronous.
   base::MessageLoopProxy::current()->PostTask(
       FROM_HERE,
-      base::Bind(callback, GDATA_FILE_OK));
+      base::Bind(callback, DRIVE_FILE_OK));
 }
 
 void GDataFileSystem::TransferFileFromRemoteToLocal(
     const FilePath& remote_src_file_path,
     const FilePath& local_dest_file_path,
     const FileOperationCallback& callback) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   DCHECK(!callback.is_null());
 
   GetFileByPath(remote_src_file_path,
@@ skipping 19 matching lines @@
           ui_weak_ptr_,
           local_src_file_path,
           remote_dest_file_path,
           callback));
 }
 
 void GDataFileSystem::TransferFileFromLocalToRemoteAfterGetEntryInfo(
     const FilePath& local_src_file_path,
     const FilePath& remote_dest_file_path,
     const FileOperationCallback& callback,
-    GDataFileError error,
+    DriveFileError error,
     scoped_ptr<DriveEntryProto> entry_proto) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   DCHECK(!callback.is_null());
 
-  if (error != GDATA_FILE_OK) {
+  if (error != DRIVE_FILE_OK) {
     callback.Run(error);
     return;
   }
 
   DCHECK(entry_proto.get());
   if (!entry_proto->file_info().is_directory()) {
     // The parent of |remote_dest_file_path| is not a directory.
-    callback.Run(GDATA_FILE_ERROR_NOT_A_DIRECTORY);
+    callback.Run(DRIVE_FILE_ERROR_NOT_A_DIRECTORY);
     return;
   }
 
   std::string* resource_id = new std::string;
   util::PostBlockingPoolSequencedTaskAndReply(
       FROM_HERE,
       blocking_task_runner_,
       base::Bind(&GetDocumentResourceIdOnBlockingPool,
                  local_src_file_path,
                  resource_id),
@@ skipping 30 matching lines @@
       remote_dest_file_path.BaseName().RemoveExtension().value(),
       callback);
 }
 
 void GDataFileSystem::TransferRegularFile(
     const FilePath& local_file_path,
     const FilePath& remote_dest_file_path,
     const FileOperationCallback& callback) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 
-  GDataFileError* error =
-      new GDataFileError(GDATA_FILE_OK);
+  DriveFileError* error =
+      new DriveFileError(DRIVE_FILE_OK);
   int64* file_size = new int64;
   std::string* content_type = new std::string;
   util::PostBlockingPoolSequencedTaskAndReply(
       FROM_HERE,
       blocking_task_runner_,
       base::Bind(&GetLocalFileInfoOnBlockingPool,
                  local_file_path,
                  error,
                  file_size,
                  content_type),
       base::Bind(&GDataFileSystem::StartFileUploadOnUIThread,
                  ui_weak_ptr_,
                  StartFileUploadParams(local_file_path,
                                        remote_dest_file_path,
                                        callback),
                  base::Owned(error),
                  base::Owned(file_size),
                  base::Owned(content_type)));
 }
 
 void GDataFileSystem::StartFileUploadOnUIThread(
     const StartFileUploadParams& params,
-    GDataFileError* error,
+    DriveFileError* error,
     int64* file_size,
     std::string* content_type) {
   // This method needs to run on the UI thread as required by
   // GDataUploader::UploadNewFile().
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   DCHECK(error);
   DCHECK(file_size);
   DCHECK(content_type);
 
-  if (*error != GDATA_FILE_OK) {
+  if (*error != DRIVE_FILE_OK) {
     if (!params.callback.is_null())
       params.callback.Run(*error);
 
     return;
   }
 
   // Make sure the destination directory exists.
   resource_metadata_->GetEntryInfoByPath(
       params.remote_file_path.DirName(),
       base::Bind(
           &GDataFileSystem::StartFileUploadOnUIThreadAfterGetEntryInfo,
           ui_weak_ptr_,
           params,
           *file_size,
           *content_type));
 }
 
 void GDataFileSystem::StartFileUploadOnUIThreadAfterGetEntryInfo(
     const StartFileUploadParams& params,
     int64 file_size,
     std::string content_type,
-    GDataFileError error,
+    DriveFileError error,
     scoped_ptr<DriveEntryProto> entry_proto) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 
   if (entry_proto.get() && !entry_proto->file_info().is_directory())
-    error = GDATA_FILE_ERROR_NOT_A_DIRECTORY;
+    error = DRIVE_FILE_ERROR_NOT_A_DIRECTORY;
 
-  if (error != GDATA_FILE_OK) {
+  if (error != DRIVE_FILE_OK) {
     if (!params.callback.is_null())
       params.callback.Run(error);
     return;
   }
   DCHECK(entry_proto.get());
 
   // Fill in values of UploadFileInfo.
   scoped_ptr<UploadFileInfo> upload_file_info(new UploadFileInfo);
   upload_file_info->file_path = params.local_file_path;
   upload_file_info->file_size = file_size;
   upload_file_info->gdata_path = params.remote_file_path;
   // Use the file name as the title.
   upload_file_info->title = params.remote_file_path.BaseName().value();
   upload_file_info->content_length = file_size;
   upload_file_info->all_bytes_present = true;
   upload_file_info->content_type = content_type;
   upload_file_info->initial_upload_location = GURL(entry_proto->upload_url());
   upload_file_info->upload_mode = UPLOAD_NEW_FILE;
 
   upload_file_info->completion_callback =
       base::Bind(&GDataFileSystem::OnTransferCompleted,
                  ui_weak_ptr_,
                  params.callback);
 
   uploader_->UploadNewFile(upload_file_info.Pass());
 }
 
 void GDataFileSystem::OnTransferCompleted(
     const FileOperationCallback& callback,
-    GDataFileError error,
+    DriveFileError error,
     scoped_ptr<UploadFileInfo> upload_file_info) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   DCHECK(upload_file_info.get());
 
-  if (error == GDATA_FILE_OK && upload_file_info->entry.get()) {
+  if (error == DRIVE_FILE_OK && upload_file_info->entry.get()) {
     AddUploadedFile(UPLOAD_NEW_FILE,
                     upload_file_info->gdata_path.DirName(),
                     upload_file_info->entry.Pass(),
                     upload_file_info->file_path,
                     DriveCache::FILE_OPERATION_COPY,
                     base::Bind(&OnAddUploadFileCompleted, callback, error));
   } else if (!callback.is_null()) {
     callback.Run(error);
   }
 }
@@ skipping 28 matching lines @@
 }
 
 void GDataFileSystem::CopyOnUIThreadAfterGetEntryInfoPair(
     const FilePath& dest_file_path,
     const FileOperationCallback& callback,
     scoped_ptr<EntryInfoPairResult> result) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   DCHECK(!callback.is_null());
   DCHECK(result.get());
 
-  if (result->first.error != GDATA_FILE_OK) {
+  if (result->first.error != DRIVE_FILE_OK) {
     callback.Run(result->first.error);
     return;
-  } else if (result->second.error != GDATA_FILE_OK) {
+  } else if (result->second.error != DRIVE_FILE_OK) {
     callback.Run(result->second.error);
     return;
   }
 
   scoped_ptr<DriveEntryProto> src_file_proto = result->first.proto.Pass();
   scoped_ptr<DriveEntryProto> dest_parent_proto = result->second.proto.Pass();
 
   if (!dest_parent_proto->file_info().is_directory()) {
-    callback.Run(GDATA_FILE_ERROR_NOT_A_DIRECTORY);
+    callback.Run(DRIVE_FILE_ERROR_NOT_A_DIRECTORY);
     return;
   } else if (src_file_proto->file_info().is_directory()) {
     // TODO(kochi): Implement copy for directories. In the interim,
     // we handle recursive directory copy in the file manager.
     // crbug.com/141596
-    callback.Run(GDATA_FILE_ERROR_INVALID_OPERATION);
+    callback.Run(DRIVE_FILE_ERROR_INVALID_OPERATION);
     return;
   }
 
   if (src_file_proto->file_specific_info().is_hosted_document()) {
     CopyDocumentToDirectory(dest_file_path.DirName(),
                             src_file_proto->resource_id(),
                             // Drop the document extension, which should not be
                             // in the document title.
                             dest_file_path.BaseName().RemoveExtension().value(),
                             callback);
     return;
   }
 
   // TODO(kochi): Reimplement this once the server API supports
   // copying of regular files directly on the server side. crbug.com/138273
   const FilePath& src_file_path = result->first.path;
   GetFileByPath(src_file_path,
                 base::Bind(&GDataFileSystem::OnGetFileCompleteForCopy,
                            ui_weak_ptr_,
                            dest_file_path,
                            callback),
                 GetContentCallback());
 }
 
 void GDataFileSystem::OnGetFileCompleteForCopy(
     const FilePath& remote_dest_file_path,
     const FileOperationCallback& callback,
-    GDataFileError error,
+    DriveFileError error,
     const FilePath& local_file_path,
     const std::string& unused_mime_type,
     DriveFileType file_type) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   DCHECK(!callback.is_null());
 
-  if (error != GDATA_FILE_OK) {
+  if (error != DRIVE_FILE_OK) {
     callback.Run(error);
     return;
   }
 
   // This callback is only triggered for a regular file via Copy().
   DCHECK_EQ(REGULAR_FILE, file_type);
   TransferRegularFile(local_file_path, remote_dest_file_path, callback);
 }
 
 void GDataFileSystem::OnGetFileCompleteForTransferFile(
     const FilePath& local_dest_file_path,
     const FileOperationCallback& callback,
-    GDataFileError error,
+    DriveFileError error,
     const FilePath& local_file_path,
     const std::string& unused_mime_type,
     DriveFileType file_type) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   DCHECK(!callback.is_null());
 
-  if (error != GDATA_FILE_OK) {
+  if (error != DRIVE_FILE_OK) {
     callback.Run(error);
     return;
   }
 
   // GetFileByPath downloads the file from gdata to a local cache, which is then
   // copied to the actual destination path on the local file system using
   // CopyLocalFileOnBlockingPool.
-  GDataFileError* copy_file_error =
-      new GDataFileError(GDATA_FILE_OK);
+  DriveFileError* copy_file_error =
+      new DriveFileError(DRIVE_FILE_OK);
   util::PostBlockingPoolSequencedTaskAndReply(
       FROM_HERE,
       blocking_task_runner_,
       base::Bind(&CopyLocalFileOnBlockingPool,
                  local_file_path,
                  local_dest_file_path,
                  copy_file_error),
       base::Bind(&RunFileOperationCallbackHelper,
                  callback,
                  base::Owned(copy_file_error)));
@@ skipping 15 matching lines @@
 }
 
 void GDataFileSystem::Rename(const FilePath& file_path,
                              const FilePath::StringType& new_name,
                              const FileMoveCallback& callback) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   DCHECK(!callback.is_null());
 
   // It is a no-op if the file is renamed to the same name.
   if (file_path.BaseName().value() == new_name) {
-    callback.Run(GDATA_FILE_OK, file_path);
+    callback.Run(DRIVE_FILE_OK, file_path);
     return;
   }
 
   // Get the edit URL of an entry at |file_path|.
   resource_metadata_->GetEntryInfoByPath(
       file_path,
       base::Bind(
           &GDataFileSystem::RenameAfterGetEntryInfo,
           ui_weak_ptr_,
           file_path,
           new_name,
           callback));
 }
 
 void GDataFileSystem::RenameAfterGetEntryInfo(
     const FilePath& file_path,
     const FilePath::StringType& new_name,
     const FileMoveCallback& callback,
-    GDataFileError error,
+    DriveFileError error,
     scoped_ptr<DriveEntryProto> entry_proto) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 
-  if (error != GDATA_FILE_OK) {
+  if (error != DRIVE_FILE_OK) {
     if (!callback.is_null())
       callback.Run(error, file_path);
     return;
   }
   DCHECK(entry_proto.get());
 
   // Drop the .g<something> extension from |new_name| if the file being
   // renamed is a hosted document and |new_name| has the same .g<something>
   // extension as the file.
   FilePath::StringType file_name = new_name;
@@ skipping 46 matching lines @@
 }
 
 void GDataFileSystem::MoveOnUIThreadAfterGetEntryInfoPair(
     const FilePath& dest_file_path,
     const FileOperationCallback& callback,
     scoped_ptr<EntryInfoPairResult> result) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   DCHECK(!callback.is_null());
   DCHECK(result.get());
 
-  if (result->first.error != GDATA_FILE_OK) {
+  if (result->first.error != DRIVE_FILE_OK) {
     callback.Run(result->first.error);
     return;
-  } else if (result->second.error != GDATA_FILE_OK) {
+  } else if (result->second.error != DRIVE_FILE_OK) {
     callback.Run(result->second.error);
     return;
   }
 
   scoped_ptr<DriveEntryProto> dest_parent_proto = result->second.proto.Pass();
   if (!dest_parent_proto->file_info().is_directory()) {
-    callback.Run(GDATA_FILE_ERROR_NOT_A_DIRECTORY);
+    callback.Run(DRIVE_FILE_ERROR_NOT_A_DIRECTORY);
     return;
   }
 
   // If the file/directory is moved to the same directory, just rename it.
   const FilePath& src_file_path = result->first.path;
   const FilePath& dest_parent_path = result->second.path;
   if (src_file_path.DirName() == dest_parent_path) {
     FileMoveCallback final_file_path_update_callback =
         base::Bind(&GDataFileSystem::OnFilePathUpdated,
                    ui_weak_ptr_,
@@ skipping 24 matching lines @@
                  ui_weak_ptr_,
                  add_file_to_directory_callback);
 
   Rename(src_file_path, dest_file_path.BaseName().value(),
          remove_file_from_directory_callback);
 }
 
 void GDataFileSystem::MoveEntryFromRootDirectory(
     const FilePath& dir_path,
     const FileOperationCallback& callback,
-    GDataFileError error,
+    DriveFileError error,
     const FilePath& file_path) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   DCHECK(!callback.is_null());
   DCHECK_EQ(kDriveRootDirectory, file_path.DirName().value());
 
   // Return if there is an error or |dir_path| is the root directory.
-  if (error != GDATA_FILE_OK || dir_path == FilePath(kDriveRootDirectory)) {
+  if (error != DRIVE_FILE_OK || dir_path == FilePath(kDriveRootDirectory)) {
     callback.Run(error);
     return;
   }
 
   resource_metadata_->GetEntryInfoPairByPaths(
       file_path,
       dir_path,
       base::Bind(
           &GDataFileSystem::MoveEntryFromRootDirectoryAfterGetEntryInfoPair,
           ui_weak_ptr_,
           callback));
 }
 
 void GDataFileSystem::MoveEntryFromRootDirectoryAfterGetEntryInfoPair(
     const FileOperationCallback& callback,
     scoped_ptr<EntryInfoPairResult> result) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   DCHECK(!callback.is_null());
   DCHECK(result.get());
 
-  if (result->first.error != GDATA_FILE_OK) {
+  if (result->first.error != DRIVE_FILE_OK) {
     callback.Run(result->first.error);
     return;
-  } else if (result->second.error != GDATA_FILE_OK) {
+  } else if (result->second.error != DRIVE_FILE_OK) {
     callback.Run(result->second.error);
     return;
   }
 
   scoped_ptr<DriveEntryProto> src_proto = result->first.proto.Pass();
   scoped_ptr<DriveEntryProto> dir_proto = result->second.proto.Pass();
 
   if (!dir_proto->file_info().is_directory()) {
-    callback.Run(GDATA_FILE_ERROR_NOT_A_DIRECTORY);
+    callback.Run(DRIVE_FILE_ERROR_NOT_A_DIRECTORY);
     return;
   }
 
   const FilePath& file_path = result->first.path;
   const FilePath& dir_path = result->second.path;
   drive_service_->AddResourceToDirectory(
       GURL(dir_proto->content_url()),
       GURL(src_proto->edit_url()),
       base::Bind(&GDataFileSystem::OnMoveEntryFromRootDirectoryCompleted,
                  ui_weak_ptr_,
                  callback,
                  file_path,
                  dir_path));
 }
 
 void GDataFileSystem::RemoveEntryFromNonRootDirectory(
     const FileMoveCallback& callback,
-    GDataFileError error,
+    DriveFileError error,
     const FilePath& file_path) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   DCHECK(!callback.is_null());
 
   const FilePath dir_path = file_path.DirName();
   // Return if there is an error or |dir_path| is the root directory.
-  if (error != GDATA_FILE_OK || dir_path == FilePath(kDriveRootDirectory)) {
+  if (error != DRIVE_FILE_OK || dir_path == FilePath(kDriveRootDirectory)) {
     callback.Run(error, file_path);
     return;
   }
 
   resource_metadata_->GetEntryInfoPairByPaths(
       file_path,
       dir_path,
       base::Bind(
           &GDataFileSystem::RemoveEntryFromNonRootDirectoryAfterEntryInfoPair,
           ui_weak_ptr_,
           callback));
 }
 
 void GDataFileSystem::RemoveEntryFromNonRootDirectoryAfterEntryInfoPair(
     const FileMoveCallback& callback,
     scoped_ptr<EntryInfoPairResult> result) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   DCHECK(!callback.is_null());
   DCHECK(result.get());
 
   const FilePath& file_path = result->first.path;
   const FilePath& dir_path = result->second.path;
-  if (result->first.error != GDATA_FILE_OK) {
+  if (result->first.error != DRIVE_FILE_OK) {
     callback.Run(result->first.error, file_path);
     return;
-  } else if (result->second.error != GDATA_FILE_OK) {
+  } else if (result->second.error != DRIVE_FILE_OK) {
     callback.Run(result->second.error, file_path);
     return;
   }
 
   scoped_ptr<DriveEntryProto> entry_proto = result->first.proto.Pass();
   scoped_ptr<DriveEntryProto> dir_proto = result->second.proto.Pass();
 
   if (!dir_proto->file_info().is_directory()) {
-    callback.Run(GDATA_FILE_ERROR_NOT_A_DIRECTORY, file_path);
+    callback.Run(DRIVE_FILE_ERROR_NOT_A_DIRECTORY, file_path);
     return;
   }
 
   drive_service_->RemoveResourceFromDirectory(
       GURL(dir_proto->content_url()),
       GURL(entry_proto->edit_url()),
       entry_proto->resource_id(),
       base::Bind(&GDataFileSystem::MoveEntryToRootDirectoryLocally,
                  ui_weak_ptr_,
                  callback,
@@ skipping 27 matching lines @@
           ui_weak_ptr_,
           file_path,
           is_recursive,
           callback));
 }
 
 void GDataFileSystem::RemoveOnUIThreadAfterGetEntryInfo(
     const FilePath& file_path,
     bool /* is_recursive */,
     const FileOperationCallback& callback,
-    GDataFileError error,
+    DriveFileError error,
     scoped_ptr<DriveEntryProto> entry_proto) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 
-  if (error != GDATA_FILE_OK) {
+  if (error != DRIVE_FILE_OK) {
     if (!callback.is_null()) {
       base::MessageLoopProxy::current()->PostTask(
           FROM_HERE, base::Bind(callback, error));
     }
     return;
   }
 
   DCHECK(entry_proto.get());
   drive_service_->DeleteDocument(
       GURL(entry_proto->edit_url()),
@@ skipping 29 matching lines @@
   FilePath first_missing_path;
   GURL last_parent_dir_url;
   FindMissingDirectoryResult result =
       FindFirstMissingParentDirectory(directory_path,
                                       &last_parent_dir_url,
                                       &first_missing_path);
   switch (result) {
     case FOUND_INVALID: {
       if (!callback.is_null()) {
         MessageLoop::current()->PostTask(FROM_HERE,
-            base::Bind(callback, GDATA_FILE_ERROR_NOT_FOUND));
+            base::Bind(callback, DRIVE_FILE_ERROR_NOT_FOUND));
       }
 
       return;
     }
     case DIRECTORY_ALREADY_PRESENT: {
       if (!callback.is_null()) {
         MessageLoop::current()->PostTask(FROM_HERE,
             base::Bind(callback,
-                       is_exclusive ? GDATA_FILE_ERROR_EXISTS :
-                                      GDATA_FILE_OK));
+                       is_exclusive ? DRIVE_FILE_ERROR_EXISTS :
+                                      DRIVE_FILE_OK));
       }
 
       return;
     }
     case FOUND_MISSING: {
       // There is a missing folder to be created here, move on with the rest of
       // this function.
       break;
     }
     default: {
       NOTREACHED();
       break;
     }
   }
 
   // Do we have a parent directory here as well? We can't then create target
   // directory if this is not a recursive operation.
   if (directory_path !=  first_missing_path && !is_recursive) {
     if (!callback.is_null()) {
       MessageLoop::current()->PostTask(FROM_HERE,
-           base::Bind(callback, GDATA_FILE_ERROR_NOT_FOUND));
+           base::Bind(callback, DRIVE_FILE_ERROR_NOT_FOUND));
     }
     return;
   }
 
   drive_service_->CreateDirectory(
       last_parent_dir_url,
       first_missing_path.BaseName().value(),
       base::Bind(&GDataFileSystem::OnCreateDirectoryCompleted,
                  ui_weak_ptr_,
                  CreateDirectoryParams(
@@ skipping 32 matching lines @@
                  ui_weak_ptr_,
                  file_path,
                  is_exclusive,
                  callback));
 }
 
 void GDataFileSystem::OnGetEntryInfoForCreateFile(
     const FilePath& file_path,
     bool is_exclusive,
     const FileOperationCallback& callback,
-    GDataFileError result,
+    DriveFileError result,
     scoped_ptr<DriveEntryProto> entry_proto) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   DCHECK(!callback.is_null());
 
   // The |file_path| is invalid. It is an error.
-  if (result != GDATA_FILE_ERROR_NOT_FOUND &&
-      result != GDATA_FILE_OK) {
+  if (result != DRIVE_FILE_ERROR_NOT_FOUND &&
+      result != DRIVE_FILE_OK) {
     callback.Run(result);
     return;
   }
 
   // An entry already exists at |file_path|.
-  if (result == GDATA_FILE_OK) {
+  if (result == DRIVE_FILE_OK) {
     DCHECK(entry_proto.get());
     // If an exclusive mode is requested, or the entry is not a regular file,
     // it is an error.
     if (is_exclusive ||
         entry_proto->file_info().is_directory() ||
         entry_proto->file_specific_info().is_hosted_document()) {
-      callback.Run(GDATA_FILE_ERROR_EXISTS);
+      callback.Run(DRIVE_FILE_ERROR_EXISTS);
       return;
     }
 
     // Otherwise nothing more to do. Succeeded.
-    callback.Run(GDATA_FILE_OK);
+    callback.Run(DRIVE_FILE_OK);
     return;
   }
 
   // No entry found at |file_path|. Let's create a brand new file.
   // For now, it is implemented by uploading an empty file (/dev/null).
   // TODO(kinaba): http://crbug.com/135143. Implement in a nicer way.
   TransferRegularFile(FilePath(kEmptyFilePath), file_path, callback);
 }
 
 void GDataFileSystem::GetFileByPath(
@@ skipping 22 matching lines @@
                  ui_weak_ptr_,
                  file_path,
                  CreateRelayCallback(get_file_callback),
                  CreateRelayCallback(get_content_callback)));
 }
 
 void GDataFileSystem::OnGetEntryInfoCompleteForGetFileByPath(
     const FilePath& file_path,
     const GetFileCallback& get_file_callback,
     const GetContentCallback& get_content_callback,
-    GDataFileError error,
+    DriveFileError error,
     scoped_ptr<DriveEntryProto> entry_proto) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 
   // If |error| == PLATFORM_FILE_OK then |entry_proto| must be valid.
-  DCHECK(error != GDATA_FILE_OK ||
+  DCHECK(error != DRIVE_FILE_OK ||
          (entry_proto.get() && !entry_proto->resource_id().empty()));
   GetResolvedFileByPath(file_path,
                         get_file_callback,
                         get_content_callback,
                         error,
                         entry_proto.get());
 }
 
 void GDataFileSystem::GetResolvedFileByPath(
     const FilePath& file_path,
     const GetFileCallback& get_file_callback,
     const GetContentCallback& get_content_callback,
-    GDataFileError error,
+    DriveFileError error,
     const DriveEntryProto* entry_proto) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 
   if (entry_proto && !entry_proto->has_file_specific_info())
-    error = GDATA_FILE_ERROR_NOT_FOUND;
+    error = DRIVE_FILE_ERROR_NOT_FOUND;
 
-  if (error != GDATA_FILE_OK) {
+  if (error != DRIVE_FILE_OK) {
     if (!get_file_callback.is_null()) {
       MessageLoop::current()->PostTask(
           FROM_HERE,
           base::Bind(get_file_callback,
-                     GDATA_FILE_ERROR_NOT_FOUND,
+                     DRIVE_FILE_ERROR_NOT_FOUND,
                      FilePath(),
                      std::string(),
                      REGULAR_FILE));
     }
     return;
   }
 
   // For a hosted document, we create a special JSON file to represent the
   // document instead of fetching the document content in one of the exported
   // formats. The JSON file contains the edit URL and resource ID of the
   // document.
   if (entry_proto->file_specific_info().is_hosted_document()) {
-    GDataFileError* error =
-        new GDataFileError(GDATA_FILE_OK);
+    DriveFileError* error =
+        new DriveFileError(DRIVE_FILE_OK);
     FilePath* temp_file_path = new FilePath;
     std::string* mime_type = new std::string;
     DriveFileType* file_type = new DriveFileType(REGULAR_FILE);
     util::PostBlockingPoolSequencedTaskAndReply(
         FROM_HERE,
         blocking_task_runner_,
         base::Bind(&CreateDocumentJsonFileOnBlockingPool,
                    cache_->GetCacheDirectoryPath(
                        DriveCache::CACHE_TYPE_TMP_DOCUMENTS),
                    GURL(entry_proto->file_specific_info().alternate_url()),
@@ skipping 74 matching lines @@
       file_path = file->GetFilePath();
   }
 
   // Report an error immediately if the file for the resource ID is not
   // found.
   if (file_path.empty()) {
     if (!get_file_callback.is_null()) {
       base::MessageLoopProxy::current()->PostTask(
           FROM_HERE,
           base::Bind(get_file_callback,
-                     GDATA_FILE_ERROR_NOT_FOUND,
+                     DRIVE_FILE_ERROR_NOT_FOUND,
                      FilePath(),
                      std::string(),
                      REGULAR_FILE));
     }
     return;
   }
 
   GetFileByPath(file_path, get_file_callback, get_content_callback);
 }
 
 void GDataFileSystem::OnGetFileFromCache(const GetFileFromCacheParams& params,
-                                         GDataFileError error,
+                                         DriveFileError error,
                                          const std::string& resource_id,
                                          const std::string& md5,
                                          const FilePath& cache_file_path) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 
   // Have we found the file in cache? If so, return it back to the caller.
-  if (error == GDATA_FILE_OK) {
+  if (error == DRIVE_FILE_OK) {
     if (!params.get_file_callback.is_null()) {
       params.get_file_callback.Run(error,
                                    cache_file_path,
                                    params.mime_type,
                                    REGULAR_FILE);
     }
     return;
   }
 
   // If cache file is not found, try to download the file from the server
@@ skipping 17 matching lines @@
                                         params.content_url,
                                         params.resource_id,
                                         params.md5,
                                         params.mime_type,
                                         params.get_file_callback,
                                         params.get_content_callback)));
 }
 
 void GDataFileSystem::OnGetDocumentEntry(const FilePath& cache_file_path,
                                          const GetFileFromCacheParams& params,
-                                         GDataErrorCode status,
+                                         DriveErrorCode status,
                                          scoped_ptr<base::Value> data) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 
-  GDataFileError error = util::GDataToGDataFileError(status);
+  DriveFileError error = util::DriveToDriveFileError(status);
 
   scoped_ptr<DriveEntry> fresh_entry;
-  if (error == GDATA_FILE_OK) {
+  if (error == DRIVE_FILE_OK) {
     scoped_ptr<DocumentEntry> doc_entry(DocumentEntry::ExtractAndParse(*data));
     if (doc_entry.get())
       fresh_entry.reset(resource_metadata_->FromDocumentEntry(*doc_entry));
     if (!fresh_entry.get() || !fresh_entry->AsDriveFile()) {
       LOG(ERROR) << "Got invalid entry from server for " << params.resource_id;
-      error = GDATA_FILE_ERROR_FAILED;
+      error = DRIVE_FILE_ERROR_FAILED;
     }
   }
 
-  if (error != GDATA_FILE_OK) {
+  if (error != DRIVE_FILE_OK) {
     if (!params.get_file_callback.is_null()) {
       params.get_file_callback.Run(error,
                                    cache_file_path,
                                    params.mime_type,
                                    REGULAR_FILE);
     }
     return;
   }
 
   GURL content_url = fresh_entry->content_url();
@@ skipping 23 matching lines @@
 void GDataFileSystem::StartDownloadFileIfEnoughSpace(
     const GetFileFromCacheParams& params,
     const GURL& content_url,
     const FilePath& cache_file_path,
     bool* has_enough_space) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 
   if (!*has_enough_space) {
     // If no enough space, return PLATFORM_FILE_ERROR_NO_SPACE.
     if (!params.get_file_callback.is_null()) {
-      params.get_file_callback.Run(GDATA_FILE_ERROR_NO_SPACE,
+      params.get_file_callback.Run(DRIVE_FILE_ERROR_NO_SPACE,
                                    cache_file_path,
                                    params.mime_type,
                                    REGULAR_FILE);
     }
     return;
   }
 
   // We have enough disk space. Start downloading the file.
   drive_service_->DownloadFile(
       params.virtual_file_path,
@@ skipping 27 matching lines @@
   LoadFeedIfNeeded(
       base::Bind(&GDataFileSystem::GetEntryInfoByPathOnUIThreadAfterLoad,
                  ui_weak_ptr_,
                  file_path,
                  callback));
 }
 
 void GDataFileSystem::GetEntryInfoByPathOnUIThreadAfterLoad(
     const FilePath& file_path,
     const GetEntryInfoCallback& callback,
-    GDataFileError error) {
+    DriveFileError error) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   DCHECK(!callback.is_null());
 
-  if (error != GDATA_FILE_OK) {
+  if (error != DRIVE_FILE_OK) {
     callback.Run(error, scoped_ptr<DriveEntryProto>());
     return;
   }
 
   resource_metadata_->GetEntryInfoByPath(
       file_path,
       base::Bind(&GDataFileSystem::GetEntryInfoByPathOnUIThreadAfterGetEntry,
                  ui_weak_ptr_,
                  callback));
 }
 
 void GDataFileSystem::GetEntryInfoByPathOnUIThreadAfterGetEntry(
     const GetEntryInfoCallback& callback,
-    GDataFileError error,
+    DriveFileError error,
     scoped_ptr<DriveEntryProto> entry_proto) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   DCHECK(!callback.is_null());
 
-  if (error != GDATA_FILE_OK) {
+  if (error != DRIVE_FILE_OK) {
     callback.Run(error, scoped_ptr<DriveEntryProto>());
     return;
   }
   DCHECK(entry_proto.get());
 
   CheckLocalModificationAndRun(entry_proto.Pass(), callback);
 }
 
 void GDataFileSystem::ReadDirectoryByPath(
     const FilePath& file_path,
@@ skipping 18 matching lines @@
   LoadFeedIfNeeded(
       base::Bind(&GDataFileSystem::ReadDirectoryByPathOnUIThreadAfterLoad,
                  ui_weak_ptr_,
                  file_path,
                  callback));
 }
 
 void GDataFileSystem::ReadDirectoryByPathOnUIThreadAfterLoad(
     const FilePath& file_path,
     const ReadDirectoryWithSettingCallback& callback,
-    GDataFileError error) {
+    DriveFileError error) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   DCHECK(!callback.is_null());
 
-  if (error != GDATA_FILE_OK) {
+  if (error != DRIVE_FILE_OK) {
     callback.Run(error,
                  hide_hosted_docs_,
                  scoped_ptr<DriveEntryProtoVector>());
     return;
   }
 
   resource_metadata_->ReadDirectoryByPath(
       file_path,
       base::Bind(&GDataFileSystem::ReadDirectoryByPathOnUIThreadAfterRead,
                  ui_weak_ptr_,
                  callback));
 }
 
 void GDataFileSystem::ReadDirectoryByPathOnUIThreadAfterRead(
     const ReadDirectoryWithSettingCallback& callback,
-    GDataFileError error,
+    DriveFileError error,
     scoped_ptr<DriveEntryProtoVector> entries) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   DCHECK(!callback.is_null());
 
-  if (error != GDATA_FILE_OK) {
+  if (error != DRIVE_FILE_OK) {
     callback.Run(error,
                  hide_hosted_docs_,
                  scoped_ptr<DriveEntryProtoVector>());
     return;
   }
   DCHECK(entries.get());  // This is valid for emptry directories too.
 
-  callback.Run(GDATA_FILE_OK, hide_hosted_docs_, entries.Pass());
+  callback.Run(DRIVE_FILE_OK, hide_hosted_docs_, entries.Pass());
 }
 
 void GDataFileSystem::RequestDirectoryRefresh(const FilePath& file_path) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI) ||
          BrowserThread::CurrentlyOn(BrowserThread::IO));
   RunTaskOnUIThread(
       base::Bind(&GDataFileSystem::RequestDirectoryRefreshOnUIThread,
                  ui_weak_ptr_,
                  file_path));
 }
 
 void GDataFileSystem::RequestDirectoryRefreshOnUIThread(
     const FilePath& file_path) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 
   // Make sure the destination directory exists.
   resource_metadata_->GetEntryInfoByPath(
       file_path,
       base::Bind(
           &GDataFileSystem::RequestDirectoryRefreshOnUIThreadAfterGetEntryInfo,
           ui_weak_ptr_,
           file_path));
 }
 
 void GDataFileSystem::RequestDirectoryRefreshOnUIThreadAfterGetEntryInfo(
     const FilePath& file_path,
-    GDataFileError error,
+    DriveFileError error,
     scoped_ptr<DriveEntryProto> entry_proto) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 
-  if (error != GDATA_FILE_OK ||
+  if (error != DRIVE_FILE_OK ||
       !entry_proto->file_info().is_directory()) {
     LOG(ERROR) << "Directory entry not found: " << file_path.value();
     return;
   }
 
   feed_loader_->LoadDirectoryFromServer(
       resource_metadata_->origin(),
       entry_proto->resource_id(),
       base::Bind(&GDataFileSystem::OnRequestDirectoryRefresh,
                  ui_weak_ptr_,
                  file_path));
 }
 
 void GDataFileSystem::OnRequestDirectoryRefresh(
     const FilePath& directory_path,
     GetDocumentsParams* params,
-    GDataFileError error) {
+    DriveFileError error) {
   DCHECK(params);
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 
-  if (error != GDATA_FILE_OK) {
+  if (error != DRIVE_FILE_OK) {
     LOG(ERROR) << "Failed to refresh directory: " << directory_path.value()
                << ": " << error;
     return;
   }
 
   int64 unused_delta_feed_changestamp = 0;
   FeedToFileResourceMapUmaStats unused_uma_stats;
   FileResourceIdMap file_map;
   GDataWapiFeedProcessor feed_processor(resource_metadata_.get());
   error = feed_processor.FeedToFileResourceMap(
       *params->feed_list,
       &file_map,
       &unused_delta_feed_changestamp,
       &unused_uma_stats);
-  if (error != GDATA_FILE_OK) {
+  if (error != DRIVE_FILE_OK) {
     LOG(ERROR) << "Failed to convert feed: " << directory_path.value()
                << ": " << error;
     return;
   }
 
   resource_metadata_->RefreshDirectory(
       params->directory_resource_id,
       file_map,
       base::Bind(&GDataFileSystem::OnDirectoryChangeFileMoveCallback,
                  ui_weak_ptr_));
@@ skipping 23 matching lines @@
   // UpdateFileByResourceIdOnUIThread(). crbug.com/143873
   resource_metadata_->GetEntryInfoByResourceId(
       resource_id,
       base::Bind(&GDataFileSystem::UpdateFileByEntryInfo,
                  ui_weak_ptr_,
                  callback));
 }
 
 void GDataFileSystem::UpdateFileByEntryInfo(
     const FileOperationCallback& callback,
-    GDataFileError error,
+    DriveFileError error,
     const FilePath& /* dive_file_path */,
     scoped_ptr<DriveEntryProto> entry_proto) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   DCHECK(!callback.is_null());
 
-  if (error != GDATA_FILE_OK) {
+  if (error != DRIVE_FILE_OK) {
     callback.Run(error);
     return;
   }
 
   DCHECK(entry_proto.get());
   if (entry_proto->file_info().is_directory()) {
-    callback.Run(GDATA_FILE_ERROR_NOT_FOUND);
+    callback.Run(DRIVE_FILE_ERROR_NOT_FOUND);
     return;
   }
 
   cache_->GetFileOnUIThread(
       entry_proto->resource_id(),
       entry_proto->file_specific_info().file_md5(),
       base::Bind(&GDataFileSystem::OnGetFileCompleteForUpdateFile,
                  ui_weak_ptr_,
                  callback));
 }
 
 void GDataFileSystem::OnGetFileCompleteForUpdateFile(
     const FileOperationCallback& callback,
-    GDataFileError error,
+    DriveFileError error,
     const std::string& resource_id,
     const std::string& /* md5 */,
     const FilePath& cache_file_path) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   DCHECK(!callback.is_null());
 
-  if (error != GDATA_FILE_OK) {
+  if (error != DRIVE_FILE_OK) {
     callback.Run(error);
     return;
   }
 
   // Gets the size of the cache file. Since the file is locally modified, the
   // file size information stored in DriveEntry is not correct.
-  GDataFileError* get_size_error = new GDataFileError(GDATA_FILE_ERROR_FAILED);
+  DriveFileError* get_size_error = new DriveFileError(DRIVE_FILE_ERROR_FAILED);
   int64* file_size = new int64(-1);
   util::PostBlockingPoolSequencedTaskAndReply(
       FROM_HERE,
       blocking_task_runner_,
       base::Bind(&GetLocalFileSizeOnBlockingPool,
                  cache_file_path,
                  get_size_error,
                  file_size),
       base::Bind(&GDataFileSystem::OnGetFileSizeCompleteForUpdateFile,
                  ui_weak_ptr_,
                  callback,
                  resource_id,
                  cache_file_path,
                  base::Owned(get_size_error),
                  base::Owned(file_size)));
 }
 
 void GDataFileSystem::OnGetFileSizeCompleteForUpdateFile(
     const FileOperationCallback& callback,
     const std::string& resource_id,
     const FilePath& cache_file_path,
-    GDataFileError* error,
+    DriveFileError* error,
     int64* file_size) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   DCHECK(!callback.is_null());
 
-  if (*error != GDATA_FILE_OK) {
+  if (*error != DRIVE_FILE_OK) {
     callback.Run(*error);
     return;
   }
 
   // TODO(satorux): GetEntryInfoByResourceId() is called twice for
   // UpdateFileByResourceIdOnUIThread(). crbug.com/143873
   resource_metadata_->GetEntryInfoByResourceId(
       resource_id,
       base::Bind(&GDataFileSystem::OnGetFileCompleteForUpdateFileByEntry,
           ui_weak_ptr_,
           callback,
           *file_size,
           cache_file_path));
 }
 
 void GDataFileSystem::OnGetFileCompleteForUpdateFileByEntry(
     const FileOperationCallback& callback,
     int64 file_size,
     const FilePath& cache_file_path,
-    GDataFileError error,
+    DriveFileError error,
     const FilePath& drive_file_path,
     scoped_ptr<DriveEntryProto> entry_proto) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   DCHECK(!callback.is_null());
 
-  if (error != GDATA_FILE_OK) {
+  if (error != DRIVE_FILE_OK) {
     callback.Run(error);
     return;
   }
 
   DCHECK(entry_proto.get());
   if (entry_proto->file_info().is_directory()) {
-    callback.Run(GDATA_FILE_ERROR_NOT_FOUND);
+    callback.Run(DRIVE_FILE_ERROR_NOT_FOUND);
     return;
   }
 
   uploader_->UploadExistingFile(
       GURL(entry_proto->upload_url()),
       drive_file_path,
       cache_file_path,
       file_size,
       entry_proto->file_specific_info().content_mime_type(),
       base::Bind(&GDataFileSystem::OnUpdatedFileUploaded,
                  ui_weak_ptr_,
                  callback));
 }
 
 void GDataFileSystem::OnUpdatedFileUploaded(
     const FileOperationCallback& callback,
-    GDataFileError error,
+    DriveFileError error,
     scoped_ptr<UploadFileInfo> upload_file_info) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   DCHECK(upload_file_info.get());
 
-  if (error != GDATA_FILE_OK) {
+  if (error != DRIVE_FILE_OK) {
     if (!callback.is_null())
       callback.Run(error);
     return;
   }
 
   AddUploadedFile(UPLOAD_EXISTING_FILE,
                   upload_file_info->gdata_path.DirName(),
                   upload_file_info->entry.Pass(),
                   upload_file_info->file_path,
                   DriveCache::FILE_OPERATION_MOVE,
@@ skipping 19 matching lines @@
       base::Bind(&GDataFileSystem::OnGetAboutResource,
                  ui_weak_ptr_,
                  callback) :
       base::Bind(&GDataFileSystem::OnGetAvailableSpace,
                  ui_weak_ptr_,
                  callback));
 }
 
 void GDataFileSystem::OnGetAvailableSpace(
     const GetAvailableSpaceCallback& callback,
-    GDataErrorCode status,
+    DriveErrorCode status,
     scoped_ptr<base::Value> data) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   DCHECK(!callback.is_null());
 
-  GDataFileError error = util::GDataToGDataFileError(status);
-  if (error != GDATA_FILE_OK) {
+  DriveFileError error = util::DriveToDriveFileError(status);
+  if (error != DRIVE_FILE_OK) {
     callback.Run(error, -1, -1);
     return;
   }
 
   scoped_ptr<AccountMetadataFeed> feed;
   if (data.get())
     feed = AccountMetadataFeed::CreateFrom(*data);
   if (!feed.get()) {
-    callback.Run(GDATA_FILE_ERROR_FAILED, -1, -1);
+    callback.Run(DRIVE_FILE_ERROR_FAILED, -1, -1);
     return;
   }
 
-  callback.Run(GDATA_FILE_OK,
+  callback.Run(DRIVE_FILE_OK,
                feed->quota_bytes_total(),
                feed->quota_bytes_used());
 }
 
 void GDataFileSystem::OnGetAboutResource(
     const GetAvailableSpaceCallback& callback,
-    GDataErrorCode status,
+    DriveErrorCode status,
     scoped_ptr<base::Value> resource_json) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   DCHECK(!callback.is_null());
 
-  GDataFileError error = util::GDataToGDataFileError(status);
-  if (error != GDATA_FILE_OK) {
+  DriveFileError error = util::DriveToDriveFileError(status);
+  if (error != DRIVE_FILE_OK) {
     callback.Run(error, -1, -1);
     return;
   }
 
   scoped_ptr<AboutResource> about;
   if (resource_json.get())
     about = AboutResource::CreateFrom(*resource_json);
 
   if (!about.get()) {
-    callback.Run(GDATA_FILE_ERROR_FAILED, -1, -1);
+    callback.Run(DRIVE_FILE_ERROR_FAILED, -1, -1);
     return;
   }
 
-  callback.Run(GDATA_FILE_OK,
+  callback.Run(DRIVE_FILE_OK,
                about->quota_bytes_total(),
                about->quota_bytes_used());
 }
 
 void GDataFileSystem::OnCreateDirectoryCompleted(
     const CreateDirectoryParams& params,
-    GDataErrorCode status,
+    DriveErrorCode status,
     scoped_ptr<base::Value> data) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 
-  GDataFileError error = util::GDataToGDataFileError(status);
-  if (error != GDATA_FILE_OK) {
+  DriveFileError error = util::DriveToDriveFileError(status);
+  if (error != DRIVE_FILE_OK) {
     if (!params.callback.is_null())
       params.callback.Run(error);
 
     return;
   }
 
   base::DictionaryValue* dict_value = NULL;
   base::Value* created_entry = NULL;
   if (data.get() && data->GetAsDictionary(&dict_value) && dict_value)
     dict_value->Get("entry", &created_entry);
   error = AddNewDirectory(params.created_directory_path.DirName(),
                           created_entry);
 
-  if (error != GDATA_FILE_OK) {
+  if (error != DRIVE_FILE_OK) {
     if (!params.callback.is_null())
       params.callback.Run(error);
 
     return;
   }
 
   // Not done yet with recursive directory creation?
   if (params.target_directory_path != params.created_directory_path &&
       params.is_recursive) {
     CreateDirectory(params.target_directory_path,
                     params.is_exclusive,
                     params.is_recursive,
                     params.callback);
     return;
   }
 
   if (!params.callback.is_null()) {
     // Finally done with the create request.
-    params.callback.Run(GDATA_FILE_OK);
+    params.callback.Run(DRIVE_FILE_OK);
   }
 }
 
 void GDataFileSystem::OnSearch(const SearchCallback& callback,
                                GetDocumentsParams* params,
-                               GDataFileError error) {
+                               DriveFileError error) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 
-  if (error != GDATA_FILE_OK) {
+  if (error != DRIVE_FILE_OK) {
     if (!callback.is_null())
       callback.Run(error, GURL(), scoped_ptr<std::vector<SearchResultInfo> >());
     return;
   }
 
   // The search results will be returned using virtual directory.
   // The directory is not really part of the file system, so it has no parent or
   // root.
   std::vector<SearchResultInfo>* results(new std::vector<SearchResultInfo>());
 
@@ skipping 95 matching lines @@
 }
 
 void GDataFileSystem::LoadRootFeedFromCacheForTesting() {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 
   feed_loader_->LoadFromCache(
       false,  // should_load_from_server.
       FileOperationCallback());
 }
 
-GDataFileError GDataFileSystem::UpdateFromFeedForTesting(
+DriveFileError GDataFileSystem::UpdateFromFeedForTesting(
     const std::vector<DocumentFeed*>& feed_list,
     int64 start_changestamp,
     int64 root_feed_changestamp) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 
   return feed_loader_->UpdateFromFeed(feed_list,
                                       start_changestamp,
                                       root_feed_changestamp);
 }
 
 void GDataFileSystem::OnFilePathUpdated(const FileOperationCallback& callback,
-                                        GDataFileError error,
+                                        DriveFileError error,
                                         const FilePath& /* file_path */) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   if (!callback.is_null())
     callback.Run(error);
 }
 
 void GDataFileSystem::OnCopyDocumentCompleted(
     const FilePath& dir_path,
     const FileOperationCallback& callback,
-    GDataErrorCode status,
+    DriveErrorCode status,
     scoped_ptr<base::Value> data) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   DCHECK(!callback.is_null());
 
-  GDataFileError error = util::GDataToGDataFileError(status);
-  if (error != GDATA_FILE_OK) {
+  DriveFileError error = util::DriveToDriveFileError(status);
+  if (error != DRIVE_FILE_OK) {
     callback.Run(error);
     return;
   }
 
   scoped_ptr<DocumentEntry> doc_entry(DocumentEntry::ExtractAndParse(*data));
   if (!doc_entry.get()) {
-    callback.Run(GDATA_FILE_ERROR_FAILED);
+    callback.Run(DRIVE_FILE_ERROR_FAILED);
     return;
   }
 
   DriveEntry* entry = resource_metadata_->FromDocumentEntry(*doc_entry);
   if (!entry) {
-    callback.Run(GDATA_FILE_ERROR_FAILED);
+    callback.Run(DRIVE_FILE_ERROR_FAILED);
     return;
   }
 
   // |entry| was added in the root directory on the server, so we should
   // first add it to |root_| to mirror the state and then move it to the
   // destination directory by MoveEntryFromRootDirectory().
   resource_metadata_->AddEntryToDirectory(
       resource_metadata_->root(),
       entry,
       base::Bind(&GDataFileSystem::MoveEntryFromRootDirectory,
                  ui_weak_ptr_,
                  dir_path,
                  callback));
 }
 
 void GDataFileSystem::OnMoveEntryFromRootDirectoryCompleted(
     const FileOperationCallback& callback,
     const FilePath& file_path,
     const FilePath& dir_path,
-    GDataErrorCode status,
+    DriveErrorCode status,
     const GURL& document_url) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   DCHECK(!callback.is_null());
 
-  GDataFileError error = util::GDataToGDataFileError(status);
-  if (error == GDATA_FILE_OK) {
+  DriveFileError error = util::DriveToDriveFileError(status);
+  if (error == DRIVE_FILE_OK) {
     DriveEntry* entry = resource_metadata_->FindEntryByPathSync(file_path);
     if (entry) {
       DCHECK_EQ(resource_metadata_->root(), entry->parent());
       resource_metadata_->MoveEntryToDirectory(
           dir_path,
           entry,
           base::Bind(
               &GDataFileSystem::NotifyAndRunFileOperationCallback,
               ui_weak_ptr_,
               callback));
       return;
     } else {
-      error = GDATA_FILE_ERROR_NOT_FOUND;
+      error = DRIVE_FILE_ERROR_NOT_FOUND;
     }
   }
 
   callback.Run(error);
 }
 
 void GDataFileSystem::OnRemovedDocument(
     const FileOperationCallback& callback,
     const FilePath& file_path,
-    GDataErrorCode status,
+    DriveErrorCode status,
     const GURL& document_url) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 
-  GDataFileError error = util::GDataToGDataFileError(status);
+  DriveFileError error = util::DriveToDriveFileError(status);
 
-  if (error == GDATA_FILE_OK)
+  if (error == DRIVE_FILE_OK)
     error = RemoveEntryAndCacheLocally(file_path);
 
   if (!callback.is_null()) {
     callback.Run(error);
   }
 }
 
 void GDataFileSystem::OnFileDownloaded(
     const GetFileFromCacheParams& params,
-    GDataErrorCode status,
+    DriveErrorCode status,
     const GURL& content_url,
     const FilePath& downloaded_file_path) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 
   // If user cancels download of a pinned-but-not-fetched file, mark file as
   // unpinned so that we do not sync the file again.
-  if (status == GDATA_CANCELLED) {
+  if (status == DRIVE_CANCELLED) {
     cache_->GetCacheEntryOnUIThread(
         params.resource_id,
         params.md5,
         base::Bind(&GDataFileSystem::UnpinIfPinned,
                    ui_weak_ptr_,
                    params.resource_id,
                    params.md5));
   }
 
   // At this point, the disk can be full or nearly full for several reasons:
@@ skipping 28 matching lines @@
     const DriveCacheEntry& cache_entry) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   // TODO(hshi): http://crbug.com/127138 notify when file properties change.
   // This allows file manager to clear the "Available offline" checkbox.
   if (success && cache_entry.is_pinned())
     cache_->UnpinOnUIThread(resource_id, md5, CacheOperationCallback());
 }
 
 void GDataFileSystem::OnFileDownloadedAndSpaceChecked(
     const GetFileFromCacheParams& params,
-    GDataErrorCode status,
+    DriveErrorCode status,
     const GURL& content_url,
     const FilePath& downloaded_file_path,
     bool* has_enough_space) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 
-  GDataFileError error = util::GDataToGDataFileError(status);
+  DriveFileError error = util::DriveToDriveFileError(status);
 
   // Make sure that downloaded file is properly stored in cache. We don't have
   // to wait for this operation to finish since the user can already use the
   // downloaded file.
-  if (error == GDATA_FILE_OK) {
+  if (error == DRIVE_FILE_OK) {
     if (*has_enough_space) {
       cache_->StoreOnUIThread(
           params.resource_id,
           params.md5,
           downloaded_file_path,
           DriveCache::FILE_OPERATION_MOVE,
           base::Bind(&GDataFileSystem::OnDownloadStoredToCache,
                      ui_weak_ptr_));
     } else {
       // If we don't have enough space, remove the downloaded file, and
       // report "no space" error.
       util::PostBlockingPoolSequencedTask(
           FROM_HERE,
           blocking_task_runner_,
           base::Bind(base::IgnoreResult(&file_util::Delete),
                      downloaded_file_path,
                      false /* recursive*/));
-      error = GDATA_FILE_ERROR_NO_SPACE;
+      error = DRIVE_FILE_ERROR_NO_SPACE;
     }
   }
 
   if (!params.get_file_callback.is_null()) {
     params.get_file_callback.Run(error,
                                  downloaded_file_path,
                                  params.mime_type,
                                  REGULAR_FILE);
   }
 }
 
-void GDataFileSystem::OnDownloadStoredToCache(GDataFileError error,
+void GDataFileSystem::OnDownloadStoredToCache(DriveFileError error,
                                               const std::string& resource_id,
                                               const std::string& md5) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   // Nothing much to do here for now.
 }
 
 void GDataFileSystem::RenameEntryLocally(
     const FilePath& file_path,
     const FilePath::StringType& new_name,
     const FileMoveCallback& callback,
-    GDataErrorCode status,
+    DriveErrorCode status,
     const GURL& document_url) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 
-  const GDataFileError error = util::GDataToGDataFileError(status);
-  if (error != GDATA_FILE_OK) {
+  const DriveFileError error = util::DriveToDriveFileError(status);
+  if (error != DRIVE_FILE_OK) {
     if (!callback.is_null())
       callback.Run(error, FilePath());
     return;
   }
 
   DriveEntry* entry = resource_metadata_->FindEntryByPathSync(file_path);
   if (!entry) {
     if (!callback.is_null())
-      callback.Run(GDATA_FILE_ERROR_NOT_FOUND, FilePath());
+      callback.Run(DRIVE_FILE_ERROR_NOT_FOUND, FilePath());
     return;
   }
 
   DCHECK(entry->parent());
   entry->set_title(new_name);
   // After changing the title of the entry, call MoveEntryToDirectory() to
   // remove the entry from its parent directory and then add it back in order to
   // go through the file name de-duplication.
   // TODO(achuith/satorux/zel): This code is fragile. The title has been
   // changed, but not the file_name. MoveEntryToDirectory calls RemoveChild to
   // remove the child based on the old file_name, and then re-adds the child by
   // first assigning the new title to file_name. http://crbug.com/30157
   resource_metadata_->MoveEntryToDirectory(
       entry->parent()->GetFilePath(),
       entry,
       base::Bind(&GDataFileSystem::NotifyAndRunFileMoveCallback,
                  ui_weak_ptr_,
                  callback));
 }
 
 void GDataFileSystem::MoveEntryToRootDirectoryLocally(
     const FileMoveCallback& callback,
     const FilePath& file_path,
     const FilePath& dir_path,
-    GDataErrorCode status,
+    DriveErrorCode status,
     const GURL& document_url) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   DCHECK(!callback.is_null());
 
-  const GDataFileError error = util::GDataToGDataFileError(status);
-  if (error != GDATA_FILE_OK) {
+  const DriveFileError error = util::DriveToDriveFileError(status);
+  if (error != DRIVE_FILE_OK) {
     callback.Run(error, FilePath());
     return;
   }
 
   DriveEntry* entry = resource_metadata_->FindEntryByPathSync(file_path);
   if (!entry) {
-    callback.Run(GDATA_FILE_ERROR_NOT_FOUND, FilePath());
+    callback.Run(DRIVE_FILE_ERROR_NOT_FOUND, FilePath());
     return;
   }
 
   resource_metadata_->MoveEntryToDirectory(
       resource_metadata_->root()->GetFilePath(),
       entry,
       base::Bind(&GDataFileSystem::NotifyAndRunFileMoveCallback,
                  ui_weak_ptr_,
                  callback));
 }
 
 void GDataFileSystem::NotifyAndRunFileMoveCallback(
     const FileMoveCallback& callback,
-    GDataFileError error,
+    DriveFileError error,
     const FilePath& moved_file_path) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 
-  if (error == GDATA_FILE_OK)
+  if (error == DRIVE_FILE_OK)
     OnDirectoryChanged(moved_file_path.DirName());
 
   if (!callback.is_null())
     callback.Run(error, moved_file_path);
 }
 
 void GDataFileSystem::NotifyAndRunFileOperationCallback(
     const FileOperationCallback& callback,
-    GDataFileError error,
+    DriveFileError error,
     const FilePath& moved_file_path) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   DCHECK(!callback.is_null());
 
-  if (error == GDATA_FILE_OK)
+  if (error == DRIVE_FILE_OK)
     OnDirectoryChanged(moved_file_path.DirName());
 
   callback.Run(error);
 }
 
 void GDataFileSystem::OnDirectoryChangeFileMoveCallback(
-    GDataFileError error,
+    DriveFileError error,
     const FilePath& directory_path) {
-  if (error == GDATA_FILE_OK)
+  if (error == DRIVE_FILE_OK)
     OnDirectoryChanged(directory_path);
 }
 
-GDataFileError GDataFileSystem::RemoveEntryAndCacheLocally(
+DriveFileError GDataFileSystem::RemoveEntryAndCacheLocally(
     const FilePath& file_path) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 
   std::string resource_id;
-  GDataFileError error = RemoveEntryLocally(file_path, &resource_id);
-  if (error != GDATA_FILE_OK)
+  DriveFileError error = RemoveEntryLocally(file_path, &resource_id);
+  if (error != DRIVE_FILE_OK)
     return error;
 
   // If resource_id is not empty, remove its corresponding file from cache.
   if (!resource_id.empty())
     cache_->RemoveOnUIThread(resource_id, CacheOperationCallback());
 
-  return GDATA_FILE_OK;
+  return DRIVE_FILE_OK;
 }
 
 void GDataFileSystem::RemoveStaleEntryOnUpload(
     const std::string& resource_id,
     DriveDirectory* parent_dir,
     const FileMoveCallback& callback,
     DriveEntry* existing_entry) {
   if (existing_entry &&
       // This should always match, but just in case.
       existing_entry->parent() == parent_dir) {
     resource_metadata_->RemoveEntryFromParent(existing_entry, callback);
   } else {
-    callback.Run(GDATA_FILE_ERROR_NOT_FOUND, FilePath());
+    callback.Run(DRIVE_FILE_ERROR_NOT_FOUND, FilePath());
     LOG(ERROR) << "Entry for the existing file not found: " << resource_id;
   }
 }
 
 void GDataFileSystem::NotifyFileSystemMounted() {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 
   DVLOG(1) << "File System is mounted";
   // Notify the observers that the file system is mounted.
   FOR_EACH_OBSERVER(GDataFileSystemInterface::Observer, observers_,
                     OnFileSystemMounted());
 }
 
 void GDataFileSystem::NotifyFileSystemToBeUnmounted() {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 
   DVLOG(1) << "File System is to be unmounted";
   // Notify the observers that the file system is being unmounted.
   FOR_EACH_OBSERVER(GDataFileSystemInterface::Observer, observers_,
                     OnFileSystemBeingUnmounted());
 }
 
 void GDataFileSystem::NotifyInitialLoadFinishedAndRun(
     const FileOperationCallback& callback,
-    GDataFileError error) {
+    DriveFileError error) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   DCHECK(!callback.is_null());
 
   // Notify the observers that root directory has been initialized.
   FOR_EACH_OBSERVER(GDataFileSystemInterface::Observer, observers_,
                     OnInitialLoadFinished());
 
   callback.Run(error);
 }
 
-GDataFileError GDataFileSystem::AddNewDirectory(
+DriveFileError GDataFileSystem::AddNewDirectory(
     const FilePath& directory_path, base::Value* entry_value) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 
   if (!entry_value)
-    return GDATA_FILE_ERROR_FAILED;
+    return DRIVE_FILE_ERROR_FAILED;
 
   scoped_ptr<DocumentEntry> doc_entry(DocumentEntry::CreateFrom(*entry_value));
 
   if (!doc_entry.get())
-    return GDATA_FILE_ERROR_FAILED;
+    return DRIVE_FILE_ERROR_FAILED;
 
   // Find parent directory element within the cached file system snapshot.
   DriveEntry* entry = resource_metadata_->FindEntryByPathSync(directory_path);
   if (!entry)
-    return GDATA_FILE_ERROR_FAILED;
+    return DRIVE_FILE_ERROR_FAILED;
 
   // Check if parent is a directory since in theory since this is a callback
   // something could in the meantime have nuked the parent dir and created a
   // file with the exact same name.
   DriveDirectory* parent_dir = entry->AsDriveDirectory();
   if (!parent_dir)
-    return GDATA_FILE_ERROR_FAILED;
+    return DRIVE_FILE_ERROR_FAILED;
 
   DriveEntry* new_entry =
       resource_metadata_->FromDocumentEntry(*doc_entry);
   if (!new_entry)
-    return GDATA_FILE_ERROR_FAILED;
+    return DRIVE_FILE_ERROR_FAILED;
 
   resource_metadata_->AddEntryToDirectory(
       parent_dir,
       new_entry,
       base::Bind(&GDataFileSystem::NotifyAndRunFileMoveCallback,
                  ui_weak_ptr_,
                  FileMoveCallback()));
-  return GDATA_FILE_OK;
+  return DRIVE_FILE_OK;
 }
 
 GDataFileSystem::FindMissingDirectoryResult
 GDataFileSystem::FindFirstMissingParentDirectory(
     const FilePath& directory_path,
     GURL* last_dir_content_url,
     FilePath* first_missing_parent_path) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 
   // Let's find which how deep is the existing directory structure and
@@ skipping 15 matching lines @@
         return FOUND_INVALID;
       }
     } else {
       *first_missing_parent_path = current_path;
       return FOUND_MISSING;
     }
   }
   return DIRECTORY_ALREADY_PRESENT;
 }
 
-GDataFileError GDataFileSystem::RemoveEntryLocally(
+DriveFileError GDataFileSystem::RemoveEntryLocally(
     const FilePath& file_path, std::string* resource_id) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 
   resource_id->clear();
 
   // Find directory element within the cached file system snapshot.
   DriveEntry* entry = resource_metadata_->FindEntryByPathSync(file_path);
 
   if (!entry)
-    return GDATA_FILE_ERROR_NOT_FOUND;
+    return DRIVE_FILE_ERROR_NOT_FOUND;
 
   // You can't remove root element.
   if (!entry->parent())
-    return GDATA_FILE_ERROR_ACCESS_DENIED;
+    return DRIVE_FILE_ERROR_ACCESS_DENIED;
 
   // If it's a file (only files have resource id), get its resource id so that
   // we can remove it after releasing the auto lock.
   if (entry->AsDriveFile())
     *resource_id = entry->AsDriveFile()->resource_id();
 
   resource_metadata_->RemoveEntryFromParent(
       entry,
       base::Bind(&GDataFileSystem::OnDirectoryChangeFileMoveCallback,
                  ui_weak_ptr_));
-  return GDATA_FILE_OK;
+  return DRIVE_FILE_OK;
 }
 
 void GDataFileSystem::AddUploadedFile(
     UploadMode upload_mode,
     const FilePath& virtual_dir_path,
     scoped_ptr<DocumentEntry> entry,
     const FilePath& file_content_path,
     DriveCache::FileOperationType cache_operation,
     const base::Closure& callback) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
@@ skipping 60 matching lines @@
   if (upload_mode == UPLOAD_EXISTING_FILE) {
     // Remove an existing entry, which should be present.
     resource_metadata_->GetEntryByResourceIdAsync(
         resource_id,
         base::Bind(&GDataFileSystem::RemoveStaleEntryOnUpload,
                    ui_weak_ptr_,
                    resource_id,
                    parent_dir,
                    file_move_callback));
   } else {
-    file_move_callback.Run(GDATA_FILE_OK, FilePath());
+    file_move_callback.Run(DRIVE_FILE_OK, FilePath());
   }
 }
 
 void GDataFileSystem::ContinueAddUploadedFile(
     AddUploadedFileParams* params,
-    GDataFileError error,
+    DriveFileError error,
     const FilePath& file_path) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
-  DCHECK_EQ(GDATA_FILE_OK, error);
+  DCHECK_EQ(DRIVE_FILE_OK, error);
   DCHECK(params->new_entry.get());
   DriveFile* file = params->new_entry->AsDriveFile();
   DCHECK(file);
 
   params->resource_id = file->resource_id();
   params->md5 = file->file_md5();
   resource_metadata_->AddEntryToDirectory(
       params->parent_dir,
       params->new_entry.release(),
       base::Bind(&GDataFileSystem::NotifyAndRunFileMoveCallback,
                  ui_weak_ptr_,
                  base::Bind(&GDataFileSystem::AddUploadedFileToCache,
                             ui_weak_ptr_,
                             base::Owned(params))));
 }
 
 void GDataFileSystem::AddUploadedFileToCache(
     AddUploadedFileParams* params,
-    GDataFileError error,
+    DriveFileError error,
     const FilePath& file_path) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 
   if (params->upload_mode == UPLOAD_NEW_FILE) {
     // Add the file to the cache if we have uploaded a new file.
     cache_->StoreOnUIThread(params->resource_id,
                             params->md5,
                             params->file_content_path,
                             params->cache_operation,
                             base::Bind(&OnCacheUpdatedForAddUploadedFile,
@@ skipping 115 matching lines @@
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 
   // If the file is already opened, it cannot be opened again before closed.
   // This is for avoiding simultaneous modification to the file, and moreover
   // to avoid an inconsistent cache state (suppose an operation sequence like
   // Open->Open->modify->Close->modify->Close; the second modify may not be
   // synchronized to the server since it is already Closed on the cache).
   if (open_files_.find(file_path) != open_files_.end()) {
     MessageLoop::current()->PostTask(
         FROM_HERE,
-        base::Bind(callback, GDATA_FILE_ERROR_IN_USE, FilePath()));
+        base::Bind(callback, DRIVE_FILE_ERROR_IN_USE, FilePath()));
     return;
   }
   open_files_.insert(file_path);
 
   resource_metadata_->GetEntryInfoByPath(
       file_path,
       base::Bind(&GDataFileSystem::OnGetEntryInfoCompleteForOpenFile,
                  ui_weak_ptr_,
                  file_path,
                  base::Bind(&GDataFileSystem::OnOpenFileFinished,
                             ui_weak_ptr_,
                             file_path,
                             callback)));
 }
 
 void GDataFileSystem::OnGetEntryInfoCompleteForOpenFile(
     const FilePath& file_path,
     const OpenFileCallback& callback,
-    GDataFileError error,
+    DriveFileError error,
     scoped_ptr<DriveEntryProto> entry_proto) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 
   if (entry_proto.get() && !entry_proto->has_file_specific_info())
-    error = GDATA_FILE_ERROR_NOT_FOUND;
+    error = DRIVE_FILE_ERROR_NOT_FOUND;
 
-  if (error == GDATA_FILE_OK) {
+  if (error == DRIVE_FILE_OK) {
     if (entry_proto->file_specific_info().file_md5().empty() ||
         entry_proto->file_specific_info().is_hosted_document()) {
       // No support for opening a directory or hosted document.
-      error = GDATA_FILE_ERROR_INVALID_OPERATION;
+      error = DRIVE_FILE_ERROR_INVALID_OPERATION;
     }
   }
 
-  if (error != GDATA_FILE_OK) {
+  if (error != DRIVE_FILE_OK) {
     if (!callback.is_null())
       callback.Run(error, FilePath());
     return;
   }
 
   DCHECK(!entry_proto->resource_id().empty());
   GetResolvedFileByPath(
       file_path,
       base::Bind(&GDataFileSystem::OnGetFileCompleteForOpenFile,
                  ui_weak_ptr_,
                  callback,
                  GetFileCompleteForOpenParams(
                      entry_proto->resource_id(),
                      entry_proto->file_specific_info().file_md5())),
       GetContentCallback(),
       error,
       entry_proto.get());
 }
 
 void GDataFileSystem::OnGetFileCompleteForOpenFile(
     const OpenFileCallback& callback,
     const GetFileCompleteForOpenParams& entry_proto,
-    GDataFileError error,
+    DriveFileError error,
     const FilePath& file_path,
     const std::string& mime_type,
     DriveFileType file_type) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 
-  if (error != GDATA_FILE_OK) {
+  if (error != DRIVE_FILE_OK) {
     if (!callback.is_null())
       callback.Run(error, FilePath());
     return;
   }
 
   // OpenFileOnUIThread ensures that the file is a regular file.
   DCHECK_EQ(REGULAR_FILE, file_type);
 
   cache_->MarkDirtyOnUIThread(
       entry_proto.resource_id,
       entry_proto.md5,
       base::Bind(&GDataFileSystem::OnMarkDirtyInCacheCompleteForOpenFile,
                  ui_weak_ptr_,
                  callback));
 }
 
 void GDataFileSystem::OnMarkDirtyInCacheCompleteForOpenFile(
     const OpenFileCallback& callback,
-    GDataFileError error,
+    DriveFileError error,
     const std::string& resource_id,
     const std::string& md5,
     const FilePath& cache_file_path) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 
   if (!callback.is_null())
     callback.Run(error, cache_file_path);
 }
 
 void GDataFileSystem::OnOpenFileFinished(const FilePath& file_path,
                                          const OpenFileCallback& callback,
-                                         GDataFileError result,
+                                         DriveFileError result,
                                          const FilePath& cache_file_path) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 
   // All the invocation of |callback| from operations initiated from OpenFile
   // must go through here. Removes the |file_path| from the remembered set when
   // the file was not successfully opened.
-  if (result != GDATA_FILE_OK)
+  if (result != DRIVE_FILE_OK)
     open_files_.erase(file_path);
 
   if (!callback.is_null())
     callback.Run(result, cache_file_path);
 }
 
 void GDataFileSystem::CloseFile(const FilePath& file_path,
                                 const FileOperationCallback& callback) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI) ||
          BrowserThread::CurrentlyOn(BrowserThread::IO));
   DCHECK(!callback.is_null());
 
   RunTaskOnUIThread(base::Bind(&GDataFileSystem::CloseFileOnUIThread,
                                ui_weak_ptr_,
                                file_path,
                                CreateRelayCallback(callback)));
 }
 
 void GDataFileSystem::CloseFileOnUIThread(
     const FilePath& file_path,
     const FileOperationCallback& callback) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   DCHECK(!callback.is_null());
 
   if (open_files_.find(file_path) == open_files_.end()) {
     // The file is not being opened.
     MessageLoop::current()->PostTask(
         FROM_HERE,
-        base::Bind(callback, GDATA_FILE_ERROR_NOT_FOUND));
+        base::Bind(callback, DRIVE_FILE_ERROR_NOT_FOUND));
     return;
   }
 
   // Step 1 of CloseFile: Get resource_id and md5 for |file_path|.
   resource_metadata_->GetEntryInfoByPath(
       file_path,
       base::Bind(&GDataFileSystem::CloseFileOnUIThreadAfterGetEntryInfo,
                  ui_weak_ptr_,
                  file_path,
                  base::Bind(&GDataFileSystem::CloseFileOnUIThreadFinalize,
                             ui_weak_ptr_,
                             file_path,
                             callback)));
 }
 
 void GDataFileSystem::CloseFileOnUIThreadAfterGetEntryInfo(
     const FilePath& file_path,
     const FileOperationCallback& callback,
-    GDataFileError error,
+    DriveFileError error,
     scoped_ptr<DriveEntryProto> entry_proto) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   DCHECK(!callback.is_null());
 
   if (entry_proto.get() && !entry_proto->has_file_specific_info())
-    error = GDATA_FILE_ERROR_NOT_FOUND;
+    error = DRIVE_FILE_ERROR_NOT_FOUND;
 
-  if (error != GDATA_FILE_OK) {
+  if (error != DRIVE_FILE_OK) {
     callback.Run(error);
     return;
   }
 
   // Step 2 of CloseFile: Commit the modification in cache. This will trigger
   // background upload.
   // TODO(benchan,kinaba): Call ClearDirtyInCache instead of CommitDirtyInCache
   // if the file has not been modified. Come up with a way to detect the
   // intactness effectively, or provide a method for user to declare it when
   // calling CloseFile().
   cache_->CommitDirtyOnUIThread(
       entry_proto->resource_id(),
       entry_proto->file_specific_info().file_md5(),
       base::Bind(&GDataFileSystem::CloseFileOnUIThreadAfterCommitDirtyInCache,
                  ui_weak_ptr_,
                  callback));
 }
 
 void GDataFileSystem::CloseFileOnUIThreadAfterCommitDirtyInCache(
     const FileOperationCallback& callback,
-    GDataFileError error,
+    DriveFileError error,
     const std::string& /* resource_id */,
     const std::string& /* md5 */) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   DCHECK(!callback.is_null());
 
   callback.Run(error);
 }
 
 void GDataFileSystem::CloseFileOnUIThreadFinalize(
     const FilePath& file_path,
     const FileOperationCallback& callback,
-    GDataFileError result) {
+    DriveFileError result) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   DCHECK(!callback.is_null());
 
   // Step 3 of CloseFile.
   // All the invocation of |callback| from operations initiated from CloseFile
   // must go through here. Removes the |file_path| from the remembered set so
   // that subsequent operations can open the file again.
   open_files_.erase(file_path);
 
   // Then invokes the user-supplied callback function.
   callback.Run(result);
 }
 
 void GDataFileSystem::CheckLocalModificationAndRun(
     scoped_ptr<DriveEntryProto> entry_proto,
     const GetEntryInfoCallback& callback) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   DCHECK(entry_proto.get());
   DCHECK(!callback.is_null());
 
   // For entries that will never be cached, use the original entry info as is.
   if (!entry_proto->has_file_specific_info() ||
       entry_proto->file_specific_info().is_hosted_document()) {
-    callback.Run(GDATA_FILE_OK, entry_proto.Pass());
+    callback.Run(DRIVE_FILE_OK, entry_proto.Pass());
     return;
   }
 
   // Checks if the file is cached and modified locally.
   const std::string resource_id = entry_proto->resource_id();
   const std::string md5 = entry_proto->file_specific_info().file_md5();
   cache_->GetCacheEntryOnUIThread(
       resource_id,
       md5,
       base::Bind(
           &GDataFileSystem::CheckLocalModificationAndRunAfterGetCacheEntry,
           ui_weak_ptr_, base::Passed(&entry_proto), callback));
 }
 
 void GDataFileSystem::CheckLocalModificationAndRunAfterGetCacheEntry(
     scoped_ptr<DriveEntryProto> entry_proto,
     const GetEntryInfoCallback& callback,
     bool success,
     const DriveCacheEntry& cache_entry) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   DCHECK(!callback.is_null());
 
   // When no dirty cache is found, use the original entry info as is.
   if (!success || !cache_entry.is_dirty()) {
-    callback.Run(GDATA_FILE_OK, entry_proto.Pass());
+    callback.Run(DRIVE_FILE_OK, entry_proto.Pass());
     return;
   }
 
   // Gets the cache file path.
   const std::string& resource_id = entry_proto->resource_id();
   const std::string& md5 = entry_proto->file_specific_info().file_md5();
   cache_->GetFileOnUIThread(
       resource_id,
       md5,
       base::Bind(
           &GDataFileSystem::CheckLocalModificationAndRunAfterGetCacheFile,
           ui_weak_ptr_, base::Passed(&entry_proto), callback));
 }
 
 void GDataFileSystem::CheckLocalModificationAndRunAfterGetCacheFile(
     scoped_ptr<DriveEntryProto> entry_proto,
     const GetEntryInfoCallback& callback,
-    GDataFileError error,
+    DriveFileError error,
     const std::string& resource_id,
     const std::string& md5,
     const FilePath& local_cache_path) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   DCHECK(!callback.is_null());
 
   // When no dirty cache is found, use the original entry info as is.
-  if (error != GDATA_FILE_OK) {
-    callback.Run(GDATA_FILE_OK, entry_proto.Pass());
+  if (error != DRIVE_FILE_OK) {
+    callback.Run(DRIVE_FILE_OK, entry_proto.Pass());
     return;
   }
 
   // If the cache is dirty, obtain the file info from the cache file itself.
   base::PlatformFileInfo* file_info = new base::PlatformFileInfo;
   bool* get_file_info_result = new bool(false);
   util::PostBlockingPoolSequencedTaskAndReply(
       FROM_HERE,
       blocking_task_runner_,
       base::Bind(&GetFileInfoOnBlockingPool,
@@ skipping 10 matching lines @@
 
 void GDataFileSystem::CheckLocalModificationAndRunAfterGetFileInfo(
     scoped_ptr<DriveEntryProto> entry_proto,
     const GetEntryInfoCallback& callback,
     base::PlatformFileInfo* file_info,
     bool* get_file_info_result) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   DCHECK(!callback.is_null());
 
   if (!*get_file_info_result) {
-    callback.Run(GDATA_FILE_ERROR_NOT_FOUND, scoped_ptr<DriveEntryProto>());
+    callback.Run(DRIVE_FILE_ERROR_NOT_FOUND, scoped_ptr<DriveEntryProto>());
     return;
   }
 
   PlatformFileInfoProto entry_file_info;
   DriveEntry::ConvertPlatformFileInfoToProto(*file_info, &entry_file_info);
   *entry_proto->mutable_file_info() = entry_file_info;
-  callback.Run(GDATA_FILE_OK, entry_proto.Pass());
+  callback.Run(DRIVE_FILE_OK, entry_proto.Pass());
 }
 
 }  // namespace gdata