Rename GDataUplaoder to DriveUploader

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/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_proxy.h"
 #include "base/metrics/histogram.h"
 #include "base/platform_file.h"
 #include "base/stringprintf.h"
 #include "base/threading/sequenced_worker_pool.h"
 #include "base/values.h"
 #include "chrome/browser/chromeos/gdata/drive.pb.h"
 #include "chrome/browser/chromeos/gdata/drive_api_parser.h"
 #include "chrome/browser/chromeos/gdata/drive_files.h"
 #include "chrome/browser/chromeos/gdata/drive_file_system_util.h"
 #include "chrome/browser/chromeos/gdata/drive_function_remove.h"
 #include "chrome/browser/chromeos/gdata/drive_service_interface.h"
 #include "chrome/browser/chromeos/gdata/drive_system_service.h"
+#include "chrome/browser/chromeos/gdata/drive_uploader.h"
 #include "chrome/browser/chromeos/gdata/drive_webapps_registry.h"
-#include "chrome/browser/chromeos/gdata/gdata_uploader.h"
 #include "chrome/browser/chromeos/gdata/gdata_util.h"
 #include "chrome/browser/chromeos/gdata/task_util.h"
 #include "chrome/browser/prefs/pref_service.h"
 #include "chrome/browser/profiles/profile.h"
 #include "chrome/common/chrome_notification_types.h"
 #include "chrome/common/pref_names.h"
 #include "content/public/browser/browser_thread.h"
 #include "content/public/browser/notification_details.h"
 #include "net/base/mime_util.h"
 
@@ skipping 344 matching lines @@
   base::Closure callback;
 };
 
 
 // DriveFileSystem class implementation.
 
 DriveFileSystem::DriveFileSystem(
     Profile* profile,
     DriveCache* cache,
     DriveServiceInterface* drive_service,
-    GDataUploaderInterface* uploader,
+    DriveUploaderInterface* 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),
@@ skipping 296 matching lines @@
                  base::Owned(file_size),
                  base::Owned(content_type)));
 }
 
 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().
+  // DriveUploader::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;
@@ skipping 25 matching lines @@
     if (!params.callback.is_null())
       params.callback.Run(error);
     return;
   }
   DCHECK(entry_proto.get());
 
   // Fill in values of UploadFileInfo.
   scoped_ptr<UploadFileInfo> upload_file_info(new UploadFileInfo);
   upload_file_info->file_path = params.local_file_path;
   upload_file_info->file_size = file_size;
-  upload_file_info->gdata_path = params.remote_file_path;
+  upload_file_info->drive_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->completion_callback =
       base::Bind(&DriveFileSystem::OnTransferCompleted,
                  ui_weak_ptr_,
                  params.callback);
 
   uploader_->UploadNewFile(upload_file_info.Pass());
 }
 
 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->drive_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 DriveFileSystem::Copy(const FilePath& src_file_path,
@@ skipping 1254 matching lines @@
   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->drive_path.DirName(),
                   upload_file_info->entry.Pass(),
                   upload_file_info->file_path,
                   DriveCache::FILE_OPERATION_MOVE,
                   base::Bind(&OnAddUploadFileCompleted, callback, error));
 }
 
 void DriveFileSystem::GetAvailableSpace(
     const GetAvailableSpaceCallback& callback) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI) ||
          BrowserThread::CurrentlyOn(BrowserThread::IO));
@@ skipping 1152 matching lines @@
     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