Rename GDataUplaoder to DriveUploader

chrome/browser/chromeos/gdata/drive_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/drive_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_file_system_util.h"
 #include "chrome/browser/chromeos/gdata/drive_service_interface.h"
 #include "chrome/browser/chromeos/gdata/drive_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/drive_upload_file_info.h"
+#include "chrome/browser/chromeos/gdata/drive_uploader.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;
 using content::DownloadManager;
 using content::DownloadItem;
 
 namespace gdata {
 namespace {
 
 // Threshold file size after which we stream the file.
 const int64 kStreamingFileSize = 1 << 20;  // 1MB
 
 // Keys for base::SupportsUserData::Data.
 const char kUploadingKey[] = "Uploading";
 const char kGDataPathKey[] = "GDataPath";
 
 // User Data stored in DownloadItem for ongoing uploads.
 class UploadingUserData : public DownloadCompletionBlocker {
  public:
-  explicit UploadingUserData(GDataUploader* uploader)
+  explicit UploadingUserData(DriveUploader* uploader)
       : uploader_(uploader),
         upload_id_(-1),
         is_overwrite_(false) {
   }
   virtual ~UploadingUserData() {}
 
-  GDataUploader* uploader() { return uploader_; }
+  DriveUploader* uploader() { return uploader_; }
   void set_upload_id(int upload_id) { upload_id_ = upload_id; }
   int upload_id() const { return upload_id_; }
   void set_virtual_dir_path(const FilePath& path) { virtual_dir_path_ = path; }
   const FilePath& virtual_dir_path() const { return virtual_dir_path_; }
   void set_entry(scoped_ptr<DocumentEntry> entry) { entry_ = entry.Pass(); }
   scoped_ptr<DocumentEntry> entry_passed() { return entry_.Pass(); }
   void set_overwrite(bool overwrite) { is_overwrite_ = overwrite; }
   bool is_overwrite() { return is_overwrite_; }
   void set_resource_id(const std::string& resource_id) {
     resource_id_ = resource_id;
   }
   const std::string& resource_id() const { return resource_id_; }
   void set_md5(const std::string& md5) { md5_ = md5; }
   const std::string& md5() const { return md5_; }
 
  private:
-  GDataUploader* uploader_;
+  DriveUploader* uploader_;
   int upload_id_;
   FilePath virtual_dir_path_;
   scoped_ptr<DocumentEntry> entry_;
   bool is_overwrite_;
   std::string resource_id_;
   std::string md5_;
 
   DISALLOW_COPY_AND_ASSIGN(UploadingUserData);
 };
 
@@ skipping 108 matching lines @@
                    substitute_callback));
   } else {
     // TODO(achuith): Handle this.
     NOTREACHED();
   }
 }
 
 }  // namespace
 
 DriveDownloadObserver::DriveDownloadObserver(
-    GDataUploader* uploader,
+    DriveUploader* uploader,
     DriveFileSystemInterface* file_system)
