gdata: Convert GDataFileSystem::AddUploadFile() to asynchronous.

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 55 matching lines @@
   // Create buffer to hold upload data.
   info->buf_len = std::min(info->file_size, kUploadChunkSize);
   info->buf = new net::IOBuffer(info->buf_len);
 
   OpenFile(info);
   return upload_id;
 }
 
 void GDataUploader::UpdateUpload(int upload_id,
                                  content::DownloadItem* download) {
+  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
+
   UploadFileInfo* upload_file_info = GetUploadFileInfo(upload_id);
   if (!upload_file_info)
     return;
 
   const int64 file_size = download->GetReceivedBytes();
 
   // Update file_size and all_bytes_present.
   DVLOG(1) << "Updating file size from " << upload_file_info->file_size
            << " to " << file_size
            << (download->AllDataSaved() ? " (AllDataSaved)" : " (In-progress)");
@@ skipping 85 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)
-      UploadFailed(upload_file_info, base::PLATFORM_FILE_ERROR_NOT_FOUND);
+      UploadFailed(scoped_ptr<UploadFileInfo>(upload_file_info),
+                   base::PLATFORM_FILE_ERROR_NOT_FOUND);
 
     return;
   }
 
   // Open succeeded, initiate the upload.
   upload_file_info->should_retry_file_open = false;
   const GURL destination_directory_url = file_system_->GetUploadUrlForDirectory(
       upload_file_info->gdata_path.DirName());
   if (destination_directory_url.is_empty()) {
-    UploadFailed(upload_file_info, base::PLATFORM_FILE_ERROR_ABORT);
+    UploadFailed(scoped_ptr<UploadFileInfo>(upload_file_info),
+                 base::PLATFORM_FILE_ERROR_ABORT);
     return;
   }
 
   documents_service_->InitiateUpload(
       InitiateUploadParams(upload_file_info->title,
                            upload_file_info->content_type,
                            upload_file_info->content_length,
                            destination_directory_url,
                            upload_file_info->gdata_path),
       base::Bind(&GDataUploader::OnUploadLocationReceived,
                  uploader_factory_.GetWeakPtr(),
                  upload_file_info->upload_id));
 }
 
 void GDataUploader::OnUploadLocationReceived(
     int upload_id,
     GDataErrorCode code,
     const GURL& upload_location) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 
   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.
-    UploadFailed(upload_file_info, base::PLATFORM_FILE_ERROR_ABORT);
+    UploadFailed(scoped_ptr<UploadFileInfo>(upload_file_info),
+                 base::PLATFORM_FILE_ERROR_ABORT);
     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 74 matching lines @@
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 
   UploadFileInfo* upload_file_info = GetUploadFileInfo(upload_id);
   if (!upload_file_info)
     return;
 
   if (response.code == HTTP_CREATED) {
     DVLOG(1) << "Successfully created uploaded file=["
              << upload_file_info->title;
 
+    // Remove |upload_id| from the UploadFileInfoMap. The UploadFileInfo object
+    // will be deleted upon completion of completion_callback.
+    RemoveUpload(upload_id);
+
     // 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);
+      upload_file_info->completion_callback.Run(
+          base::PLATFORM_FILE_OK,
+          scoped_ptr<UploadFileInfo>(upload_file_info));
     }
-    // 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
     LOG(ERROR) << "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;
-    UploadFailed(upload_file_info,
+    UploadFailed(
+        scoped_ptr<UploadFileInfo>(upload_file_info),
         response.code == HTTP_FORBIDDEN ?
             base::PLATFORM_FILE_ERROR_NO_SPACE :
             base::PLATFORM_FILE_ERROR_ABORT);
     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::MoveFileToCache(UploadFileInfo* upload_file_info) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   if (upload_file_info->entry == NULL)
     return;
 
+  // Remove |upload_id| from the UploadFileInfoMap. The UploadFileInfo object
+  // will be deleted upon completion of AddUploadedFile.
+  RemoveUpload(upload_file_info->upload_id);
+
   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,
-      GDataCache::FILE_OPERATION_MOVE);
-  DeleteUpload(upload_file_info);
+      GDataCache::FILE_OPERATION_MOVE,
+      base::Bind(&base::DeletePointer<UploadFileInfo>,
+                 upload_file_info));
 }
 
-void GDataUploader::UploadFailed(UploadFileInfo* upload_file_info,
+void GDataUploader::UploadFailed(scoped_ptr<UploadFileInfo> upload_file_info,
                                  base::PlatformFileError error) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
+
+  RemoveUpload(upload_file_info->upload_id);
+
   LOG(ERROR) << "Upload failed " << upload_file_info->DebugString();
   if (!upload_file_info->completion_callback.is_null()) {
     upload_file_info->completion_callback.Run(error,
-                                              upload_file_info);
+                                              upload_file_info.Pass());
   }
-  DeleteUpload(upload_file_info);
 }
 
-void GDataUploader::DeleteUpload(UploadFileInfo* upload_file_info) {
+void GDataUploader::RemoveUpload(int upload_id) {
   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;
+  pending_uploads_.erase(upload_id);
 }
 
 }  // namespace gdata