drive: Discard upload location when there is no uploaded contents

chrome/browser/drive/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/drive/drive_uploader.h"
 
 #include <algorithm>
 
 #include "base/bind.h"
 #include "base/callback.h"
@@ skipping 37 matching lines @@
 struct DriveUploader::UploadFileInfo {
   UploadFileInfo(const base::FilePath& local_path,
                  const std::string& content_type,
                  const UploadCompletionCallback& callback,
                  const ProgressCallback& progress_callback)
       : file_path(local_path),
         content_type(content_type),
         completion_callback(callback),
         progress_callback(progress_callback),
         content_length(0),
+        next_start_position(-1),
         power_save_blocker(content::PowerSaveBlocker::Create(
             content::PowerSaveBlocker::kPowerSaveBlockPreventAppSuspension,
             "Upload in progress")),
         cancelled(false),
         weak_ptr_factory_(this) {
   }
 
   ~UploadFileInfo() {
   }
 
@@ skipping 22 matching lines @@
   // Callback to periodically notify the upload progress.
   const ProgressCallback progress_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;
 
+  int64 next_start_position;
+
   // Blocks system suspend while upload is in progress.
   scoped_ptr<content::PowerSaveBlocker> power_save_blocker;
 
   // Fields for implementing cancellation. |cancel_callback| is non-null if
   // there is an in-flight HTTP request. In that case, |cancell_callback| will
   // cancel the operation. |cancelled| is initially false and turns to true
   // once Cancel() is called. DriveUploader will check this field before after
   // an async task other than HTTP requests and cancels the subsequent requests
   // if this is flagged to true.
   CancelCallback cancel_callback;
@@ skipping 178 matching lines @@
     if (code == HTTP_PRECONDITION) {
       // ETag mismatch.
       UploadFailed(upload_file_info.Pass(), HTTP_CONFLICT);
       return;
     }
     UploadFailed(upload_file_info.Pass(), code);
     return;
   }
 
   upload_file_info->upload_location = upload_location;
-  UploadNextChunk(upload_file_info.Pass(), 0);  // start_position
+  upload_file_info->next_start_position = 0;
+  UploadNextChunk(upload_file_info.Pass());
 }
 
 void DriveUploader::StartGetUploadStatus(
     scoped_ptr<UploadFileInfo> upload_file_info) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   DCHECK(upload_file_info);
 
   UploadFileInfo* info_ptr = upload_file_info.get();
   info_ptr->cancel_callback = drive_service_->GetUploadStatus(
       info_ptr->upload_location,
       info_ptr->content_length,
       base::Bind(&DriveUploader::OnUploadRangeResponseReceived,
                  weak_ptr_factory_.GetWeakPtr(),
                  base::Passed(&upload_file_info)));
 }
 
 void DriveUploader::UploadNextChunk(
-    scoped_ptr<UploadFileInfo> upload_file_info,
-    int64 start_position) {
+    scoped_ptr<UploadFileInfo> upload_file_info) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   DCHECK(upload_file_info);
-  DCHECK_GE(start_position, 0);
-  DCHECK_LE(start_position, upload_file_info->content_length);
+  DCHECK_GE(upload_file_info->next_start_position, 0);
+  DCHECK_LE(upload_file_info->next_start_position,
+            upload_file_info->content_length);
 
   if (upload_file_info->cancelled) {
     UploadFailed(upload_file_info.Pass(), GDATA_CANCELLED);
     return;
   }
 
   // Limit the size of data uploaded per each request by kUploadChunkSize.
-  const int64 end_position = std::min(upload_file_info->content_length,
-                                      start_position + kUploadChunkSize);
+  const int64 end_position = std::min(
+      upload_file_info->content_length,
+      upload_file_info->next_start_position + kUploadChunkSize);
 
   UploadFileInfo* info_ptr = upload_file_info.get();
   info_ptr->cancel_callback = drive_service_->ResumeUpload(
       info_ptr->upload_location,
-      start_position,
+      info_ptr->next_start_position,
       end_position,
       info_ptr->content_length,
       info_ptr->content_type,
       info_ptr->file_path,
       base::Bind(&DriveUploader::OnUploadRangeResponseReceived,
                  weak_ptr_factory_.GetWeakPtr(),
                  base::Passed(&upload_file_info)),
       base::Bind(&DriveUploader::OnUploadProgress,
                  weak_ptr_factory_.GetWeakPtr(),
                  info_ptr->progress_callback,
-                 start_position,
+                 info_ptr->next_start_position,
                  info_ptr->content_length));
 }
 
 void DriveUploader::OnUploadRangeResponseReceived(
     scoped_ptr<UploadFileInfo> upload_file_info,
     const UploadRangeResponse& response,
     scoped_ptr<ResourceEntry> entry) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 
   if (response.code == HTTP_CREATED || response.code == HTTP_SUCCESS) {
@@ skipping 33 matching lines @@
     UploadFailed(
         upload_file_info.Pass(),
         response.code == HTTP_FORBIDDEN ? GDATA_NO_SPACE : response.code);
     return;
   }
 
   DVLOG(1) << "Received range " << response.start_position_received
            << "-" << response.end_position_received
            << " for [" << upload_file_info->file_path.value() << "]";
 
-  UploadNextChunk(upload_file_info.Pass(), response.end_position_received);
+  upload_file_info->next_start_position = response.end_position_received;
+  UploadNextChunk(upload_file_info.Pass());
 }
 
 void DriveUploader::OnUploadProgress(const ProgressCallback& callback,
                                      int64 start_position,
                                      int64 total_size,
                                      int64 progress_of_chunk,
                                      int64 total_of_chunk) {
   if (!callback.is_null())
     callback.Run(start_position + progress_of_chunk, total_size);
 }
 
 void DriveUploader::UploadFailed(scoped_ptr<UploadFileInfo> upload_file_info,
                                  GDataErrorCode error) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 
   LOG(ERROR) << "Upload failed " << upload_file_info->DebugString();
 
+  if (upload_file_info->next_start_position < 0) {
+    // Discard the upload location because no request could succeed with it.
+    // Maybe it's obsolete.
+    upload_file_info->upload_location = GURL();
+  }
+
   upload_file_info->completion_callback.Run(
       error, upload_file_info->upload_location, scoped_ptr<ResourceEntry>());
 }
 
 }  // namespace drive