-    : gdata_uploader_(uploader),
+    : drive_uploader_(uploader),
       file_system_(file_system),
       download_manager_(NULL),
       ALLOW_THIS_IN_INITIALIZER_LIST(weak_ptr_factory_(this)) {
 }
 
 DriveDownloadObserver::~DriveDownloadObserver() {
   if (download_manager_)
     download_manager_->RemoveObserver(this);
 
   for (DownloadMap::iterator iter = pending_downloads_.begin();
        iter != pending_downloads_.end(); ++iter) {
     DetachFromDownload(iter->second);
   }
 }
 
 void DriveDownloadObserver::Initialize(
     DownloadManager* download_manager,
     const FilePath& drive_tmp_download_path) {
   DCHECK(!drive_tmp_download_path.empty());
   download_manager_ = download_manager;
   if (download_manager_)
     download_manager_->AddObserver(this);
   drive_tmp_download_path_ = drive_tmp_download_path;
 }
 
 // static
 void DriveDownloadObserver::SubstituteDriveDownloadPath(Profile* profile,
-    const FilePath& gdata_path, content::DownloadItem* download,
+    const FilePath& drive_path, content::DownloadItem* download,
     const SubstituteDriveDownloadPathCallback& callback) {
-  DVLOG(1) << "SubstituteDriveDownloadPath " << gdata_path.value();
+  DVLOG(1) << "SubstituteDriveDownloadPath " << drive_path.value();
 
-  SetDownloadParams(gdata_path, download);
+  SetDownloadParams(drive_path, download);
 
-  if (util::IsUnderGDataMountPoint(gdata_path)) {
+  if (util::IsUnderGDataMountPoint(drive_path)) {
     // Can't access drive if we're not authenticated.
     // We set off a chain of callbacks as follows:
     // DriveServiceInterface::Authenticate
     //   OnAuthenticate calls DriveFileSystem::GetEntryInfoByPath
     //     OnEntryFound calls DriveFileSystem::CreateDirectory (if necessary)
     //       OnCreateDirectory calls SubstituteDriveDownloadPathInternal
     GetSystemService(profile)->drive_service()->Authenticate(
-        base::Bind(&OnAuthenticate, profile, gdata_path,
+        base::Bind(&OnAuthenticate, profile, drive_path,
                    base::Bind(&SubstituteDriveDownloadPathInternal,
                               profile, callback)));
   } else {
-    callback.Run(gdata_path);
+    callback.Run(drive_path);
   }
 }
 
 // static
-void DriveDownloadObserver::SetDownloadParams(const FilePath& gdata_path,
+void DriveDownloadObserver::SetDownloadParams(const FilePath& drive_path,
                                               DownloadItem* download) {
   if (!download)
     return;
 
-  if (util::IsUnderGDataMountPoint(gdata_path)) {
+  if (util::IsUnderGDataMountPoint(drive_path)) {
     download->SetUserData(&kGDataPathKey,
-                          new DriveUserData(gdata_path));
-    download->SetDisplayName(gdata_path.BaseName());
+                          new DriveUserData(drive_path));
+    download->SetDisplayName(drive_path.BaseName());
     download->SetIsTemporary(true);
   } else if (IsDriveDownload(download)) {
     // This may have been previously set if the default download folder is
     // /drive, and the user has now changed the download target to a local
     // folder.
     download->SetUserData(&kGDataPathKey, NULL);
-    download->SetDisplayName(gdata_path);
+    download->SetDisplayName(drive_path);
     // TODO(achuith): This is not quite right.
     download->SetIsTemporary(false);
   }
 }
 
 // static
 FilePath DriveDownloadObserver::GetDrivePath(DownloadItem* download) {
   DriveUserData* data = GetDriveUserData(download);
   // If data is NULL, we've somehow lost the gdata path selected by the file
   // picker.
@@ skipping 154 matching lines @@
 
 void DriveDownloadObserver::UploadDownloadItem(DownloadItem* download) {
   // Update metadata of ongoing upload.
   UpdateUpload(download);
 
   if (!ShouldUpload(download))
     return;
 
   // Initialize uploading userdata.
   download->SetUserData(&kUploadingKey,
-                            new UploadingUserData(gdata_uploader_));
+                            new UploadingUserData(drive_uploader_));
 
   // Create UploadFileInfo structure for the download item.
   CreateUploadFileInfo(download);
 }
 
 void DriveDownloadObserver::UpdateUpload(DownloadItem* download) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 
   UploadingUserData* upload_data = GetUploadingUserData(download);
   if (!upload_data) {
     DVLOG(1) << "No UploadingUserData for download " << download->GetId();
     return;
   }
 
-  gdata_uploader_->UpdateUpload(upload_data->upload_id(), download);
+  drive_uploader_->UpdateUpload(upload_data->upload_id(), download);
 }
 
 bool DriveDownloadObserver::ShouldUpload(DownloadItem* download) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 
   // Upload if the item is in pending_downloads_,
   // is complete or large enough to stream, and,
   // is not already being uploaded.
   return (pending_downloads_.count(download->GetId()) != 0) &&
          (download->AllDataSaved() ||
           download->GetReceivedBytes() > kStreamingFileSize) &&
          (GetUploadingUserData(download) == NULL);
 }
 
 void DriveDownloadObserver::CreateUploadFileInfo(DownloadItem* download) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 
   scoped_ptr<UploadFileInfo> upload_file_info(new UploadFileInfo());
 
   // GetFullPath will be a temporary location if we're streaming.
   upload_file_info->file_path = download->GetFullPath();
   upload_file_info->file_size = download->GetReceivedBytes();
 
   // Extract the final path from DownloadItem.
-  upload_file_info->gdata_path = GetDrivePath(download);
+  upload_file_info->drive_path = GetDrivePath(download);
 
   // Use the file name as the title.
-  upload_file_info->title = upload_file_info->gdata_path.BaseName().value();
+  upload_file_info->title = upload_file_info->drive_path.BaseName().value();
   upload_file_info->content_type = download->GetMimeType();
   // GData api handles -1 as unknown file length.
   upload_file_info->content_length = download->AllDataSaved() ?
                                      download->GetReceivedBytes() : -1;
 
   upload_file_info->all_bytes_present = download->AllDataSaved();
 
   upload_file_info->completion_callback =
       base::Bind(&DriveDownloadObserver::OnUploadComplete,
                  weak_ptr_factory_.GetWeakPtr(),
                  download->GetId());
 
   // First check if |path| already exists. If so, we'll be overwriting an
   // existing file.
-  const FilePath path = upload_file_info->gdata_path;
+  const FilePath path = upload_file_info->drive_path;
   file_system_->GetEntryInfoByPath(
       path,
       base::Bind(
           &DriveDownloadObserver::CreateUploadFileInfoAfterCheckExistence,
           weak_ptr_factory_.GetWeakPtr(),
           download->GetId(),
           base::Passed(&upload_file_info)));
 }
 
 void DriveDownloadObserver::CreateUploadFileInfoAfterCheckExistence(
@@ skipping 32 matching lines @@
     upload_data->set_resource_id(entry_proto->resource_id());
     upload_data->set_md5(entry_proto->file_specific_info().file_md5());
     upload_data->set_overwrite(true);
 
     StartUpload(download_id, upload_file_info.Pass());
   } else {
     // No file exists at the target path, so upload as a new file.
 
     // Get the DriveDirectory proto for the upload directory, then extract the
     // initial upload URL in OnReadDirectoryByPath().
-    const FilePath upload_dir = upload_file_info->gdata_path.DirName();
+    const FilePath upload_dir = upload_file_info->drive_path.DirName();
     file_system_->GetEntryInfoByPath(
         upload_dir,
         base::Bind(
             &DriveDownloadObserver::CreateUploadFileInfoAfterCheckTargetDir,
             weak_ptr_factory_.GetWeakPtr(),
             download_id,
             base::Passed(&upload_file_info)));
   }
 }
 
