GData downloads cleanup

chrome/browser/chromeos/gdata/gdata_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/chromeos/gdata/gdata_uploader.h"
 
 #include <algorithm>
 
 #include "base/bind.h"
 #include "base/callback.h"
@@ skipping 21 matching lines @@
 
 GDataUploader::GDataUploader(GDataFileSystem* file_system)
   : file_system_(file_system),
     next_upload_id_(0),
     ALLOW_THIS_IN_INITIALIZER_LIST(uploader_factory_(this)) {
 }
 
 GDataUploader::~GDataUploader() {
 }
 
-void GDataUploader::UploadFile(UploadFileInfo* upload_file_info) {
+int GDataUploader::UploadFile(scoped_ptr<UploadFileInfo> upload_file_info) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
-  DCHECK(upload_file_info);
+  DCHECK(upload_file_info.get());
   DCHECK_EQ(upload_file_info->upload_id, -1);
+  DCHECK(!upload_file_info->file_path.empty());
+  DCHECK_NE(upload_file_info->file_size, 0);
+  DCHECK(!upload_file_info->gdata_path.empty());
+  DCHECK(!upload_file_info->title.empty());
+  DCHECK(!upload_file_info->content_type.empty());
 
-  upload_file_info->upload_id = next_upload_id_++;
+  const int upload_id = next_upload_id_++;
+  upload_file_info->upload_id = upload_id;
   // Add upload_file_info to our internal map and take ownership.
-  pending_uploads_[upload_file_info->upload_id] = upload_file_info;
-  DVLOG(1) << "Uploading file: " << upload_file_info->DebugString();
+  pending_uploads_[upload_id] = upload_file_info.release();
+
+  UploadFileInfo* info = GetUploadFileInfo(upload_id);
+  DVLOG(1) << "Uploading file: " << info->DebugString();
 
   // Create a FileStream to make sure the file can be opened successfully.
-  upload_file_info->file_stream = new net::FileStream(NULL);
+  info->file_stream = new net::FileStream(NULL);
 
   // Create buffer to hold upload data.
-  upload_file_info->buf_len = std::min(upload_file_info->file_size,
-                                       kUploadChunkSize);
-  upload_file_info->buf = new net::IOBuffer(upload_file_info->buf_len);
+  info->buf_len = std::min(info->file_size, kUploadChunkSize);
+  info->buf = new net::IOBuffer(info->buf_len);
 
-  OpenFile(upload_file_info);
+  OpenFile(info);
+  return upload_id;
 }
 
 void GDataUploader::UpdateUpload(int upload_id,
                                  content::DownloadItem* download) {
   UploadFileInfo* upload_file_info = GetUploadFileInfo(upload_id);
   if (!upload_file_info)
     return;
 
   const int64 file_size = download->GetReceivedBytes();
 
@@ skipping 23 matching lines @@
     if (upload_file_info->file_path != download->GetFullPath())
       upload_file_info->num_file_open_tries = 0;
     upload_file_info->file_path = download->GetFullPath();
     // Disallow further retries.
     upload_file_info->should_retry_file_open = false;
 
     OpenFile(upload_file_info);
   }
 
   if (download->IsComplete())
-    UploadComplete(upload_file_info);
+    MoveFileToCache(upload_file_info);
 }
 
 int64 GDataUploader::GetUploadedBytes(int upload_id) const {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   UploadFileInfo* upload_info = GetUploadFileInfo(upload_id);
   // We return the start_range as the count of uploaded bytes since that is the
   // start of the next or currently uploading chunk.
   // TODO(asanka): Use a finer grained progress value than this. We end up
   //               reporting progress in kUploadChunkSize increments.
   return upload_info ? upload_info->start_range : 0;
 }
 
 UploadFileInfo* GDataUploader::GetUploadFileInfo(int upload_id) const {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 
   UploadFileInfoMap::const_iterator it = pending_uploads_.find(upload_id);
   DVLOG_IF(1, it == pending_uploads_.end()) << "No upload found for id "
                                             << upload_id;
   return it != pending_uploads_.end() ? it->second : NULL;
 }
 
