DownloadManagerDelegate::ShouldCompleteDownload(callback)

chrome/browser/chromeos/gdata/gdata_download_observer.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_download_observer.h"
 
 #include "base/file_util.h"
+#include "chrome/browser/chromeos/gdata/gdata_upload_file_info.h"
 #include "chrome/browser/chromeos/gdata/gdata_uploader.h"
-#include "chrome/browser/chromeos/gdata/gdata_upload_file_info.h"
 #include "chrome/browser/chromeos/gdata/gdata_util.h"
+#include "chrome/browser/download/download_completion_blocker.h"
 #include "net/base/net_util.h"
 
 using content::BrowserThread;
 using content::DownloadManager;
 using content::DownloadItem;
 
 namespace gdata {
 namespace {
 
 // Threshold file size after which we stream the file.
 const int64 kStreamingFileSize = 1 << 20;  // 1MB
 
 // Keys for DownloadItem::ExternalData.
 const char kUploadingKey[] = "Uploading";
 const char kGDataPathKey[] = "GDataPath";
 
 // External Data stored in DownloadItem for ongoing uploads.
-class UploadingExternalData : public DownloadItem::ExternalData {
+class UploadingExternalData : public DownloadCompletionBlocker {
  public:
   UploadingExternalData(GDataUploader* uploader, int upload_id)
       : uploader_(uploader),
-        upload_id_(upload_id),
-        is_complete_(false) {
+        upload_id_(upload_id) {
   }
   virtual ~UploadingExternalData() {}
 
-  void MarkAsComplete() { is_complete_ = true; }
-
   int upload_id() const { return upload_id_; }
-  bool is_complete() const { return is_complete_; }
   GDataUploader* uploader() { return uploader_; }
 
  private:
   GDataUploader* uploader_;
   int upload_id_;
-  bool is_complete_;
+
+  DISALLOW_COPY_AND_ASSIGN(UploadingExternalData);
 };
 
 // External Data stored in DownloadItem for gdata path.
 class GDataExternalData : public DownloadItem::ExternalData {
  public:
   explicit GDataExternalData(const FilePath& path) : file_path_(path) {}
   virtual ~GDataExternalData() {}
 
   const FilePath& file_path() const { return file_path_; }
 
@@ skipping 62 matching lines @@
 }
 
 // static
 bool GDataDownloadObserver::IsGDataDownload(DownloadItem* download) {
   // We use the existence of the GDataExternalData object in download as a
   // signal that this is a GDataDownload.
   return !!GetGDataExternalData(download);
 }
 
 // static
-bool GDataDownloadObserver::IsReadyToComplete(DownloadItem* download) {
+bool GDataDownloadObserver::IsReadyToComplete(
+    DownloadItem* download,
+    const base::Closure& complete_callback) {
   // |download| is ready for completion (as far as GData is concerned) if:
   // 1. It's not a GData download.
   //  - or -
   // 2. The upload has completed.
+  if (!IsGDataDownload(download))
+    return true;
   UploadingExternalData* upload_data = GetUploadingExternalData(download);
-  return !IsGDataDownload(download) ||
-         (upload_data && upload_data->is_complete());
+  DCHECK(upload_data);
+  if (upload_data->is_complete())
+    return true;
+  upload_data->set_complete_callback(complete_callback);
+  return false;
 }
 
 // static
-int64 GDataDownloadObserver::GetUploadedBytes(DownloadItem* download) {
-  UploadingExternalData* upload_data = GetUploadingExternalData(download);
-  if (!upload_data || !upload_data->uploader())
-    return 0;
-  return upload_data->uploader()->GetUploadedBytes(upload_data->upload_id());
-}
-
-// static
 int GDataDownloadObserver::PercentComplete(DownloadItem* download) {
   // Progress is unknown until the upload starts.
   if (!GetUploadingExternalData(download))
     return -1;
   int64 complete = GetUploadedBytes(download);
   // Once AllDataSaved() is true, we can use the GetReceivedBytes() as the total
   // size. GetTotalBytes() may be set to 0 if there was a mismatch between the
   // count of received bytes and the size of the download as given by the
   // Content-Length header.
   int64 total = (download->AllDataSaved() ? download->GetReceivedBytes() :
@@ skipping 170 matching lines @@
 void GDataDownloadObserver::OnUploadComplete(int32 download_id,
                                              base::PlatformFileError error,
                                              UploadFileInfo* upload_file_info) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   DownloadMap::iterator iter = pending_downloads_.find(download_id);
   if (iter == pending_downloads_.end()) {
     DVLOG(1) << "Pending download not found" << download_id;
     return;
   }
   DVLOG(1) << "Completing upload for download ID " << download_id;
-  DownloadItem* download = iter->second;
-  UploadingExternalData* upload_data = GetUploadingExternalData(download);
+  DownloadItem* download_item = iter->second;
+  UploadingExternalData* upload_data = GetUploadingExternalData(download_item);
   DCHECK(upload_data);
-  upload_data->MarkAsComplete();
-  download->MaybeCompleteDownload();
-  // MaybeCompleteDownload() only works for non-SavePackage downloads.
-  // SavePackage::Finish() is the SavePackage equivalent of
-  // MaybeCompleteDownload(). MHTML SavePackages may upload to GData (see
-  // SavePackageFilePickerChromeOS), so MHTML SavePackages use
-  // OnDownloadUpdated() to wait for the upload to complete before calling
-  // Finish(). Call UpdateObservers() manually now in case this download is an
-  // MHTML SavePackage.
-  download->UpdateObservers();
+  upload_data->CompleteDownload();
 }
 
 }  // namespace gdata