@@ skipping 27 matching lines @@
   DownloadMap::iterator iter = pending_downloads_.find(download_id);
   if (iter == pending_downloads_.end()) {
     DVLOG(1) << "Pending download not found" << download_id;
     return;
   }
   DVLOG(1) << "Starting upload for download ID " << download_id;
   DownloadItem* download_item = iter->second;
 
   UploadingUserData* upload_data = GetUploadingUserData(download_item);
   DCHECK(upload_data);
-  upload_data->set_virtual_dir_path(upload_file_info->gdata_path.DirName());
+  upload_data->set_virtual_dir_path(upload_file_info->drive_path.DirName());
 
   // Start upload and save the upload id for future reference.
   if (upload_data->is_overwrite()) {
     const int upload_id =
-        gdata_uploader_->StreamExistingFile(upload_file_info.Pass());
+        drive_uploader_->StreamExistingFile(upload_file_info.Pass());
     upload_data->set_upload_id(upload_id);
   } else {
     const int upload_id =
-        gdata_uploader_->UploadNewFile(upload_file_info.Pass());
+        drive_uploader_->UploadNewFile(upload_file_info.Pass());
     upload_data->set_upload_id(upload_id);
   }
 }
 
 void DriveDownloadObserver::OnUploadComplete(
     int32 download_id,
     DriveFileError error,
     scoped_ptr<UploadFileInfo> upload_file_info) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   DCHECK(upload_file_info.get());
@@ skipping 49 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