Rename GDataFileSystem* to DriveFileSystem*

chrome/browser/chromeos/gdata/drive_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 "chrome/browser/chromeos/gdata/drive_file_system.h"
 
 #include <set>
 #include <utility>
 
 #include "base/bind.h"
 #include "base/file_util.h"
 #include "base/json/json_file_value_serializer.h"
 #include "base/message_loop.h"
 #include "base/message_loop_proxy.h"
 #include "base/metrics/histogram.h"
@@ skipping 80 matching lines @@
 void OnAddUploadFileCompleted(
     const FileOperationCallback& callback,
     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 {
+class InitialLoadObserver : public DriveFileSystemInterface::Observer {
  public:
-  InitialLoadObserver(GDataFileSystemInterface* file_system,
+  InitialLoadObserver(DriveFileSystemInterface* 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_;
+  DriveFileSystemInterface* file_system_;
   base::Closure callback_;
 };
 
 // Gets the file size of |local_file|.
 void GetLocalFileSizeOnBlockingPool(const FilePath& local_file,
                                     DriveFileError* error,
                                     int64* file_size) {
   DCHECK(error);
   DCHECK(file_size);
 
@@ skipping 134 matching lines @@
     const GetEntryInfoWithFilePathCallback& callback,
     const FilePath& path,
     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 {
+// DriveFileSystem::CreateDirectoryParams struct implementation.
+struct DriveFileSystem::CreateDirectoryParams {
   CreateDirectoryParams(const FilePath& created_directory_path,
                         const FilePath& target_directory_path,
                         bool is_exclusive,
                         bool is_recursive,
                         const FileOperationCallback& callback);
   ~CreateDirectoryParams();
 
   const FilePath created_directory_path;
   const FilePath target_directory_path;
   const bool is_exclusive;
   const bool is_recursive;
   FileOperationCallback callback;
 };
 
-GDataFileSystem::CreateDirectoryParams::CreateDirectoryParams(
+DriveFileSystem::CreateDirectoryParams::CreateDirectoryParams(
     const FilePath& created_directory_path,
     const FilePath& target_directory_path,
     bool is_exclusive,
     bool is_recursive,
     const FileOperationCallback& callback)
     : created_directory_path(created_directory_path),
       target_directory_path(target_directory_path),
       is_exclusive(is_exclusive),
       is_recursive(is_recursive),
       callback(callback) {
 }
 
-GDataFileSystem::CreateDirectoryParams::~CreateDirectoryParams() {
+DriveFileSystem::CreateDirectoryParams::~CreateDirectoryParams() {
 }
 
-// GDataFileSystem::GetFileCompleteForOpenParams struct implementation.
-struct GDataFileSystem::GetFileCompleteForOpenParams {
+// DriveFileSystem::GetFileCompleteForOpenParams struct implementation.
+struct DriveFileSystem::GetFileCompleteForOpenParams {
   GetFileCompleteForOpenParams(const std::string& resource_id,
                                const std::string& md5);
   ~GetFileCompleteForOpenParams();
   std::string resource_id;
   std::string md5;
 };
 
-GDataFileSystem::GetFileCompleteForOpenParams::GetFileCompleteForOpenParams(
+DriveFileSystem::GetFileCompleteForOpenParams::GetFileCompleteForOpenParams(
     const std::string& resource_id,
     const std::string& md5)
     : resource_id(resource_id),
       md5(md5) {
 }
 
-GDataFileSystem::GetFileCompleteForOpenParams::~GetFileCompleteForOpenParams() {
+DriveFileSystem::GetFileCompleteForOpenParams::~GetFileCompleteForOpenParams() {
 }
 
-// GDataFileSystem::GetFileFromCacheParams struct implementation.
-struct GDataFileSystem::GetFileFromCacheParams {
+// DriveFileSystem::GetFileFromCacheParams struct implementation.
+struct DriveFileSystem::GetFileFromCacheParams {
   GetFileFromCacheParams(
       const FilePath& virtual_file_path,
       const FilePath& local_tmp_path,
       const GURL& content_url,
       const std::string& resource_id,
       const std::string& md5,
       const std::string& mime_type,
       const GetFileCallback& get_file_callback,
       const GetContentCallback& get_content_callback);
   ~GetFileFromCacheParams();
 
   FilePath virtual_file_path;
   FilePath local_tmp_path;
   GURL content_url;
   std::string resource_id;
   std::string md5;
   std::string mime_type;
   const GetFileCallback get_file_callback;
   const GetContentCallback get_content_callback;
 };
 
-GDataFileSystem::GetFileFromCacheParams::GetFileFromCacheParams(
+DriveFileSystem::GetFileFromCacheParams::GetFileFromCacheParams(
     const FilePath& virtual_file_path,
     const FilePath& local_tmp_path,
     const GURL& content_url,
     const std::string& resource_id,
     const std::string& md5,
     const std::string& mime_type,
     const GetFileCallback& get_file_callback,
     const GetContentCallback& get_content_callback)
     : virtual_file_path(virtual_file_path),
       local_tmp_path(local_tmp_path),
       content_url(content_url),
       resource_id(resource_id),
       md5(md5),
       mime_type(mime_type),
       get_file_callback(get_file_callback),
       get_content_callback(get_content_callback) {
 }
 
-GDataFileSystem::GetFileFromCacheParams::~GetFileFromCacheParams() {
+DriveFileSystem::GetFileFromCacheParams::~GetFileFromCacheParams() {
 }
 
-// GDataFileSystem::StartFileUploadParams implementation.
-struct GDataFileSystem::StartFileUploadParams {
+// DriveFileSystem::StartFileUploadParams implementation.
+struct DriveFileSystem::StartFileUploadParams {
   StartFileUploadParams(const FilePath& in_local_file_path,
                         const FilePath& in_remote_file_path,
                         const FileOperationCallback& in_callback)
       : local_file_path(in_local_file_path),
         remote_file_path(in_remote_file_path),
         callback(in_callback) {}
 
   const FilePath local_file_path;
   const FilePath remote_file_path;
   const FileOperationCallback callback;
 };
 
-// GDataFileSystem::AddUploadedFileParams implementation.
-struct GDataFileSystem::AddUploadedFileParams {
+// DriveFileSystem::AddUploadedFileParams implementation.
+struct DriveFileSystem::AddUploadedFileParams {
   AddUploadedFileParams(UploadMode upload_mode,
                         DriveDirectory* parent_dir,
                         scoped_ptr<DriveEntry> new_entry,
                         const FilePath& file_content_path,
                         DriveCache::FileOperationType cache_operation,
                         const base::Closure& callback)
   : upload_mode(upload_mode),
     parent_dir(parent_dir),
     new_entry(new_entry.Pass()),
     file_content_path(file_content_path),
     cache_operation(cache_operation),
     callback(callback) {
   }
 
   UploadMode upload_mode;
   DriveDirectory* parent_dir;
   scoped_ptr<DriveEntry> new_entry;
   FilePath file_content_path;
   DriveCache::FileOperationType cache_operation;
   base::Closure callback;
   std::string resource_id;
   std::string md5;
 };
 
 
-// GDataFileSystem class implementation.
+// DriveFileSystem class implementation.
 
-GDataFileSystem::GDataFileSystem(
+DriveFileSystem::DriveFileSystem(
     Profile* profile,
     DriveCache* cache,
     DriveServiceInterface* drive_service,
     GDataUploaderInterface* uploader,
     DriveWebAppsRegistryInterface* webapps_registry,
     base::SequencedTaskRunner* blocking_task_runner)
     : profile_(profile),
       cache_(cache),
       uploader_(uploader),
       drive_service_(drive_service),
       webapps_registry_(webapps_registry),
       update_timer_(true /* retain_user_task */, true /* is_repeating */),
       hide_hosted_docs_(false),
       blocking_task_runner_(blocking_task_runner),
       ui_weak_ptr_factory_(ALLOW_THIS_IN_INITIALIZER_LIST(this)),
       ui_weak_ptr_(ui_weak_ptr_factory_.GetWeakPtr()) {
   // Should be created from the file browser extension API on UI thread.
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 }
 
-void GDataFileSystem::Initialize() {
+void DriveFileSystem::Initialize() {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 
   drive_service_->Initialize(profile_);
 
   resource_metadata_.reset(new DriveResourceMetadata);
   feed_loader_.reset(new GDataWapiFeedLoader(resource_metadata_.get(),
                                              drive_service_,
                                              webapps_registry_,
                                              cache_,
                                              blocking_task_runner_));
   feed_loader_->AddObserver(this);
 
   PrefService* pref_service = profile_->GetPrefs();
   hide_hosted_docs_ = pref_service->GetBoolean(prefs::kDisableGDataHostedFiles);
 
   InitializePreferenceObserver();
 }
 
-void GDataFileSystem::CheckForUpdates() {
+void DriveFileSystem::CheckForUpdates() {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   ContentOrigin initial_origin = resource_metadata_->origin();
   if (initial_origin == FROM_SERVER) {
     resource_metadata_->set_origin(REFRESHING);
     feed_loader_->ReloadFromServerIfNeeded(
         initial_origin,
         resource_metadata_->largest_changestamp(),
-        base::Bind(&GDataFileSystem::OnUpdateChecked,
+        base::Bind(&DriveFileSystem::OnUpdateChecked,
                    ui_weak_ptr_,
                    initial_origin));
   }
 }
 
-void GDataFileSystem::OnUpdateChecked(ContentOrigin initial_origin,
+void DriveFileSystem::OnUpdateChecked(ContentOrigin initial_origin,
                                       DriveFileError error) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 
   if (error != DRIVE_FILE_OK)
     resource_metadata_->set_origin(initial_origin);
 }
 
-GDataFileSystem::~GDataFileSystem() {
+DriveFileSystem::~DriveFileSystem() {
   // 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.
   // This asynchronously cancels the URL fetch operations.
   drive_service_->CancelAll();
 }
 
-void GDataFileSystem::AddObserver(
-    GDataFileSystemInterface::Observer* observer) {
+void DriveFileSystem::AddObserver(
+    DriveFileSystemInterface::Observer* observer) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   observers_.AddObserver(observer);
 }
 
-void GDataFileSystem::RemoveObserver(
-    GDataFileSystemInterface::Observer* observer) {
+void DriveFileSystem::RemoveObserver(
+    DriveFileSystemInterface::Observer* observer) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   observers_.RemoveObserver(observer);
 }
 
-void GDataFileSystem::StartUpdates() {
+void DriveFileSystem::StartUpdates() {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 
   DCHECK(!update_timer_.IsRunning());
   update_timer_.Start(FROM_HERE,
                       base::TimeDelta::FromSeconds(
                           kGDataUpdateCheckIntervalInSec),
-                      base::Bind(&GDataFileSystem::CheckForUpdates,
+                      base::Bind(&DriveFileSystem::CheckForUpdates,
                           ui_weak_ptr_));
 }
 
-void GDataFileSystem::StopUpdates() {
+void DriveFileSystem::StopUpdates() {
   // If unmount request comes from filesystem side, this method may be called
   // twice. First is just after unmounting on filesystem, second is after
   // unmounting on filemanager on JS. In other words, if this is called from
   // GDataSystemService::RemoveDriveMountPoint(), this will be called again from
   // FileBrowserEventRouter::HandleRemoteUpdateRequestOnUIThread().
   // We choose to stopping updates asynchronous without waiting for filemanager,
   // rather than waiting for completion of unmounting on filemanager.
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   if (update_timer_.IsRunning())
     update_timer_.Stop();
 }
 
-void GDataFileSystem::GetEntryInfoByResourceId(
+void DriveFileSystem::GetEntryInfoByResourceId(
     const std::string& resource_id,
     const GetEntryInfoWithFilePathCallback& callback) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI) ||
          BrowserThread::CurrentlyOn(BrowserThread::IO));
   DCHECK(!callback.is_null());
 
   RunTaskOnUIThread(
-      base::Bind(&GDataFileSystem::GetEntryInfoByResourceIdOnUIThread,
+      base::Bind(&DriveFileSystem::GetEntryInfoByResourceIdOnUIThread,
                  ui_weak_ptr_,
                  resource_id,
                  CreateRelayCallback(callback)));
 }
 
-void GDataFileSystem::GetEntryInfoByResourceIdOnUIThread(
+void DriveFileSystem::GetEntryInfoByResourceIdOnUIThread(
     const std::string& resource_id,
     const GetEntryInfoWithFilePathCallback& callback) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   DCHECK(!callback.is_null());
 
   resource_metadata_->GetEntryByResourceIdAsync(resource_id,
-      base::Bind(&GDataFileSystem::GetEntryInfoByEntryOnUIThread,
+      base::Bind(&DriveFileSystem::GetEntryInfoByEntryOnUIThread,
                  ui_weak_ptr_,
                  callback));
 }
 
-void GDataFileSystem::GetEntryInfoByEntryOnUIThread(
+void DriveFileSystem::GetEntryInfoByEntryOnUIThread(
     const GetEntryInfoWithFilePathCallback& callback,
     DriveEntry* entry) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   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(DRIVE_FILE_ERROR_NOT_FOUND,
                  FilePath(),
                  scoped_ptr<DriveEntryProto>());
   }
 }
 
-void GDataFileSystem::LoadFeedIfNeeded(const FileOperationCallback& callback) {
+void DriveFileSystem::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, 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,
+        base::Bind(&DriveFileSystem::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, DRIVE_FILE_OK));
 }
 
-void GDataFileSystem::TransferFileFromRemoteToLocal(
+void DriveFileSystem::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,
-      base::Bind(&GDataFileSystem::OnGetFileCompleteForTransferFile,
+      base::Bind(&DriveFileSystem::OnGetFileCompleteForTransferFile,
                  ui_weak_ptr_,
                  local_dest_file_path,
                  callback),
       GetContentCallback());
 }
 
-void GDataFileSystem::TransferFileFromLocalToRemote(
+void DriveFileSystem::TransferFileFromLocalToRemote(
     const FilePath& local_src_file_path,
     const FilePath& remote_dest_file_path,
     const FileOperationCallback& callback) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   DCHECK(!callback.is_null());
 
   // Make sure the destination directory exists.
   resource_metadata_->GetEntryInfoByPath(
       remote_dest_file_path.DirName(),
       base::Bind(
-          &GDataFileSystem::TransferFileFromLocalToRemoteAfterGetEntryInfo,
+          &DriveFileSystem::TransferFileFromLocalToRemoteAfterGetEntryInfo,
           ui_weak_ptr_,
           local_src_file_path,
           remote_dest_file_path,
           callback));
 }
 
-void GDataFileSystem::TransferFileFromLocalToRemoteAfterGetEntryInfo(
+void DriveFileSystem::TransferFileFromLocalToRemoteAfterGetEntryInfo(
     const FilePath& local_src_file_path,
     const FilePath& remote_dest_file_path,
     const FileOperationCallback& callback,
     DriveFileError error,
     scoped_ptr<DriveEntryProto> entry_proto) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   DCHECK(!callback.is_null());
 
   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(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),
-      base::Bind(&GDataFileSystem::TransferFileForResourceId,
+      base::Bind(&DriveFileSystem::TransferFileForResourceId,
                  ui_weak_ptr_,
                  local_src_file_path,
                  remote_dest_file_path,
                  callback,
                  base::Owned(resource_id)));
 }
 
-void GDataFileSystem::TransferFileForResourceId(
+void DriveFileSystem::TransferFileForResourceId(
     const FilePath& local_file_path,
     const FilePath& remote_dest_file_path,
     const FileOperationCallback& callback,
     std::string* resource_id) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   DCHECK(resource_id);
   DCHECK(!callback.is_null());
 
   if (resource_id->empty()) {
     // If |resource_id| is empty, upload the local file as a regular file.
     TransferRegularFile(local_file_path, remote_dest_file_path, callback);
     return;
   }
 
   // Otherwise, copy the document on the server side and add the new copy
   // to the destination directory (collection).
   CopyDocumentToDirectory(
       remote_dest_file_path.DirName(),
       *resource_id,
       // Drop the document extension, which should not be
       // in the document title.
       remote_dest_file_path.BaseName().RemoveExtension().value(),
       callback);
 }
 
-void GDataFileSystem::TransferRegularFile(
+void DriveFileSystem::TransferRegularFile(
     const FilePath& local_file_path,
     const FilePath& remote_dest_file_path,
     const FileOperationCallback& callback) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 
   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,
+      base::Bind(&DriveFileSystem::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(
+void DriveFileSystem::StartFileUploadOnUIThread(
     const StartFileUploadParams& params,
     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 != 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,
+          &DriveFileSystem::StartFileUploadOnUIThreadAfterGetEntryInfo,
           ui_weak_ptr_,
           params,
           *file_size,
           *content_type));
 }
 
-void GDataFileSystem::StartFileUploadOnUIThreadAfterGetEntryInfo(
+void DriveFileSystem::StartFileUploadOnUIThreadAfterGetEntryInfo(
     const StartFileUploadParams& params,
     int64 file_size,
     std::string content_type,
     DriveFileError error,
     scoped_ptr<DriveEntryProto> entry_proto) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 
   if (entry_proto.get() && !entry_proto->file_info().is_directory())
     error = DRIVE_FILE_ERROR_NOT_A_DIRECTORY;
 
@@ skipping 11 matching lines @@
   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,
+      base::Bind(&DriveFileSystem::OnTransferCompleted,
                  ui_weak_ptr_,
                  params.callback);
 
   uploader_->UploadNewFile(upload_file_info.Pass());
 }
 
-void GDataFileSystem::OnTransferCompleted(
+void DriveFileSystem::OnTransferCompleted(
     const FileOperationCallback& callback,
     DriveFileError error,
     scoped_ptr<UploadFileInfo> upload_file_info) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   DCHECK(upload_file_info.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);
   }
 }
 
-void GDataFileSystem::Copy(const FilePath& src_file_path,
+void DriveFileSystem::Copy(const FilePath& src_file_path,
                            const FilePath& dest_file_path,
                            const FileOperationCallback& callback) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI) ||
          BrowserThread::CurrentlyOn(BrowserThread::IO));
   DCHECK(!callback.is_null());
 
-  RunTaskOnUIThread(base::Bind(&GDataFileSystem::CopyOnUIThread,
+  RunTaskOnUIThread(base::Bind(&DriveFileSystem::CopyOnUIThread,
                                ui_weak_ptr_,
                                src_file_path,
                                dest_file_path,
                                CreateRelayCallback(callback)));
 }
 
-void GDataFileSystem::CopyOnUIThread(const FilePath& src_file_path,
+void DriveFileSystem::CopyOnUIThread(const FilePath& src_file_path,
                                      const FilePath& dest_file_path,
                                      const FileOperationCallback& callback) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   DCHECK(!callback.is_null());
 
   resource_metadata_->GetEntryInfoPairByPaths(
       src_file_path,
       dest_file_path.DirName(),
-      base::Bind(&GDataFileSystem::CopyOnUIThreadAfterGetEntryInfoPair,
+      base::Bind(&DriveFileSystem::CopyOnUIThreadAfterGetEntryInfoPair,
                  ui_weak_ptr_,
                  dest_file_path,
                  callback));
 }
 
-void GDataFileSystem::CopyOnUIThreadAfterGetEntryInfoPair(
+void DriveFileSystem::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 != DRIVE_FILE_OK) {
     callback.Run(result->first.error);
     return;
@@ skipping 23 matching lines @@
                             // 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,
+                base::Bind(&DriveFileSystem::OnGetFileCompleteForCopy,
                            ui_weak_ptr_,
                            dest_file_path,
                            callback),
                 GetContentCallback());
 }
 
-void GDataFileSystem::OnGetFileCompleteForCopy(
+void DriveFileSystem::OnGetFileCompleteForCopy(
     const FilePath& remote_dest_file_path,
     const FileOperationCallback& callback,
     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 != 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(
+void DriveFileSystem::OnGetFileCompleteForTransferFile(
     const FilePath& local_dest_file_path,
     const FileOperationCallback& callback,
     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 != DRIVE_FILE_OK) {
@@ skipping 11 matching lines @@
       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)));
 }
 
-void GDataFileSystem::CopyDocumentToDirectory(
+void DriveFileSystem::CopyDocumentToDirectory(
     const FilePath& dir_path,
     const std::string& resource_id,
     const FilePath::StringType& new_name,
     const FileOperationCallback& callback) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   DCHECK(!callback.is_null());
 
   drive_service_->CopyDocument(resource_id, new_name,
-      base::Bind(&GDataFileSystem::OnCopyDocumentCompleted,
+      base::Bind(&DriveFileSystem::OnCopyDocumentCompleted,
                  ui_weak_ptr_,
                  dir_path,
                  callback));
 }
 
-void GDataFileSystem::Rename(const FilePath& file_path,
+void DriveFileSystem::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(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,
+          &DriveFileSystem::RenameAfterGetEntryInfo,
           ui_weak_ptr_,
           file_path,
           new_name,
           callback));
 }
 
-void GDataFileSystem::RenameAfterGetEntryInfo(
+void DriveFileSystem::RenameAfterGetEntryInfo(
     const FilePath& file_path,
     const FilePath::StringType& new_name,
     const FileMoveCallback& callback,
     DriveFileError error,
     scoped_ptr<DriveEntryProto> entry_proto) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 
   if (error != DRIVE_FILE_OK) {
     if (!callback.is_null())
       callback.Run(error, file_path);
@@ skipping 10 matching lines @@
     FilePath new_file(file_name);
     if (new_file.Extension() ==
         entry_proto->file_specific_info().document_extension()) {
       file_name = new_file.RemoveExtension().value();
     }
   }
 
   drive_service_->RenameResource(
       GURL(entry_proto->edit_url()),
       file_name,
-      base::Bind(&GDataFileSystem::RenameEntryLocally,
+      base::Bind(&DriveFileSystem::RenameEntryLocally,
                  ui_weak_ptr_,
                  file_path,
                  file_name,
                  callback));
 }
 
-void GDataFileSystem::Move(const FilePath& src_file_path,
+void DriveFileSystem::Move(const FilePath& src_file_path,
                            const FilePath& dest_file_path,
                            const FileOperationCallback& callback) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI) ||
          BrowserThread::CurrentlyOn(BrowserThread::IO));
   DCHECK(!callback.is_null());
 
-  RunTaskOnUIThread(base::Bind(&GDataFileSystem::MoveOnUIThread,
+  RunTaskOnUIThread(base::Bind(&DriveFileSystem::MoveOnUIThread,
                                ui_weak_ptr_,
                                src_file_path,
                                dest_file_path,
                                CreateRelayCallback(callback)));
 }
 
-void GDataFileSystem::MoveOnUIThread(const FilePath& src_file_path,
+void DriveFileSystem::MoveOnUIThread(const FilePath& src_file_path,
                                      const FilePath& dest_file_path,
                                      const FileOperationCallback& callback) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   DCHECK(!callback.is_null());
 
   resource_metadata_->GetEntryInfoPairByPaths(
       src_file_path,
       dest_file_path.DirName(),
-      base::Bind(&GDataFileSystem::MoveOnUIThreadAfterGetEntryInfoPair,
+      base::Bind(&DriveFileSystem::MoveOnUIThreadAfterGetEntryInfoPair,
                  ui_weak_ptr_,
                  dest_file_path,
                  callback));
 }
 
-void GDataFileSystem::MoveOnUIThreadAfterGetEntryInfoPair(
+void DriveFileSystem::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 != DRIVE_FILE_OK) {
     callback.Run(result->first.error);
     return;
   } 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(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,
+        base::Bind(&DriveFileSystem::OnFilePathUpdated,
                    ui_weak_ptr_,
                    callback);
 
     Rename(src_file_path, dest_file_path.BaseName().value(),
            final_file_path_update_callback);
     return;
   }
 
   // Otherwise, the move operation involves three steps:
   // 1. Renames the file at |src_file_path| to basename(|dest_file_path|)
   //    within the same directory. The rename operation is a no-op if
   //    basename(|src_file_path|) equals to basename(|dest_file_path|).
   // 2. Removes the file from its parent directory (the file is not deleted),
   //    which effectively moves the file to the root directory.
   // 3. Adds the file to the parent directory of |dest_file_path|, which
   //    effectively moves the file from the root directory to the parent
   //    directory of |dest_file_path|.
   const FileMoveCallback add_file_to_directory_callback =
-      base::Bind(&GDataFileSystem::MoveEntryFromRootDirectory,
+      base::Bind(&DriveFileSystem::MoveEntryFromRootDirectory,
                  ui_weak_ptr_,
                  dest_file_path.DirName(),
                  callback);
 
   const FileMoveCallback remove_file_from_directory_callback =
-      base::Bind(&GDataFileSystem::RemoveEntryFromNonRootDirectory,
+      base::Bind(&DriveFileSystem::RemoveEntryFromNonRootDirectory,
                  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(
+void DriveFileSystem::MoveEntryFromRootDirectory(
     const FilePath& dir_path,
     const FileOperationCallback& callback,
     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 != DRIVE_FILE_OK || dir_path == FilePath(kDriveRootDirectory)) {
     callback.Run(error);
     return;
   }
 
   resource_metadata_->GetEntryInfoPairByPaths(
       file_path,
       dir_path,
       base::Bind(
-          &GDataFileSystem::MoveEntryFromRootDirectoryAfterGetEntryInfoPair,
+          &DriveFileSystem::MoveEntryFromRootDirectoryAfterGetEntryInfoPair,
           ui_weak_ptr_,
           callback));
 }
 
-void GDataFileSystem::MoveEntryFromRootDirectoryAfterGetEntryInfoPair(
+void DriveFileSystem::MoveEntryFromRootDirectoryAfterGetEntryInfoPair(
     const FileOperationCallback& callback,
     scoped_ptr<EntryInfoPairResult> result) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   DCHECK(!callback.is_null());
   DCHECK(result.get());
 
   if (result->first.error != DRIVE_FILE_OK) {
     callback.Run(result->first.error);
     return;
   } 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(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,
+      base::Bind(&DriveFileSystem::OnMoveEntryFromRootDirectoryCompleted,
                  ui_weak_ptr_,
                  callback,
                  file_path,
                  dir_path));
 }
 
-void GDataFileSystem::RemoveEntryFromNonRootDirectory(
+void DriveFileSystem::RemoveEntryFromNonRootDirectory(
     const FileMoveCallback& callback,
     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 != DRIVE_FILE_OK || dir_path == FilePath(kDriveRootDirectory)) {
     callback.Run(error, file_path);
     return;
   }
 
   resource_metadata_->GetEntryInfoPairByPaths(
       file_path,
       dir_path,
       base::Bind(
-          &GDataFileSystem::RemoveEntryFromNonRootDirectoryAfterEntryInfoPair,
+          &DriveFileSystem::RemoveEntryFromNonRootDirectoryAfterEntryInfoPair,
           ui_weak_ptr_,
           callback));
 }
 
-void GDataFileSystem::RemoveEntryFromNonRootDirectoryAfterEntryInfoPair(
+void DriveFileSystem::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 != DRIVE_FILE_OK) {
     callback.Run(result->first.error, file_path);
     return;
   } 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(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,
+      base::Bind(&DriveFileSystem::MoveEntryToRootDirectoryLocally,
                  ui_weak_ptr_,
                  callback,
                  file_path,
                  dir_path));
 }
 
-void GDataFileSystem::Remove(const FilePath& file_path,
+void DriveFileSystem::Remove(const FilePath& file_path,
     bool is_recursive,
     const FileOperationCallback& callback) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI) ||
          BrowserThread::CurrentlyOn(BrowserThread::IO));
-  RunTaskOnUIThread(base::Bind(&GDataFileSystem::RemoveOnUIThread,
+  RunTaskOnUIThread(base::Bind(&DriveFileSystem::RemoveOnUIThread,
                                ui_weak_ptr_,
                                file_path,
                                is_recursive,
                                CreateRelayCallback(callback)));
 }
 
-void GDataFileSystem::RemoveOnUIThread(
+void DriveFileSystem::RemoveOnUIThread(
     const FilePath& file_path,
     bool is_recursive,
     const FileOperationCallback& callback) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 
   // Get the edit URL of an entry at |file_path|.
   resource_metadata_->GetEntryInfoByPath(
       file_path,
       base::Bind(
-          &GDataFileSystem::RemoveOnUIThreadAfterGetEntryInfo,
+          &DriveFileSystem::RemoveOnUIThreadAfterGetEntryInfo,
           ui_weak_ptr_,
           file_path,
           is_recursive,
           callback));
 }
 
-void GDataFileSystem::RemoveOnUIThreadAfterGetEntryInfo(
+void DriveFileSystem::RemoveOnUIThreadAfterGetEntryInfo(
     const FilePath& file_path,
     bool /* is_recursive */,
     const FileOperationCallback& callback,
     DriveFileError error,
     scoped_ptr<DriveEntryProto> entry_proto) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 
   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()),
-      base::Bind(&GDataFileSystem::OnRemovedDocument,
+      base::Bind(&DriveFileSystem::OnRemovedDocument,
                  ui_weak_ptr_,
                  callback,
                  file_path));
 }
 
-void GDataFileSystem::CreateDirectory(
+void DriveFileSystem::CreateDirectory(
     const FilePath& directory_path,
     bool is_exclusive,
     bool is_recursive,
     const FileOperationCallback& callback) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI) ||
          BrowserThread::CurrentlyOn(BrowserThread::IO));
-  RunTaskOnUIThread(base::Bind(&GDataFileSystem::CreateDirectoryOnUIThread,
+  RunTaskOnUIThread(base::Bind(&DriveFileSystem::CreateDirectoryOnUIThread,
                                ui_weak_ptr_,
                                directory_path,
                                is_exclusive,
                                is_recursive,
                                CreateRelayCallback(callback)));
 }
 
-void GDataFileSystem::CreateDirectoryOnUIThread(
+void DriveFileSystem::CreateDirectoryOnUIThread(
     const FilePath& directory_path,
     bool is_exclusive,
     bool is_recursive,
     const FileOperationCallback& callback) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 
   FilePath last_parent_dir_path;
   FilePath first_missing_path;
   GURL last_parent_dir_url;
   FindMissingDirectoryResult result =
@@ skipping 36 matching lines @@
     if (!callback.is_null()) {
       MessageLoop::current()->PostTask(FROM_HERE,
            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,
+      base::Bind(&DriveFileSystem::OnCreateDirectoryCompleted,
                  ui_weak_ptr_,
                  CreateDirectoryParams(
                      first_missing_path,
                      directory_path,
                      is_exclusive,
                      is_recursive,
                      callback)));
 }
 
-void GDataFileSystem::CreateFile(const FilePath& file_path,
+void DriveFileSystem::CreateFile(const FilePath& file_path,
                                  bool is_exclusive,
                                  const FileOperationCallback& callback) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI) ||
          BrowserThread::CurrentlyOn(BrowserThread::IO));
   DCHECK(!callback.is_null());
 
-  RunTaskOnUIThread(base::Bind(&GDataFileSystem::CreateFileOnUIThread,
+  RunTaskOnUIThread(base::Bind(&DriveFileSystem::CreateFileOnUIThread,
                                ui_weak_ptr_,
                                file_path,
                                is_exclusive,
                                CreateRelayCallback(callback)));
 }
 
-void GDataFileSystem::CreateFileOnUIThread(
+void DriveFileSystem::CreateFileOnUIThread(
     const FilePath& file_path,
     bool is_exclusive,
     const FileOperationCallback& callback) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   DCHECK(!callback.is_null());
 
   // First, checks the existence of a file at |file_path|.
   resource_metadata_->GetEntryInfoByPath(
       file_path,
-      base::Bind(&GDataFileSystem::OnGetEntryInfoForCreateFile,
+      base::Bind(&DriveFileSystem::OnGetEntryInfoForCreateFile,
                  ui_weak_ptr_,
                  file_path,
                  is_exclusive,
                  callback));
 }
 
-void GDataFileSystem::OnGetEntryInfoForCreateFile(
+void DriveFileSystem::OnGetEntryInfoForCreateFile(
     const FilePath& file_path,
     bool is_exclusive,
     const FileOperationCallback& callback,
     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 != DRIVE_FILE_ERROR_NOT_FOUND &&
@@ skipping 18 matching lines @@
     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(
+void DriveFileSystem::GetFileByPath(
     const FilePath& file_path,
     const GetFileCallback& get_file_callback,
     const GetContentCallback& get_content_callback) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI) ||
          BrowserThread::CurrentlyOn(BrowserThread::IO));
   RunTaskOnUIThread(
-      base::Bind(&GDataFileSystem::GetFileByPathOnUIThread,
+      base::Bind(&DriveFileSystem::GetFileByPathOnUIThread,
                  ui_weak_ptr_,
                  file_path,
                  CreateRelayCallback(get_file_callback),
                  CreateRelayCallback(get_content_callback)));
 }
 
-void GDataFileSystem::GetFileByPathOnUIThread(
+void DriveFileSystem::GetFileByPathOnUIThread(
     const FilePath& file_path,
     const GetFileCallback& get_file_callback,
     const GetContentCallback& get_content_callback) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 
   resource_metadata_->GetEntryInfoByPath(
       file_path,
-      base::Bind(&GDataFileSystem::OnGetEntryInfoCompleteForGetFileByPath,
+      base::Bind(&DriveFileSystem::OnGetEntryInfoCompleteForGetFileByPath,
                  ui_weak_ptr_,
                  file_path,
                  CreateRelayCallback(get_file_callback),
                  CreateRelayCallback(get_content_callback)));
 }
 
-void GDataFileSystem::OnGetEntryInfoCompleteForGetFileByPath(
+void DriveFileSystem::OnGetEntryInfoCompleteForGetFileByPath(
     const FilePath& file_path,
     const GetFileCallback& get_file_callback,
     const GetContentCallback& get_content_callback,
     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 != 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(
+void DriveFileSystem::GetResolvedFileByPath(
     const FilePath& file_path,
     const GetFileCallback& get_file_callback,
     const GetContentCallback& get_content_callback,
     DriveFileError error,
     const DriveEntryProto* entry_proto) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 
   if (entry_proto && !entry_proto->has_file_specific_info())
     error = DRIVE_FILE_ERROR_NOT_FOUND;
 
@@ skipping 44 matching lines @@
   // Returns absolute path of the file if it were cached or to be cached.
   FilePath local_tmp_path = cache_->GetCacheFilePath(
       entry_proto->resource_id(),
       entry_proto->file_specific_info().file_md5(),
       DriveCache::CACHE_TYPE_TMP,
       DriveCache::CACHED_FILE_FROM_SERVER);
   cache_->GetFileOnUIThread(
       entry_proto->resource_id(),
       entry_proto->file_specific_info().file_md5(),
       base::Bind(
-          &GDataFileSystem::OnGetFileFromCache,
+          &DriveFileSystem::OnGetFileFromCache,
           ui_weak_ptr_,
           GetFileFromCacheParams(
               file_path,
               local_tmp_path,
               GURL(entry_proto->content_url()),
               entry_proto->resource_id(),
               entry_proto->file_specific_info().file_md5(),
               entry_proto->file_specific_info().content_mime_type(),
               get_file_callback,
               get_content_callback)));
 }
 
-void GDataFileSystem::GetFileByResourceId(
+void DriveFileSystem::GetFileByResourceId(
     const std::string& resource_id,
     const GetFileCallback& get_file_callback,
     const GetContentCallback& get_content_callback) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI) ||
          BrowserThread::CurrentlyOn(BrowserThread::IO));
   RunTaskOnUIThread(
-      base::Bind(&GDataFileSystem::GetFileByResourceIdOnUIThread,
+      base::Bind(&DriveFileSystem::GetFileByResourceIdOnUIThread,
                  ui_weak_ptr_,
                  resource_id,
                  CreateRelayCallback(get_file_callback),
                  CreateRelayCallback(get_content_callback)));
 }
 
-void GDataFileSystem::GetFileByResourceIdOnUIThread(
+void DriveFileSystem::GetFileByResourceIdOnUIThread(
     const std::string& resource_id,
     const GetFileCallback& get_file_callback,
     const GetContentCallback& get_content_callback) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 
   resource_metadata_->GetEntryByResourceIdAsync(resource_id,
-      base::Bind(&GDataFileSystem::GetFileByEntryOnUIThread,
+      base::Bind(&DriveFileSystem::GetFileByEntryOnUIThread,
                  ui_weak_ptr_,
                  get_file_callback,
                  get_content_callback));
 }
 
-void GDataFileSystem::GetFileByEntryOnUIThread(
+void DriveFileSystem::GetFileByEntryOnUIThread(
     const GetFileCallback& get_file_callback,
     const GetContentCallback& get_content_callback,
     DriveEntry* entry) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 
   FilePath file_path;
   if (entry) {
     DriveFile* file = entry->AsDriveFile();
     if (file)
       file_path = file->GetFilePath();
@@ skipping 10 matching lines @@
                      FilePath(),
                      std::string(),
                      REGULAR_FILE));
     }
     return;
   }
 
   GetFileByPath(file_path, get_file_callback, get_content_callback);
 }
 
-void GDataFileSystem::OnGetFileFromCache(const GetFileFromCacheParams& params,
+void DriveFileSystem::OnGetFileFromCache(const GetFileFromCacheParams& params,
                                          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 == DRIVE_FILE_OK) {
     if (!params.get_file_callback.is_null()) {
       params.get_file_callback.Run(error,
@@ skipping 10 matching lines @@
   // Retrieve fresh file metadata from server. We will extract file size and
   // content url from there (we want to make sure used content url is not
   // stale).
   //
   // Check if we have enough space, based on the expected file size.
   // - if we don't have enough space, try to free up the disk space
   // - if we still don't have enough space, return "no space" error
   // - if we have enough space, start downloading the file from the server
   drive_service_->GetDocumentEntry(
       resource_id,
-      base::Bind(&GDataFileSystem::OnGetDocumentEntry,
+      base::Bind(&DriveFileSystem::OnGetDocumentEntry,
                  ui_weak_ptr_,
                  cache_file_path,
                  GetFileFromCacheParams(params.virtual_file_path,
                                         params.local_tmp_path,
                                         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,
+void DriveFileSystem::OnGetDocumentEntry(const FilePath& cache_file_path,
                                          const GetFileFromCacheParams& params,
                                          GDataErrorCode status,
                                          scoped_ptr<base::Value> data) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 
   DriveFileError error = util::GDataToDriveFileError(status);
 
   scoped_ptr<DriveEntry> fresh_entry;
   if (error == DRIVE_FILE_OK) {
     scoped_ptr<DocumentEntry> doc_entry(DocumentEntry::ExtractAndParse(*data));
@@ skipping 24 matching lines @@
   resource_metadata_->RefreshFile(fresh_entry_as_file.Pass());
 
   bool* has_enough_space = new bool(false);
   util::PostBlockingPoolSequencedTaskAndReply(
       FROM_HERE,
       blocking_task_runner_,
       base::Bind(&DriveCache::FreeDiskSpaceIfNeededFor,
                  base::Unretained(cache_),
                  file_size,
                  has_enough_space),
-      base::Bind(&GDataFileSystem::StartDownloadFileIfEnoughSpace,
+      base::Bind(&DriveFileSystem::StartDownloadFileIfEnoughSpace,
                  ui_weak_ptr_,
                  params,
                  content_url,
                  cache_file_path,
                  base::Owned(has_enough_space)));
 }
 
-void GDataFileSystem::StartDownloadFileIfEnoughSpace(
+void DriveFileSystem::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(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,
       params.local_tmp_path,
       content_url,
-      base::Bind(&GDataFileSystem::OnFileDownloaded,
+      base::Bind(&DriveFileSystem::OnFileDownloaded,
                  ui_weak_ptr_,
                  params),
       params.get_content_callback);
 }
 
-void GDataFileSystem::GetEntryInfoByPath(const FilePath& file_path,
+void DriveFileSystem::GetEntryInfoByPath(const FilePath& file_path,
                                          const GetEntryInfoCallback& callback) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI) ||
          BrowserThread::CurrentlyOn(BrowserThread::IO));
   DCHECK(!callback.is_null());
 
   RunTaskOnUIThread(
-      base::Bind(&GDataFileSystem::GetEntryInfoByPathOnUIThread,
+      base::Bind(&DriveFileSystem::GetEntryInfoByPathOnUIThread,
                  ui_weak_ptr_,
                  file_path,
                  CreateRelayCallback(callback)));
 }
 
-void GDataFileSystem::GetEntryInfoByPathOnUIThread(
+void DriveFileSystem::GetEntryInfoByPathOnUIThread(
     const FilePath& file_path,
     const GetEntryInfoCallback& callback) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   DCHECK(!callback.is_null());
 
   LoadFeedIfNeeded(
-      base::Bind(&GDataFileSystem::GetEntryInfoByPathOnUIThreadAfterLoad,
+      base::Bind(&DriveFileSystem::GetEntryInfoByPathOnUIThreadAfterLoad,
                  ui_weak_ptr_,
                  file_path,
                  callback));
 }
 
-void GDataFileSystem::GetEntryInfoByPathOnUIThreadAfterLoad(
+void DriveFileSystem::GetEntryInfoByPathOnUIThreadAfterLoad(
     const FilePath& file_path,
     const GetEntryInfoCallback& callback,
     DriveFileError error) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   DCHECK(!callback.is_null());
 
   if (error != DRIVE_FILE_OK) {
     callback.Run(error, scoped_ptr<DriveEntryProto>());
     return;
   }
 
   resource_metadata_->GetEntryInfoByPath(
       file_path,
-      base::Bind(&GDataFileSystem::GetEntryInfoByPathOnUIThreadAfterGetEntry,
+      base::Bind(&DriveFileSystem::GetEntryInfoByPathOnUIThreadAfterGetEntry,
                  ui_weak_ptr_,
                  callback));
 }
 
-void GDataFileSystem::GetEntryInfoByPathOnUIThreadAfterGetEntry(
+void DriveFileSystem::GetEntryInfoByPathOnUIThreadAfterGetEntry(
     const GetEntryInfoCallback& callback,
     DriveFileError error,
     scoped_ptr<DriveEntryProto> entry_proto) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   DCHECK(!callback.is_null());
 
   if (error != DRIVE_FILE_OK) {
     callback.Run(error, scoped_ptr<DriveEntryProto>());
     return;
   }
   DCHECK(entry_proto.get());
 
   CheckLocalModificationAndRun(entry_proto.Pass(), callback);
 }
 
-void GDataFileSystem::ReadDirectoryByPath(
+void DriveFileSystem::ReadDirectoryByPath(
     const FilePath& file_path,
     const ReadDirectoryWithSettingCallback& callback) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI) ||
          BrowserThread::CurrentlyOn(BrowserThread::IO));
   DCHECK(!callback.is_null());
 
   RunTaskOnUIThread(
-      base::Bind(&GDataFileSystem::ReadDirectoryByPathOnUIThread,
+      base::Bind(&DriveFileSystem::ReadDirectoryByPathOnUIThread,
                  ui_weak_ptr_,
                  file_path,
                  CreateRelayCallback(callback)));
 }
 
-void GDataFileSystem::ReadDirectoryByPathOnUIThread(
+void DriveFileSystem::ReadDirectoryByPathOnUIThread(
     const FilePath& file_path,
     const ReadDirectoryWithSettingCallback& callback) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   DCHECK(!callback.is_null());
 
   LoadFeedIfNeeded(
-      base::Bind(&GDataFileSystem::ReadDirectoryByPathOnUIThreadAfterLoad,
+      base::Bind(&DriveFileSystem::ReadDirectoryByPathOnUIThreadAfterLoad,
                  ui_weak_ptr_,
                  file_path,
                  callback));
 }
 
-void GDataFileSystem::ReadDirectoryByPathOnUIThreadAfterLoad(
+void DriveFileSystem::ReadDirectoryByPathOnUIThreadAfterLoad(
     const FilePath& file_path,
     const ReadDirectoryWithSettingCallback& callback,
     DriveFileError error) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   DCHECK(!callback.is_null());
 
   if (error != DRIVE_FILE_OK) {
     callback.Run(error,
                  hide_hosted_docs_,
                  scoped_ptr<DriveEntryProtoVector>());
     return;
   }
 
   resource_metadata_->ReadDirectoryByPath(
       file_path,
-      base::Bind(&GDataFileSystem::ReadDirectoryByPathOnUIThreadAfterRead,
+      base::Bind(&DriveFileSystem::ReadDirectoryByPathOnUIThreadAfterRead,
                  ui_weak_ptr_,
                  callback));
 }
 
-void GDataFileSystem::ReadDirectoryByPathOnUIThreadAfterRead(
+void DriveFileSystem::ReadDirectoryByPathOnUIThreadAfterRead(
     const ReadDirectoryWithSettingCallback& callback,
     DriveFileError error,
     scoped_ptr<DriveEntryProtoVector> entries) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   DCHECK(!callback.is_null());
 
   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(DRIVE_FILE_OK, hide_hosted_docs_, entries.Pass());
 }
 
-void GDataFileSystem::RequestDirectoryRefresh(const FilePath& file_path) {
+void DriveFileSystem::RequestDirectoryRefresh(const FilePath& file_path) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI) ||
          BrowserThread::CurrentlyOn(BrowserThread::IO));
   RunTaskOnUIThread(
-      base::Bind(&GDataFileSystem::RequestDirectoryRefreshOnUIThread,
+      base::Bind(&DriveFileSystem::RequestDirectoryRefreshOnUIThread,
                  ui_weak_ptr_,
                  file_path));
 }
 
-void GDataFileSystem::RequestDirectoryRefreshOnUIThread(
+void DriveFileSystem::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,
+          &DriveFileSystem::RequestDirectoryRefreshOnUIThreadAfterGetEntryInfo,
           ui_weak_ptr_,
           file_path));
 }
 
-void GDataFileSystem::RequestDirectoryRefreshOnUIThreadAfterGetEntryInfo(
+void DriveFileSystem::RequestDirectoryRefreshOnUIThreadAfterGetEntryInfo(
     const FilePath& file_path,
     DriveFileError error,
     scoped_ptr<DriveEntryProto> entry_proto) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 
   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,
+      base::Bind(&DriveFileSystem::OnRequestDirectoryRefresh,
                  ui_weak_ptr_,
                  file_path));
 }
 
-void GDataFileSystem::OnRequestDirectoryRefresh(
+void DriveFileSystem::OnRequestDirectoryRefresh(
     const FilePath& directory_path,
     GetDocumentsParams* params,
     DriveFileError error) {
   DCHECK(params);
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 
   if (error != DRIVE_FILE_OK) {
     LOG(ERROR) << "Failed to refresh directory: " << directory_path.value()
                << ": " << error;
     return;
@@ skipping 10 matching lines @@
       &unused_uma_stats);
   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,
+      base::Bind(&DriveFileSystem::OnDirectoryChangeFileMoveCallback,
                  ui_weak_ptr_));
 }
 
-void GDataFileSystem::UpdateFileByResourceId(
+void DriveFileSystem::UpdateFileByResourceId(
     const std::string& resource_id,
     const FileOperationCallback& callback) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI) ||
          BrowserThread::CurrentlyOn(BrowserThread::IO));
   DCHECK(!callback.is_null());
 
   RunTaskOnUIThread(
-      base::Bind(&GDataFileSystem::UpdateFileByResourceIdOnUIThread,
+      base::Bind(&DriveFileSystem::UpdateFileByResourceIdOnUIThread,
                  ui_weak_ptr_,
                  resource_id,
                  CreateRelayCallback(callback)));
 }
 
-void GDataFileSystem::UpdateFileByResourceIdOnUIThread(
+void DriveFileSystem::UpdateFileByResourceIdOnUIThread(
     const std::string& resource_id,
     const FileOperationCallback& callback) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   DCHECK(!callback.is_null());
 
   // TODO(satorux): GetEntryInfoByResourceId() is called twice for
   // UpdateFileByResourceIdOnUIThread(). crbug.com/143873
   resource_metadata_->GetEntryInfoByResourceId(
       resource_id,
-      base::Bind(&GDataFileSystem::UpdateFileByEntryInfo,
+      base::Bind(&DriveFileSystem::UpdateFileByEntryInfo,
                  ui_weak_ptr_,
                  callback));
 }
 
-void GDataFileSystem::UpdateFileByEntryInfo(
+void DriveFileSystem::UpdateFileByEntryInfo(
     const FileOperationCallback& callback,
     DriveFileError error,
     const FilePath& /* dive_file_path */,
     scoped_ptr<DriveEntryProto> entry_proto) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   DCHECK(!callback.is_null());
 
   if (error != DRIVE_FILE_OK) {
     callback.Run(error);
     return;
   }
 
   DCHECK(entry_proto.get());
   if (entry_proto->file_info().is_directory()) {
     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,
+      base::Bind(&DriveFileSystem::OnGetFileCompleteForUpdateFile,
                  ui_weak_ptr_,
                  callback));
 }
 
-void GDataFileSystem::OnGetFileCompleteForUpdateFile(
+void DriveFileSystem::OnGetFileCompleteForUpdateFile(
     const FileOperationCallback& callback,
     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 != 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.
   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,
+      base::Bind(&DriveFileSystem::OnGetFileSizeCompleteForUpdateFile,
                  ui_weak_ptr_,
                  callback,
                  resource_id,
                  cache_file_path,
                  base::Owned(get_size_error),
                  base::Owned(file_size)));
 }
 
-void GDataFileSystem::OnGetFileSizeCompleteForUpdateFile(
+void DriveFileSystem::OnGetFileSizeCompleteForUpdateFile(
     const FileOperationCallback& callback,
     const std::string& resource_id,
     const FilePath& cache_file_path,
     DriveFileError* error,
     int64* file_size) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   DCHECK(!callback.is_null());
 
   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,
+      base::Bind(&DriveFileSystem::OnGetFileCompleteForUpdateFileByEntry,
           ui_weak_ptr_,
           callback,
           *file_size,
           cache_file_path));
 }
 
-void GDataFileSystem::OnGetFileCompleteForUpdateFileByEntry(
+void DriveFileSystem::OnGetFileCompleteForUpdateFileByEntry(
     const FileOperationCallback& callback,
     int64 file_size,
     const FilePath& cache_file_path,
     DriveFileError error,
     const FilePath& drive_file_path,
     scoped_ptr<DriveEntryProto> entry_proto) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   DCHECK(!callback.is_null());
 
   if (error != DRIVE_FILE_OK) {
     callback.Run(error);
     return;
   }
 
   DCHECK(entry_proto.get());
   if (entry_proto->file_info().is_directory()) {
     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,
+      base::Bind(&DriveFileSystem::OnUpdatedFileUploaded,
                  ui_weak_ptr_,
                  callback));
 }
 
-void GDataFileSystem::OnUpdatedFileUploaded(
+void DriveFileSystem::OnUpdatedFileUploaded(
     const FileOperationCallback& callback,
     DriveFileError error,
     scoped_ptr<UploadFileInfo> upload_file_info) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   DCHECK(upload_file_info.get());
 
   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,
                   base::Bind(&OnAddUploadFileCompleted, callback, error));
 }
 
-void GDataFileSystem::GetAvailableSpace(
+void DriveFileSystem::GetAvailableSpace(
     const GetAvailableSpaceCallback& callback) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI) ||
          BrowserThread::CurrentlyOn(BrowserThread::IO));
-  RunTaskOnUIThread(base::Bind(&GDataFileSystem::GetAvailableSpaceOnUIThread,
+  RunTaskOnUIThread(base::Bind(&DriveFileSystem::GetAvailableSpaceOnUIThread,
                                ui_weak_ptr_,
                                CreateRelayCallback(callback)));
 }
 
-void GDataFileSystem::GetAvailableSpaceOnUIThread(
+void DriveFileSystem::GetAvailableSpaceOnUIThread(
     const GetAvailableSpaceCallback& callback) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   DCHECK(!callback.is_null());
 
   drive_service_->GetAccountMetadata(
       gdata::util::IsDriveV2ApiEnabled() ?
-      base::Bind(&GDataFileSystem::OnGetAboutResource,
+      base::Bind(&DriveFileSystem::OnGetAboutResource,
                  ui_weak_ptr_,
                  callback) :
-      base::Bind(&GDataFileSystem::OnGetAvailableSpace,
+      base::Bind(&DriveFileSystem::OnGetAvailableSpace,
                  ui_weak_ptr_,
                  callback));
 }
 
-void GDataFileSystem::OnGetAvailableSpace(
+void DriveFileSystem::OnGetAvailableSpace(
     const GetAvailableSpaceCallback& callback,
     GDataErrorCode status,
     scoped_ptr<base::Value> data) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   DCHECK(!callback.is_null());
 
   DriveFileError error = util::GDataToDriveFileError(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(DRIVE_FILE_ERROR_FAILED, -1, -1);
     return;
   }
 
   callback.Run(DRIVE_FILE_OK,
                feed->quota_bytes_total(),
                feed->quota_bytes_used());
 }
 
-void GDataFileSystem::OnGetAboutResource(
+void DriveFileSystem::OnGetAboutResource(
     const GetAvailableSpaceCallback& callback,
     GDataErrorCode status,
     scoped_ptr<base::Value> resource_json) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   DCHECK(!callback.is_null());
 
   DriveFileError error = util::GDataToDriveFileError(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(DRIVE_FILE_ERROR_FAILED, -1, -1);
     return;
   }
 
   callback.Run(DRIVE_FILE_OK,
                about->quota_bytes_total(),
                about->quota_bytes_used());
 }
 
-void GDataFileSystem::OnCreateDirectoryCompleted(
+void DriveFileSystem::OnCreateDirectoryCompleted(
     const CreateDirectoryParams& params,
     GDataErrorCode status,
     scoped_ptr<base::Value> data) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 
   DriveFileError error = util::GDataToDriveFileError(status);
   if (error != DRIVE_FILE_OK) {
     if (!params.callback.is_null())
       params.callback.Run(error);
 
@@ skipping 23 matching lines @@
                     params.callback);
     return;
   }
 
   if (!params.callback.is_null()) {
     // Finally done with the create request.
     params.callback.Run(DRIVE_FILE_OK);
   }
 }
 
-void GDataFileSystem::OnSearch(const SearchCallback& callback,
+void DriveFileSystem::OnSearch(const SearchCallback& callback,
                                GetDocumentsParams* params,
                                DriveFileError error) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 
   if (error != DRIVE_FILE_OK) {
     if (!callback.is_null())
       callback.Run(error, GURL(), scoped_ptr<std::vector<SearchResultInfo> >());
     return;
   }
 
@@ skipping 39 matching lines @@
     }
 
     // We will need information about result entry to create info for callback.
     // We can't use |entry| anymore, so we have to refetch entry from file
     // system. Also, |entry| doesn't have file path set before |RefreshFile|
     // call, so we can't get file path from there.
     resource_metadata_->GetEntryByResourceIdAsync(entry_resource_id,
         base::Bind(&AddEntryToSearchResults,
                    results,
                    callback,
-                   base::Bind(&GDataFileSystem::CheckForUpdates, ui_weak_ptr_),
+                   base::Bind(&DriveFileSystem::CheckForUpdates, ui_weak_ptr_),
                    error,
                    i+1 == feed->entries().size(),
                    next_feed));
   }
 }
 
-void GDataFileSystem::Search(const std::string& search_query,
+void DriveFileSystem::Search(const std::string& search_query,
                              const GURL& next_feed,
                              const SearchCallback& callback) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI) ||
          BrowserThread::CurrentlyOn(BrowserThread::IO));
-  RunTaskOnUIThread(base::Bind(&GDataFileSystem::SearchAsyncOnUIThread,
+  RunTaskOnUIThread(base::Bind(&DriveFileSystem::SearchAsyncOnUIThread,
                                ui_weak_ptr_,
                                search_query,
                                next_feed,
                                CreateRelayCallback(callback)));
 }
 
-void GDataFileSystem::SearchAsyncOnUIThread(
+void DriveFileSystem::SearchAsyncOnUIThread(
     const std::string& search_query,
     const GURL& next_feed,
     const SearchCallback& callback) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 
   feed_loader_->SearchFromServer(
       resource_metadata_->origin(),
       search_query,
       next_feed,
-      base::Bind(&GDataFileSystem::OnSearch, ui_weak_ptr_, callback));
+      base::Bind(&DriveFileSystem::OnSearch, ui_weak_ptr_, callback));
 }
 
-void GDataFileSystem::OnDirectoryChanged(const FilePath& directory_path) {
+void DriveFileSystem::OnDirectoryChanged(const FilePath& directory_path) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 
-  FOR_EACH_OBSERVER(GDataFileSystemInterface::Observer, observers_,
+  FOR_EACH_OBSERVER(DriveFileSystemInterface::Observer, observers_,
                     OnDirectoryChanged(directory_path));
 }
 
-void GDataFileSystem::OnDocumentFeedFetched(int num_accumulated_entries) {
+void DriveFileSystem::OnDocumentFeedFetched(int num_accumulated_entries) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 
-  FOR_EACH_OBSERVER(GDataFileSystemInterface::Observer, observers_,
+  FOR_EACH_OBSERVER(DriveFileSystemInterface::Observer, observers_,
                     OnDocumentFeedFetched(num_accumulated_entries));
 }
 
-void GDataFileSystem::OnFeedFromServerLoaded() {
+void DriveFileSystem::OnFeedFromServerLoaded() {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 
-  FOR_EACH_OBSERVER(GDataFileSystemInterface::Observer, observers_,
+  FOR_EACH_OBSERVER(DriveFileSystemInterface::Observer, observers_,
                     OnFeedFromServerLoaded());
 }
 
-void GDataFileSystem::LoadRootFeedFromCacheForTesting() {
+void DriveFileSystem::LoadRootFeedFromCacheForTesting() {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 
   feed_loader_->LoadFromCache(
       false,  // should_load_from_server.
       FileOperationCallback());
 }
 
-DriveFileError GDataFileSystem::UpdateFromFeedForTesting(
+DriveFileError DriveFileSystem::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,
+void DriveFileSystem::OnFilePathUpdated(const FileOperationCallback& callback,
                                         DriveFileError error,
                                         const FilePath& /* file_path */) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   if (!callback.is_null())
     callback.Run(error);
 }
 
-void GDataFileSystem::OnCopyDocumentCompleted(
+void DriveFileSystem::OnCopyDocumentCompleted(
     const FilePath& dir_path,
     const FileOperationCallback& callback,
     GDataErrorCode status,
     scoped_ptr<base::Value> data) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   DCHECK(!callback.is_null());
 
   DriveFileError error = util::GDataToDriveFileError(status);
   if (error != DRIVE_FILE_OK) {
     callback.Run(error);
@@ skipping 11 matching lines @@
     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,
+      base::Bind(&DriveFileSystem::MoveEntryFromRootDirectory,
                  ui_weak_ptr_,
                  dir_path,
                  callback));
 }
 
-void GDataFileSystem::OnMoveEntryFromRootDirectoryCompleted(
+void DriveFileSystem::OnMoveEntryFromRootDirectoryCompleted(
     const FileOperationCallback& callback,
     const FilePath& file_path,
     const FilePath& dir_path,
     GDataErrorCode status,
     const GURL& document_url) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   DCHECK(!callback.is_null());
 
   DriveFileError error = util::GDataToDriveFileError(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,
+              &DriveFileSystem::NotifyAndRunFileOperationCallback,
               ui_weak_ptr_,
               callback));
       return;
     } else {
       error = DRIVE_FILE_ERROR_NOT_FOUND;
     }
   }
 
   callback.Run(error);
 }
 
-void GDataFileSystem::OnRemovedDocument(
+void DriveFileSystem::OnRemovedDocument(
     const FileOperationCallback& callback,
     const FilePath& file_path,
     GDataErrorCode status,
     const GURL& document_url) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 
   DriveFileError error = util::GDataToDriveFileError(status);
 
   if (error == DRIVE_FILE_OK)
     error = RemoveEntryAndCacheLocally(file_path);
 
   if (!callback.is_null()) {
     callback.Run(error);
   }
 }
 
-void GDataFileSystem::OnFileDownloaded(
+void DriveFileSystem::OnFileDownloaded(
     const GetFileFromCacheParams& params,
     GDataErrorCode 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) {
     cache_->GetCacheEntryOnUIThread(
         params.resource_id,
         params.md5,
-        base::Bind(&GDataFileSystem::UnpinIfPinned,
+        base::Bind(&DriveFileSystem::UnpinIfPinned,
                    ui_weak_ptr_,
                    params.resource_id,
                    params.md5));
   }
 
   // At this point, the disk can be full or nearly full for several reasons:
   // - The expected file size was incorrect and the file was larger
   // - There was an in-flight download operation and it used up space
   // - The disk became full for some user actions we cannot control
   //   (ex. the user might have downloaded a large file from a regular web site)
   //
   // If we don't have enough space, we return PLATFORM_FILE_ERROR_NO_SPACE,
   // and try to free up space, even if the file was downloaded successfully.
   bool* has_enough_space = new bool(false);
   util::PostBlockingPoolSequencedTaskAndReply(
       FROM_HERE,
       blocking_task_runner_,
       base::Bind(&DriveCache::FreeDiskSpaceIfNeededFor,
                  base::Unretained(cache_),
                  0,
                  has_enough_space),
-      base::Bind(&GDataFileSystem::OnFileDownloadedAndSpaceChecked,
+      base::Bind(&DriveFileSystem::OnFileDownloadedAndSpaceChecked,
                  ui_weak_ptr_,
                  params,
                  status,
                  content_url,
                  downloaded_file_path,
                  base::Owned(has_enough_space)));
 }
 
-void GDataFileSystem::UnpinIfPinned(
+void DriveFileSystem::UnpinIfPinned(
     const std::string& resource_id,
     const std::string& md5,
     bool success,
     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(
+void DriveFileSystem::OnFileDownloadedAndSpaceChecked(
     const GetFileFromCacheParams& params,
     GDataErrorCode status,
     const GURL& content_url,
     const FilePath& downloaded_file_path,
     bool* has_enough_space) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 
   DriveFileError error = util::GDataToDriveFileError(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 == 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,
+          base::Bind(&DriveFileSystem::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 = 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(DriveFileError error,
+void DriveFileSystem::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(
+void DriveFileSystem::RenameEntryLocally(
     const FilePath& file_path,
     const FilePath::StringType& new_name,
     const FileMoveCallback& callback,
     GDataErrorCode status,
     const GURL& document_url) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 
   const DriveFileError error = util::GDataToDriveFileError(status);
   if (error != DRIVE_FILE_OK) {
     if (!callback.is_null())
@@ skipping 13 matching lines @@
   // 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,
+      base::Bind(&DriveFileSystem::NotifyAndRunFileMoveCallback,
                  ui_weak_ptr_,
                  callback));
 }
 
-void GDataFileSystem::MoveEntryToRootDirectoryLocally(
+void DriveFileSystem::MoveEntryToRootDirectoryLocally(
     const FileMoveCallback& callback,
     const FilePath& file_path,
     const FilePath& dir_path,
     GDataErrorCode status,
     const GURL& document_url) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   DCHECK(!callback.is_null());
 
   const DriveFileError error = util::GDataToDriveFileError(status);
   if (error != DRIVE_FILE_OK) {
     callback.Run(error, FilePath());
     return;
   }
 
   DriveEntry* entry = resource_metadata_->FindEntryByPathSync(file_path);
   if (!entry) {
     callback.Run(DRIVE_FILE_ERROR_NOT_FOUND, FilePath());
     return;
   }
 
   resource_metadata_->MoveEntryToDirectory(
       resource_metadata_->root()->GetFilePath(),
       entry,
-      base::Bind(&GDataFileSystem::NotifyAndRunFileMoveCallback,
+      base::Bind(&DriveFileSystem::NotifyAndRunFileMoveCallback,
                  ui_weak_ptr_,
                  callback));
 }
 
-void GDataFileSystem::NotifyAndRunFileMoveCallback(
+void DriveFileSystem::NotifyAndRunFileMoveCallback(
     const FileMoveCallback& callback,
     DriveFileError error,
     const FilePath& moved_file_path) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 
   if (error == DRIVE_FILE_OK)
     OnDirectoryChanged(moved_file_path.DirName());
 
   if (!callback.is_null())
     callback.Run(error, moved_file_path);
 }
 
-void GDataFileSystem::NotifyAndRunFileOperationCallback(
+void DriveFileSystem::NotifyAndRunFileOperationCallback(
     const FileOperationCallback& callback,
     DriveFileError error,
     const FilePath& moved_file_path) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   DCHECK(!callback.is_null());
 
   if (error == DRIVE_FILE_OK)
     OnDirectoryChanged(moved_file_path.DirName());
 
   callback.Run(error);
 }
 
-void GDataFileSystem::OnDirectoryChangeFileMoveCallback(
+void DriveFileSystem::OnDirectoryChangeFileMoveCallback(
     DriveFileError error,
     const FilePath& directory_path) {
   if (error == DRIVE_FILE_OK)
     OnDirectoryChanged(directory_path);
 }
 
-DriveFileError GDataFileSystem::RemoveEntryAndCacheLocally(
+DriveFileError DriveFileSystem::RemoveEntryAndCacheLocally(
     const FilePath& file_path) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 
   std::string resource_id;
   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 DRIVE_FILE_OK;
 }
 
-void GDataFileSystem::RemoveStaleEntryOnUpload(
+void DriveFileSystem::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(DRIVE_FILE_ERROR_NOT_FOUND, FilePath());
     LOG(ERROR) << "Entry for the existing file not found: " << resource_id;
   }
 }
 
-void GDataFileSystem::NotifyFileSystemMounted() {
+void DriveFileSystem::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_,
+  FOR_EACH_OBSERVER(DriveFileSystemInterface::Observer, observers_,
                     OnFileSystemMounted());
 }
 
-void GDataFileSystem::NotifyFileSystemToBeUnmounted() {
+void DriveFileSystem::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_,
+  FOR_EACH_OBSERVER(DriveFileSystemInterface::Observer, observers_,
                     OnFileSystemBeingUnmounted());
 }
 
-void GDataFileSystem::NotifyInitialLoadFinishedAndRun(
+void DriveFileSystem::NotifyInitialLoadFinishedAndRun(
     const FileOperationCallback& callback,
     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_,
+  FOR_EACH_OBSERVER(DriveFileSystemInterface::Observer, observers_,
                     OnInitialLoadFinished());
 
   callback.Run(error);
 }
 
-DriveFileError GDataFileSystem::AddNewDirectory(
+DriveFileError DriveFileSystem::AddNewDirectory(
     const FilePath& directory_path, base::Value* entry_value) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 
   if (!entry_value)
     return DRIVE_FILE_ERROR_FAILED;
 
   scoped_ptr<DocumentEntry> doc_entry(DocumentEntry::CreateFrom(*entry_value));
 
   if (!doc_entry.get())
     return DRIVE_FILE_ERROR_FAILED;
@@ skipping 11 matching lines @@
     return DRIVE_FILE_ERROR_FAILED;
 
   DriveEntry* new_entry =
       resource_metadata_->FromDocumentEntry(*doc_entry);
   if (!new_entry)
     return DRIVE_FILE_ERROR_FAILED;
 
   resource_metadata_->AddEntryToDirectory(
       parent_dir,
       new_entry,
-      base::Bind(&GDataFileSystem::NotifyAndRunFileMoveCallback,
+      base::Bind(&DriveFileSystem::NotifyAndRunFileMoveCallback,
                  ui_weak_ptr_,
                  FileMoveCallback()));
   return DRIVE_FILE_OK;
 }
 
-GDataFileSystem::FindMissingDirectoryResult
-GDataFileSystem::FindFirstMissingParentDirectory(
+DriveFileSystem::FindMissingDirectoryResult
+DriveFileSystem::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
   // get the first element that's missing.
   std::vector<FilePath::StringType> path_parts;
   directory_path.GetComponents(&path_parts);
   FilePath current_path;
@@ skipping 11 matching lines @@
         return FOUND_INVALID;
       }
     } else {
       *first_missing_parent_path = current_path;
       return FOUND_MISSING;
     }
   }
   return DIRECTORY_ALREADY_PRESENT;
 }
 
-DriveFileError GDataFileSystem::RemoveEntryLocally(
+DriveFileError DriveFileSystem::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 DRIVE_FILE_ERROR_NOT_FOUND;
 
   // You can't remove root element.
   if (!entry->parent())
     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,
+      base::Bind(&DriveFileSystem::OnDirectoryChangeFileMoveCallback,
                  ui_weak_ptr_));
   return DRIVE_FILE_OK;
 }
 
-void GDataFileSystem::AddUploadedFile(
+void DriveFileSystem::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));
 
   // Post a task to the same thread, rather than calling it here, as
   // AddUploadedFile() is asynchronous.
   base::MessageLoopProxy::current()->PostTask(
       FROM_HERE,
-      base::Bind(&GDataFileSystem::AddUploadedFileOnUIThread,
+      base::Bind(&DriveFileSystem::AddUploadedFileOnUIThread,
                  ui_weak_ptr_,
                  upload_mode,
                  virtual_dir_path,
                  base::Passed(&entry),
                  file_content_path,
                  cache_operation,
                  callback));
 }
 
-void GDataFileSystem::AddUploadedFileOnUIThread(
+void DriveFileSystem::AddUploadedFileOnUIThread(
     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));
 
   // ScopedClosureRunner ensures that the specified callback is always invoked
   // upon return or passed on.
@@ skipping 21 matching lines @@
   const std::string& resource_id = new_entry->resource_id();
   AddUploadedFileParams* params =
       new AddUploadedFileParams(upload_mode,
                                 parent_dir,
                                 new_entry.Pass(),
                                 file_content_path,
                                 cache_operation,
                                 callback_runner.Release());
 
   const FileMoveCallback file_move_callback =
-      base::Bind(&GDataFileSystem::ContinueAddUploadedFile,
+      base::Bind(&DriveFileSystem::ContinueAddUploadedFile,
                  ui_weak_ptr_, params);
 
   if (upload_mode == UPLOAD_EXISTING_FILE) {
     // Remove an existing entry, which should be present.
     resource_metadata_->GetEntryByResourceIdAsync(
         resource_id,
-        base::Bind(&GDataFileSystem::RemoveStaleEntryOnUpload,
+        base::Bind(&DriveFileSystem::RemoveStaleEntryOnUpload,
                    ui_weak_ptr_,
                    resource_id,
                    parent_dir,
                    file_move_callback));
   } else {
     file_move_callback.Run(DRIVE_FILE_OK, FilePath());
   }
 }
 
-void GDataFileSystem::ContinueAddUploadedFile(
+void DriveFileSystem::ContinueAddUploadedFile(
     AddUploadedFileParams* params,
     DriveFileError error,
     const FilePath& file_path) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   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,
+      base::Bind(&DriveFileSystem::NotifyAndRunFileMoveCallback,
                  ui_weak_ptr_,
-                 base::Bind(&GDataFileSystem::AddUploadedFileToCache,
+                 base::Bind(&DriveFileSystem::AddUploadedFileToCache,
                             ui_weak_ptr_,
                             base::Owned(params))));
 }
 
-void GDataFileSystem::AddUploadedFileToCache(
+void DriveFileSystem::AddUploadedFileToCache(
     AddUploadedFileParams* params,
     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,
                                        params->callback));
   } else if (params->upload_mode == UPLOAD_EXISTING_FILE) {
     // Clear the dirty bit if we have updated an existing file.
     cache_->ClearDirtyOnUIThread(params->resource_id,
                                  params->md5,
                                  base::Bind(&OnCacheUpdatedForAddUploadedFile,
                                             params->callback));
   } else {
     NOTREACHED() << "Unexpected upload mode: " << params->upload_mode;
     // Shouldn't reach here, so the line below should not make much sense, but
     // since calling |callback| exactly once is our obligation, we'd better call
     // it for not to clutter further more.
     params->callback.Run();
   }
 }
 
-void GDataFileSystem::UpdateEntryData(const std::string& resource_id,
+void DriveFileSystem::UpdateEntryData(const std::string& resource_id,
                                       const std::string& md5,
                                       scoped_ptr<DocumentEntry> entry,
                                       const FilePath& file_content_path,
                                       const base::Closure& callback) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 
   // Post a task to the same thread, rather than calling it here, as
   // UpdateEntryData() is asynchronous.
   base::MessageLoopProxy::current()->PostTask(
       FROM_HERE,
-      base::Bind(&GDataFileSystem::UpdateEntryDataOnUIThread,
+      base::Bind(&DriveFileSystem::UpdateEntryDataOnUIThread,
                  ui_weak_ptr_,
                  resource_id,
                  md5,
                  base::Passed(&entry),
                  file_content_path,
                  callback));
 }
 
-void GDataFileSystem::UpdateEntryDataOnUIThread(
+void DriveFileSystem::UpdateEntryDataOnUIThread(
     const std::string& resource_id,
     const std::string& md5,
     scoped_ptr<DocumentEntry> entry,
     const FilePath& file_content_path,
     const base::Closure& callback) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 
   scoped_ptr<DriveFile> new_entry(
       resource_metadata_->FromDocumentEntry(*entry)->AsDriveFile());
   if (!new_entry.get()) {
     return;
   }
 
   resource_metadata_->RefreshFile(new_entry.Pass());
 
   // Add the file to the cache if we have uploaded a new file.
   cache_->StoreOnUIThread(resource_id,
                           md5,
                           file_content_path,
                           DriveCache::FILE_OPERATION_MOVE,
                           base::Bind(&OnCacheUpdatedForAddUploadedFile,
                                      callback));
 }
 
 
-void GDataFileSystem::Observe(int type,
+void DriveFileSystem::Observe(int type,
                               const content::NotificationSource& source,
                               const content::NotificationDetails& details) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 
   if (type == chrome::NOTIFICATION_PREF_CHANGED) {
     PrefService* pref_service = profile_->GetPrefs();
     std::string* pref_name = content::Details<std::string>(details).ptr();
     if (*pref_name == prefs::kDisableGDataHostedFiles) {
       SetHideHostedDocuments(
           pref_service->GetBoolean(prefs::kDisableGDataHostedFiles));
     }
   } else {
     NOTREACHED();
   }
 }
 
-void GDataFileSystem::SetHideHostedDocuments(bool hide) {
+void DriveFileSystem::SetHideHostedDocuments(bool hide) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 
   if (hide == hide_hosted_docs_)
     return;
 
   hide_hosted_docs_ = hide;
   const FilePath root_path = resource_metadata_->root()->GetFilePath();
 
   // Kick off directory refresh when this setting changes.
-  FOR_EACH_OBSERVER(GDataFileSystemInterface::Observer, observers_,
+  FOR_EACH_OBSERVER(DriveFileSystemInterface::Observer, observers_,
                     OnDirectoryChanged(root_path));
 }
 
-//============= GDataFileSystem: internal helper functions =====================
+//============= DriveFileSystem: internal helper functions =====================
 
-void GDataFileSystem::InitializePreferenceObserver() {
+void DriveFileSystem::InitializePreferenceObserver() {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 
   pref_registrar_.reset(new PrefChangeRegistrar());
   pref_registrar_->Init(profile_->GetPrefs());
   pref_registrar_->Add(prefs::kDisableGDataHostedFiles, this);
 }
 
-void GDataFileSystem::OpenFile(const FilePath& file_path,
+void DriveFileSystem::OpenFile(const FilePath& file_path,
                                const OpenFileCallback& callback) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI) ||
          BrowserThread::CurrentlyOn(BrowserThread::IO));
-  RunTaskOnUIThread(base::Bind(&GDataFileSystem::OpenFileOnUIThread,
+  RunTaskOnUIThread(base::Bind(&DriveFileSystem::OpenFileOnUIThread,
                                ui_weak_ptr_,
                                file_path,
                                CreateRelayCallback(callback)));
 }
 
-void GDataFileSystem::OpenFileOnUIThread(const FilePath& file_path,
+void DriveFileSystem::OpenFileOnUIThread(const FilePath& file_path,
                                          const OpenFileCallback& callback) {
   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, DRIVE_FILE_ERROR_IN_USE, FilePath()));
     return;
   }
   open_files_.insert(file_path);
 
   resource_metadata_->GetEntryInfoByPath(
       file_path,
-      base::Bind(&GDataFileSystem::OnGetEntryInfoCompleteForOpenFile,
+      base::Bind(&DriveFileSystem::OnGetEntryInfoCompleteForOpenFile,
                  ui_weak_ptr_,
                  file_path,
-                 base::Bind(&GDataFileSystem::OnOpenFileFinished,
+                 base::Bind(&DriveFileSystem::OnOpenFileFinished,
                             ui_weak_ptr_,
                             file_path,
                             callback)));
 }
 
-void GDataFileSystem::OnGetEntryInfoCompleteForOpenFile(
+void DriveFileSystem::OnGetEntryInfoCompleteForOpenFile(
     const FilePath& file_path,
     const OpenFileCallback& callback,
     DriveFileError error,
     scoped_ptr<DriveEntryProto> entry_proto) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 
   if (entry_proto.get() && !entry_proto->has_file_specific_info())
     error = DRIVE_FILE_ERROR_NOT_FOUND;
 
   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 = DRIVE_FILE_ERROR_INVALID_OPERATION;
     }
   }
 
   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,
+      base::Bind(&DriveFileSystem::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(
+void DriveFileSystem::OnGetFileCompleteForOpenFile(
     const OpenFileCallback& callback,
     const GetFileCompleteForOpenParams& entry_proto,
     DriveFileError error,
     const FilePath& file_path,
     const std::string& mime_type,
     DriveFileType file_type) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 
   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,
+      base::Bind(&DriveFileSystem::OnMarkDirtyInCacheCompleteForOpenFile,
                  ui_weak_ptr_,
                  callback));
 }
 
-void GDataFileSystem::OnMarkDirtyInCacheCompleteForOpenFile(
+void DriveFileSystem::OnMarkDirtyInCacheCompleteForOpenFile(
     const OpenFileCallback& callback,
     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,
+void DriveFileSystem::OnOpenFileFinished(const FilePath& file_path,
                                          const OpenFileCallback& callback,
                                          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 != 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,
+void DriveFileSystem::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,
+  RunTaskOnUIThread(base::Bind(&DriveFileSystem::CloseFileOnUIThread,
                                ui_weak_ptr_,
                                file_path,
                                CreateRelayCallback(callback)));
 }
 
-void GDataFileSystem::CloseFileOnUIThread(
+void DriveFileSystem::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, 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,
+      base::Bind(&DriveFileSystem::CloseFileOnUIThreadAfterGetEntryInfo,
                  ui_weak_ptr_,
                  file_path,
-                 base::Bind(&GDataFileSystem::CloseFileOnUIThreadFinalize,
+                 base::Bind(&DriveFileSystem::CloseFileOnUIThreadFinalize,
                             ui_weak_ptr_,
                             file_path,
                             callback)));
 }
 
-void GDataFileSystem::CloseFileOnUIThreadAfterGetEntryInfo(
+void DriveFileSystem::CloseFileOnUIThreadAfterGetEntryInfo(
     const FilePath& file_path,
     const FileOperationCallback& callback,
     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 = DRIVE_FILE_ERROR_NOT_FOUND;
 
   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,
+      base::Bind(&DriveFileSystem::CloseFileOnUIThreadAfterCommitDirtyInCache,
                  ui_weak_ptr_,
                  callback));
 }
 
-void GDataFileSystem::CloseFileOnUIThreadAfterCommitDirtyInCache(
+void DriveFileSystem::CloseFileOnUIThreadAfterCommitDirtyInCache(
     const FileOperationCallback& callback,
     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(
+void DriveFileSystem::CloseFileOnUIThreadFinalize(
     const FilePath& file_path,
     const FileOperationCallback& callback,
     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(
+void DriveFileSystem::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(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,
+          &DriveFileSystem::CheckLocalModificationAndRunAfterGetCacheEntry,
           ui_weak_ptr_, base::Passed(&entry_proto), callback));
 }
 
-void GDataFileSystem::CheckLocalModificationAndRunAfterGetCacheEntry(
+void DriveFileSystem::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(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,
+          &DriveFileSystem::CheckLocalModificationAndRunAfterGetCacheFile,
           ui_weak_ptr_, base::Passed(&entry_proto), callback));
 }
 
-void GDataFileSystem::CheckLocalModificationAndRunAfterGetCacheFile(
+void DriveFileSystem::CheckLocalModificationAndRunAfterGetCacheFile(
     scoped_ptr<DriveEntryProto> entry_proto,
     const GetEntryInfoCallback& callback,
     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 != 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,
                  local_cache_path,
                  base::Unretained(file_info),
                  base::Unretained(get_file_info_result)),
-      base::Bind(&GDataFileSystem::CheckLocalModificationAndRunAfterGetFileInfo,
+      base::Bind(&DriveFileSystem::CheckLocalModificationAndRunAfterGetFileInfo,
                  ui_weak_ptr_,
                  base::Passed(&entry_proto),
                  callback,
                  base::Owned(file_info),
                  base::Owned(get_file_info_result)));
 }
 
-void GDataFileSystem::CheckLocalModificationAndRunAfterGetFileInfo(
+void DriveFileSystem::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(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(DRIVE_FILE_OK, entry_proto.Pass());
 }
 
 }  // namespace gdata