-void GDataUploader::RemovePendingUpload(UploadFileInfo* upload_file_info) {
-  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
-
-  pending_uploads_.erase(upload_file_info->upload_id);
-  if (!upload_file_info->completion_callback.is_null()) {
-    upload_file_info->completion_callback.Run(
-        base::PLATFORM_FILE_ERROR_ABORT, NULL);
-  }
-
-  file_system_->CancelOperation(upload_file_info->gdata_path);
-
-  // The file stream is closed by the destructor asynchronously.
-  delete upload_file_info->file_stream;
-  delete upload_file_info;
-}
-
 void GDataUploader::OpenFile(UploadFileInfo* upload_file_info) {
   // Open the file asynchronously.
   const int rv = upload_file_info->file_stream->Open(
       upload_file_info->file_path,
       base::PLATFORM_FILE_OPEN |
       base::PLATFORM_FILE_READ |
       base::PLATFORM_FILE_ASYNC,
       base::Bind(&GDataUploader::OpenCompletionCallback,
                  uploader_factory_.GetWeakPtr(),
                  upload_file_info->upload_id));
@@ skipping 17 matching lines @@
 
     DVLOG(1) << "Error opening \"" << upload_file_info->file_path.value()
              << "\" for reading: " << net::ErrorToString(result)
              << ", tries=" << upload_file_info->num_file_open_tries;
 
     // Stop trying to open this file if we exceed kMaxFileOpenTries.
     const bool exceeded_max_attempts =
         upload_file_info->num_file_open_tries >= kMaxFileOpenTries;
     upload_file_info->should_retry_file_open = !exceeded_max_attempts;
     if (exceeded_max_attempts)
-      RemovePendingUpload(upload_file_info);
+      UploadFailed(upload_file_info);
 
     return;
   }
 
   // Open succeeded, initiate the upload.
   upload_file_info->should_retry_file_open = false;
   file_system_->InitiateUpload(
       upload_file_info->title,
       upload_file_info->content_type,
       upload_file_info->content_length,
@@ skipping 12 matching lines @@
 
   UploadFileInfo* upload_file_info = GetUploadFileInfo(upload_id);
   if (!upload_file_info)
     return;
 
   DVLOG(1) << "Got upload location [" << upload_location.spec()
            << "] for [" << upload_file_info->title << "]";
 
   if (code != HTTP_SUCCESS) {
     // TODO(achuith): Handle error codes from Google Docs server.
-    RemovePendingUpload(upload_file_info);
-    NOTREACHED();
+    UploadFailed(upload_file_info);
     return;
   }
 
   upload_file_info->upload_location = upload_location;
 
   // Start the upload from the beginning of the file.
   UploadNextChunk(upload_file_info);
 }
 
 void GDataUploader::UploadNextChunk(UploadFileInfo* upload_file_info) {
@@ skipping 77 matching lines @@
   if (!upload_file_info)
     return;
 
   if (response.code == HTTP_CREATED) {
     DVLOG(1) << "Successfully created uploaded file=["
              << upload_file_info->title;
 
     // Done uploading.
     upload_file_info->entry = entry.Pass();
     if (!upload_file_info->completion_callback.is_null()) {
-      upload_file_info->completion_callback.Run(
-          base::PLATFORM_FILE_OK,
-          upload_file_info->entry.get());
-      upload_file_info->completion_callback.Reset();
+      upload_file_info->completion_callback.Run(base::PLATFORM_FILE_OK,
+                                                upload_file_info);

[asanka, 2012/03/28 22:02:33]

Minor Nit: Perhaps have a way to assert that we only invoke the callback once?

[achuithb, 2012/03/28 23:27:11]

I've put the Reset back in.

     }
+    // TODO(achuith): DeleteUpload() here and let clients call
+    // GDataFileSystem::AddUploadedFile.
     return;
   }
 
   // If code is 308 (RESUME_INCOMPLETE) and range_received is what has been
   // previously uploaded (i.e. = upload_file_info->end_range), proceed to
   // upload the next chunk.
   if (response.code != HTTP_RESUME_INCOMPLETE ||
       response.start_range_received != 0 ||
       response.end_range_received != upload_file_info->end_range) {
     // TODO(achuith): Handle error cases, e.g.
     // - when previously uploaded data wasn't received by Google Docs server,
     //   i.e. when end_range_received < upload_file_info->end_range
     // - when quota is exceeded, which is 1GB for files not converted to Google
     //   Docs format; even though the quota-exceeded content length
     //   is specified in the header when posting request to get upload
     //   location, the server allows us to upload all chunks of entire file
     //   successfully, but instead of returning 201 (CREATED) status code after
     //   receiving the last chunk, it returns 403 (FORBIDDEN); response content
     //   then will indicate quote exceeded exception.
     NOTREACHED() << "UploadNextChunk http code=" << response.code
                  << ", start_range_received=" << response.start_range_received
                  << ", end_range_received=" << response.end_range_received
                  << ", expected end range=" << upload_file_info->end_range;
 
-    RemovePendingUpload(upload_file_info);
+    UploadFailed(upload_file_info);
     return;
   }
 
   DVLOG(1) << "Received range " << response.start_range_received
            << "-" << response.end_range_received
            << " for [" << upload_file_info->title << "]";
 
   // Continue uploading.
   UploadNextChunk(upload_file_info);
 }
 
-void GDataUploader::UploadComplete(UploadFileInfo* upload_file_info) {
-  DVLOG(1) << "UploadComplete " << upload_file_info->file_path.value();
-  file_system_->AddUploadedFile(upload_file_info->gdata_path.DirName(),
-                                upload_file_info->entry.get(),
-                                upload_file_info->file_path,
-                                GDataFileSystemInterface::FILE_OPERATION_MOVE);
-  RemovePendingUpload(upload_file_info);
+void GDataUploader::MoveFileToCache(UploadFileInfo* upload_file_info) {
+  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
+  if (upload_file_info->entry == NULL)
+    return;
+
+  DVLOG(1) << "MoveFileToCache " << upload_file_info->file_path.value();
+  file_system_->AddUploadedFile(
+      upload_file_info->gdata_path.DirName(),
+      upload_file_info->entry.get(),
+      upload_file_info->file_path,
+      GDataFileSystemInterface::FILE_OPERATION_MOVE);
+  DeleteUpload(upload_file_info);
+}
+
+void GDataUploader::UploadFailed(UploadFileInfo* upload_file_info) {
+  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
+  LOG(ERROR) << "Upload failed " << upload_file_info->DebugString();
+  if (!upload_file_info->completion_callback.is_null()) {
+    upload_file_info->completion_callback.Run(base::PLATFORM_FILE_ERROR_ABORT,
+                                              upload_file_info);
+  }
+  file_system_->CancelOperation(upload_file_info->gdata_path);
+  DeleteUpload(upload_file_info);
+}
+
+void GDataUploader::DeleteUpload(UploadFileInfo* upload_file_info) {
+  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
+
+  DVLOG(1) << "Deleting upload " << upload_file_info->gdata_path.value();
+  pending_uploads_.erase(upload_file_info->upload_id);
+
+  // The file stream is closed by the destructor asynchronously.
+  delete upload_file_info->file_stream;
+  delete upload_file_info;
 }
 
 }  // namespace gdata