Rename GDataFileSystem* to DriveFileSystem*

chrome/browser/chromeos/gdata/gdata_download_observer.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_download_observer.h"
 
 #include <string>
 
 #include "base/callback.h"
 #include "base/file_util.h"
 #include "base/supports_user_data.h"
 #include "chrome/browser/chromeos/gdata/drive.pb.h"
+#include "chrome/browser/chromeos/gdata/drive_file_system_interface.h"
 #include "chrome/browser/chromeos/gdata/drive_service_interface.h"
-#include "chrome/browser/chromeos/gdata/gdata_file_system_interface.h"
 #include "chrome/browser/chromeos/gdata/gdata_system_service.h"
 #include "chrome/browser/chromeos/gdata/gdata_upload_file_info.h"
 #include "chrome/browser/chromeos/gdata/gdata_uploader.h"
 #include "chrome/browser/chromeos/gdata/gdata_util.h"
 #include "chrome/browser/chromeos/gdata/gdata_wapi_parser.h"
 #include "chrome/browser/download/download_completion_blocker.h"
 #include "chrome/browser/profiles/profile_manager.h"
 #include "net/base/net_util.h"
 
 using content::BrowserThread;
@@ skipping 101 matching lines @@
   BrowserThread::GetBlockingPool()->PostTaskAndReply(
       FROM_HERE,
       base::Bind(&GDataDownloadObserver::GetGDataTempDownloadPath,
                  gdata_tmp_download_dir,
                  gdata_tmp_download_path),
       base::Bind(&RunSubstituteGDataDownloadCallback,
                  callback,
                  base::Owned(gdata_tmp_download_path)));
 }
 
-// Callback for GDataFileSystem::CreateDirectory.
+// Callback for DriveFileSystem::CreateDirectory.
 void OnCreateDirectory(const base::Closure& substitute_callback,
                        DriveFileError error) {
   DVLOG(1) << "OnCreateDirectory " << error;
   if (error == DRIVE_FILE_OK) {
     substitute_callback.Run();
   } else {
     // TODO(achuith): Handle this.
     NOTREACHED();
   }
 }
 
-// Callback for GDataFileSystem::GetEntryInfoByPath.
+// Callback for DriveFileSystem::GetEntryInfoByPath.
 void OnEntryFound(Profile* profile,
     const FilePath& gdata_dir_path,
     const base::Closure& substitute_callback,
     DriveFileError error,
     scoped_ptr<DriveEntryProto> entry_proto) {
   if (error == DRIVE_FILE_ERROR_NOT_FOUND) {
     // Destination gdata directory doesn't exist, so create it.
     const bool is_exclusive = false, is_recursive = true;
     GetSystemService(profile)->file_system()->CreateDirectory(
         gdata_dir_path, is_exclusive, is_recursive,
@@ skipping 10 matching lines @@
 void OnAuthenticate(Profile* profile,
                     const FilePath& gdata_path,
                     const base::Closure& substitute_callback,
                     GDataErrorCode error,
                     const std::string& token) {
   DVLOG(1) << "OnAuthenticate";
 
   if (error == HTTP_SUCCESS) {
     const FilePath gdata_dir_path =
         util::ExtractGDataPath(gdata_path.DirName());
-    // Ensure the directory exists. This also forces GDataFileSystem to
+    // Ensure the directory exists. This also forces DriveFileSystem to
     // initialize GDataRootDirectory.
     GetSystemService(profile)->file_system()->GetEntryInfoByPath(
         gdata_dir_path,
         base::Bind(&OnEntryFound, profile, gdata_dir_path,
                    substitute_callback));
   } else {
     // TODO(achuith): Handle this.
     NOTREACHED();
   }
 }
 
 }  // namespace
 
 GDataDownloadObserver::GDataDownloadObserver(
     GDataUploader* uploader,
-    GDataFileSystemInterface* file_system)
+    DriveFileSystemInterface* file_system)
     : gdata_uploader_(uploader),
       file_system_(file_system),
       download_manager_(NULL),
       ALLOW_THIS_IN_INITIALIZER_LIST(weak_ptr_factory_(this)) {
 }
 
 GDataDownloadObserver::~GDataDownloadObserver() {
   if (download_manager_)
     download_manager_->RemoveObserver(this);
 
@@ skipping 18 matching lines @@
     const FilePath& gdata_path, content::DownloadItem* download,
     const SubstituteGDataDownloadPathCallback& callback) {
   DVLOG(1) << "SubstituteGDataDownloadPath " << gdata_path.value();
 
   SetDownloadParams(gdata_path, download);
 
   if (util::IsUnderGDataMountPoint(gdata_path)) {
     // Can't access drive if we're not authenticated.
     // We set off a chain of callbacks as follows:
     // DriveServiceInterface::Authenticate
-    //   OnAuthenticate calls GDataFileSystem::GetEntryInfoByPath
-    //     OnEntryFound calls GDataFileSystem::CreateDirectory (if necessary)
+    //   OnAuthenticate calls DriveFileSystem::GetEntryInfoByPath
+    //     OnEntryFound calls DriveFileSystem::CreateDirectory (if necessary)
     //       OnCreateDirectory calls SubstituteGDataDownloadPathInternal
     GetSystemService(profile)->drive_service()->Authenticate(
         base::Bind(&OnAuthenticate, profile, gdata_path,
                    base::Bind(&SubstituteGDataDownloadPathInternal,
                               profile, callback)));
   } else {
     callback.Run(gdata_path);
   }
 }
 
@@ skipping 375 matching lines @@
     DVLOG(1) << "Pending download not found" << download_id;
     return;
   }
   DVLOG(1) << "Completing upload for download ID " << download_id;
   DownloadItem* download_item = iter->second;
 
   UploadingUserData* upload_data = GetUploadingUserData(download_item);
   DCHECK(upload_data);
 
   // Take ownership of the DocumentEntry from UploadFileInfo. This is used by
-  // GDataFileSystem::AddUploadedFile() to add the entry to DriveCache after the
+  // DriveFileSystem::AddUploadedFile() to add the entry to DriveCache after the
   // upload completes.
   upload_data->set_entry(upload_file_info->entry.Pass());
 
   // Allow the download item to complete.
   upload_data->CompleteDownload();
 }
 
 void GDataDownloadObserver::MoveFileToDriveCache(DownloadItem* download) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 
@@ skipping 23 matching lines @@
     file_system_->AddUploadedFile(UPLOAD_NEW_FILE,
                                   upload_data->virtual_dir_path(),
                                   entry.Pass(),
                                   download->GetTargetFilePath(),
                                   DriveCache::FILE_OPERATION_MOVE,
                                   base::Bind(&base::DoNothing));
   }
 }
 
 }  // namespace gdata