Split InitiateUpload method into two.

chrome/browser/google_apis/drive_uploader.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/google_apis/drive_uploader.h"
 
 #include <algorithm>
 
 #include "base/bind.h"
 #include "base/callback.h"
@@ skipping 27 matching lines @@
 
 }  // namespace
 
 namespace google_apis {
 
 // Structure containing current upload information of file, passed between
 // DriveServiceInterface methods and callbacks.
 struct DriveUploader::UploadFileInfo {
   UploadFileInfo(scoped_refptr<base::SequencedTaskRunner> task_runner,
                  UploadMode upload_mode,
-                 const GURL& initial_upload_location,
-                 const base::FilePath& drive_path,
-                 const base::FilePath& local_path,
-                 const std::string& title,
+                 const FilePath& drive_path,
+                 const FilePath& local_path,
                  const std::string& content_type,
-                 const std::string& etag,
                  const UploadCompletionCallback& callback)
       : upload_mode(upload_mode),
-        initial_upload_location(initial_upload_location),
         drive_path(drive_path),
         file_path(local_path),
-        title(title),
         content_type(content_type),
-        etag(etag),
         completion_callback(callback),
         content_length(0),
         next_send_position(0),
         file_stream(new net::FileStream(NULL)),
         buf(new net::IOBuffer(kUploadChunkSize)),
         blocking_task_runner(task_runner),
         power_save_blocker(content::PowerSaveBlocker::Create(
             content::PowerSaveBlocker::kPowerSaveBlockPreventAppSuspension,
             "Upload in progress")) {
   }
 
   ~UploadFileInfo() {
     blocking_task_runner->DeleteSoon(FROM_HERE, file_stream.release());
   }
 
   // Bytes left to upload.
   int64 SizeRemaining()  const {
     DCHECK(content_length >= next_send_position);
     return content_length - next_send_position;
   }
 
   // Useful for printf debugging.
   std::string DebugString() const {
-    return "title=[" + title +
-           "], file_path=[" + file_path.AsUTF8Unsafe() +
+    return "file_path=[" + file_path.AsUTF8Unsafe() +
            "], content_type=[" + content_type +
            "], content_length=[" + base::UintToString(content_length) +
            "], drive_path=[" + drive_path.AsUTF8Unsafe() +
            "]";
   }
 
   // Whether this is uploading a new file or updating an existing file.
   const UploadMode upload_mode;
 
-  // Location URL used to get |upload_location| with InitiateUpload.
-  const GURL initial_upload_location;
-
   // Final path in gdata. Looks like /special/drive/MyFolder/MyFile.
   const base::FilePath drive_path;
 
   // The local file path of the file to be uploaded.
   const base::FilePath file_path;
 
-  // Title to be used for file to be uploaded.
-  const std::string title;
-
   // Content-Type of file.
   const std::string content_type;
 
-  const std::string etag;
-
   // Callback to be invoked once the upload has finished.
   const UploadCompletionCallback completion_callback;
 
   // Location URL where file is to be uploaded to, returned from
   // InitiateUpload. Used for the subsequent ResumeUpload requests.
   GURL upload_location;
 
   // Header content-Length.
   int64 content_length;
 
@@ skipping 22 matching lines @@
 DriveUploader::DriveUploader(DriveServiceInterface* drive_service)
     : drive_service_(drive_service),
       ALLOW_THIS_IN_INITIALIZER_LIST(weak_ptr_factory_(this)) {
   base::SequencedWorkerPool* blocking_pool = BrowserThread::GetBlockingPool();
   blocking_task_runner_ = blocking_pool->GetSequencedTaskRunner(
       blocking_pool->GetSequenceToken());
 }
 
 DriveUploader::~DriveUploader() {}
 
-void DriveUploader::UploadNewFile(const GURL& upload_location,
+void DriveUploader::UploadNewFile(const GURL& parent_upload_url,
                                   const base::FilePath& drive_file_path,
                                   const base::FilePath& local_file_path,
                                   const std::string& title,
                                   const std::string& content_type,
                                   const UploadCompletionCallback& callback) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
-  DCHECK(!upload_location.is_empty());
+  DCHECK(!parent_upload_url.is_empty());
   DCHECK(!drive_file_path.empty());
   DCHECK(!local_file_path.empty());
   DCHECK(!title.empty());
   DCHECK(!content_type.empty());
   DCHECK(!callback.is_null());
 
-  StartUploadFile(scoped_ptr<UploadFileInfo>(new UploadFileInfo(
-      blocking_task_runner_,
-      UPLOAD_NEW_FILE,
-      upload_location,
-      drive_file_path,
-      local_file_path,
-      title,
-      content_type,
-      "",  // etag
-      callback
-  )));
+  StartUploadFile(
+      scoped_ptr<UploadFileInfo>(new UploadFileInfo(blocking_task_runner_,
+                                                    UPLOAD_NEW_FILE,
+                                                    drive_file_path,
+                                                    local_file_path,
+                                                    content_type,
+                                                    callback)),
+      base::Bind(&DriveUploader::StartInitiateUploadNewFile,
+                 weak_ptr_factory_.GetWeakPtr(),
+                 parent_upload_url,
+                 title));
 }
 
 void DriveUploader::UploadExistingFile(
-    const GURL& upload_location,
+    const GURL& upload_url,
     const base::FilePath& drive_file_path,
     const base::FilePath& local_file_path,
     const std::string& content_type,
     const std::string& etag,
     const UploadCompletionCallback& callback) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
-  DCHECK(!upload_location.is_empty());
+  DCHECK(!upload_url.is_empty());
   DCHECK(!drive_file_path.empty());
   DCHECK(!local_file_path.empty());
   DCHECK(!content_type.empty());
   DCHECK(!callback.is_null());
 
-  StartUploadFile(scoped_ptr<UploadFileInfo>(new UploadFileInfo(
-      blocking_task_runner_,
-      UPLOAD_EXISTING_FILE,
-      upload_location,
-      drive_file_path,
-      local_file_path,
-      "",  // title : not necessary for update of an existing file.
-      content_type,
-      etag,
-      callback
-  )));
+  StartUploadFile(
+      scoped_ptr<UploadFileInfo>(new UploadFileInfo(blocking_task_runner_,
+                                                    UPLOAD_EXISTING_FILE,
+                                                    drive_file_path,
+                                                    local_file_path,
+                                                    content_type,
+                                                    callback)),
+      base::Bind(&DriveUploader::StartInitiateUploadExistingFile,
+                 weak_ptr_factory_.GetWeakPtr(),
+                 upload_url,
+                 etag));
 }
 
 void DriveUploader::StartUploadFile(
-    scoped_ptr<UploadFileInfo> upload_file_info) {
+    scoped_ptr<UploadFileInfo> upload_file_info,
+    const StartInitiateUploadCallback& start_initiate_upload_callback) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   DVLOG(1) << "Uploading file: " << upload_file_info->DebugString();
 
   // Passing a raw net::FileStream* to the blocking pool is safe, because it is
   // owned by |upload_file_info| in the reply callback.
   UploadFileInfo* info_ptr = upload_file_info.get();
   base::PostTaskAndReplyWithResult(
       blocking_task_runner_.get(),
       FROM_HERE,
       base::Bind(&OpenFileStreamAndGetSizeOnBlockingPool,
                  info_ptr->file_stream.get(),
                  info_ptr->file_path),
       base::Bind(&DriveUploader::OpenCompletionCallback,
                  weak_ptr_factory_.GetWeakPtr(),
-                 base::Passed(&upload_file_info)));
+                 base::Passed(&upload_file_info),
+                 start_initiate_upload_callback));
 }
 
 void DriveUploader::OpenCompletionCallback(
-    scoped_ptr<UploadFileInfo> upload_file_info, int64 file_size) {
+    scoped_ptr<UploadFileInfo> upload_file_info,
+    const StartInitiateUploadCallback& start_initiate_upload_callback,
+    int64 file_size) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 
   if (file_size < 0) {
     UploadFailed(upload_file_info.Pass(), DRIVE_UPLOAD_ERROR_NOT_FOUND);
     return;
   }
 
   upload_file_info->content_length = file_size;
 
   // Open succeeded, initiate the upload.
+  start_initiate_upload_callback.Run(upload_file_info.Pass());
+}
+
+void DriveUploader::StartInitiateUploadNewFile(
+    const GURL& parent_upload_url,
+    const std::string& title,
+    scoped_ptr<UploadFileInfo> upload_file_info) {
+  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
+
   UploadFileInfo* info_ptr = upload_file_info.get();
-  drive_service_->InitiateUpload(
-      InitiateUploadParams(info_ptr->upload_mode,
-                           info_ptr->title,
-                           info_ptr->content_type,
-                           info_ptr->content_length,
-                           info_ptr->initial_upload_location,
-                           info_ptr->drive_path,
-                           info_ptr->etag),
+  drive_service_->InitiateUploadNewFile(
+      info_ptr->drive_path,
+      info_ptr->content_type,
+      info_ptr->content_length,
+      parent_upload_url,
+      title,
       base::Bind(&DriveUploader::OnUploadLocationReceived,
                  weak_ptr_factory_.GetWeakPtr(),
                  base::Passed(&upload_file_info)));
+}
+
+void DriveUploader::StartInitiateUploadExistingFile(
+    const GURL& upload_url,
+    const std::string& etag,
+    scoped_ptr<UploadFileInfo> upload_file_info) {
+  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
+
+  UploadFileInfo* info_ptr = upload_file_info.get();
+  drive_service_->InitiateUploadExistingFile(
+      info_ptr->drive_path,
+      info_ptr->content_type,
+      info_ptr->content_length,
+      upload_url,
+      etag,
+      base::Bind(&DriveUploader::OnUploadLocationReceived,
+                 weak_ptr_factory_.GetWeakPtr(),
+                 base::Passed(&upload_file_info)));
 }
 
 void DriveUploader::OnUploadLocationReceived(
     scoped_ptr<UploadFileInfo> upload_file_info,
     GDataErrorCode code,
     const GURL& upload_location) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 
   DVLOG(1) << "Got upload location [" << upload_location.spec()
-           << "] for [" << upload_file_info->title << "]";
+           << "] for [" << upload_file_info->drive_path.value() << "]";
 
   if (code != HTTP_SUCCESS) {
     // TODO(achuith): Handle error codes from Google Docs server.
     if (code == HTTP_PRECONDITION) {
       // ETag mismatch.
       UploadFailed(upload_file_info.Pass(), DRIVE_UPLOAD_ERROR_CONFLICT);
       return;
     }
     UploadFailed(upload_file_info.Pass(), DRIVE_UPLOAD_ERROR_ABORT);
     return;
@@ skipping 79 matching lines @@
 void DriveUploader::OnUploadRangeResponseReceived(
     scoped_ptr<UploadFileInfo> upload_file_info,
     const UploadRangeResponse& response,
     scoped_ptr<ResourceEntry> entry) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 
   const UploadMode upload_mode = upload_file_info->upload_mode;
   if ((upload_mode == UPLOAD_NEW_FILE && response.code == HTTP_CREATED) ||
       (upload_mode == UPLOAD_EXISTING_FILE && response.code == HTTP_SUCCESS)) {
     DVLOG(1) << "Successfully created uploaded file=["
-             << upload_file_info->title << "]";
+             << upload_file_info->drive_path.value() << "]";
 
     // Done uploading.
     upload_file_info->completion_callback.Run(DRIVE_UPLOAD_OK,
                                               upload_file_info->drive_path,
                                               upload_file_info->file_path,
                                               entry.Pass());
     return;
   }
 
   // ETag mismatch.
@@ skipping 16 matching lines @@
         << ", end_position_received=" << response.end_position_received
         << ", expected end range=" << upload_file_info->next_send_position;
     UploadFailed(upload_file_info.Pass(),
                  response.code == HTTP_FORBIDDEN ?
                      DRIVE_UPLOAD_ERROR_NO_SPACE : DRIVE_UPLOAD_ERROR_ABORT);
     return;
   }
 
   DVLOG(1) << "Received range " << response.start_position_received
            << "-" << response.end_position_received
-           << " for [" << upload_file_info->title << "]";
+           << " for [" << upload_file_info->drive_path.value() << "]";
 
   // Continue uploading.
   UploadNextChunk(upload_file_info.Pass());
 }
 
 void DriveUploader::UploadFailed(scoped_ptr<UploadFileInfo> upload_file_info,
                                  DriveUploadError error) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 
   LOG(ERROR) << "Upload failed " << upload_file_info->DebugString();
 
   upload_file_info->completion_callback.Run(error,
                                             upload_file_info->drive_path,
                                             upload_file_info->file_path,
                                             scoped_ptr<ResourceEntry>());
 }
 
 }  // namespace google_apis