gdata: Move GDataFileSystem::AddUploadedFile() call out of uploader and into GDataDownloadObserver.

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/callback.h"
 #include "base/file_util.h"
 #include "chrome/browser/chromeos/gdata/gdata.pb.h"
 #include "chrome/browser/chromeos/gdata/gdata_documents_service.h"
@@ skipping 16 matching lines @@
 // 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 DownloadCompletionBlocker {
  public:
-  UploadingExternalData(GDataUploader* uploader, int upload_id)
+  UploadingExternalData(GDataUploader* uploader,
+                        int upload_id,
+                        const FilePath& virtual_dir_path)
       : uploader_(uploader),
-        upload_id_(upload_id) {
+        upload_id_(upload_id),
+        virtual_dir_path_(virtual_dir_path) {
   }
   virtual ~UploadingExternalData() {}
 
   int upload_id() const { return upload_id_; }
   GDataUploader* uploader() { return uploader_; }
+  const FilePath& virtual_dir_path() const { return virtual_dir_path_; }
+
+  void set_entry(scoped_ptr<DocumentEntry> entry) { entry_ = entry.Pass(); }
+  scoped_ptr<DocumentEntry> entry_passed() { return entry_.Pass(); }
 
  private:
   GDataUploader* uploader_;
   int upload_id_;
+  FilePath virtual_dir_path_;
+  scoped_ptr<DocumentEntry> entry_;
 
   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() {}
 
@@ skipping 103 matching lines @@
         base::Bind(&OnEntryFound, profile, gdata_dir_path,
                    substitute_callback));
   } else {
     // TODO(achuith): Handle this.
     NOTREACHED();
   }
 }
 
 }  // namespace
 
-GDataDownloadObserver::GDataDownloadObserver()
-    : gdata_uploader_(NULL),
+GDataDownloadObserver::GDataDownloadObserver(
+    GDataUploader* uploader,
+    GDataFileSystem* file_system)
+    : gdata_uploader_(uploader),
+      file_system_(file_system),
       download_manager_(NULL),
       ALLOW_THIS_IN_INITIALIZER_LIST(weak_ptr_factory_(this)) {
 }
 
 GDataDownloadObserver::~GDataDownloadObserver() {
   if (download_manager_)
     download_manager_->RemoveObserver(this);
 
   for (DownloadMap::iterator iter = pending_downloads_.begin();
        iter != pending_downloads_.end(); ++iter) {
     DetachFromDownload(iter->second);
   }
 }
 
 void GDataDownloadObserver::Initialize(
-    GDataUploader* gdata_uploader,
     DownloadManager* download_manager,
     const FilePath& gdata_tmp_download_path) {
-  DCHECK(gdata_uploader);
   DCHECK(!gdata_tmp_download_path.empty());
-  gdata_uploader_ = gdata_uploader;
   download_manager_ = download_manager;
   if (download_manager_)
     download_manager_->AddObserver(this);
   gdata_tmp_download_path_ = gdata_tmp_download_path;
 }
 
 // static
 void GDataDownloadObserver::SubstituteGDataDownloadPath(Profile* profile,
     const FilePath& gdata_path, content::DownloadItem* download,
     const SubstituteGDataDownloadPathCallback& callback) {
@@ skipping 141 matching lines @@
 
   const DownloadItem::DownloadState state = download->GetState();
   switch (state) {
     case DownloadItem::IN_PROGRESS:
       AddPendingDownload(download);
       UploadDownloadItem(download);
       break;
 
     case DownloadItem::COMPLETE:
       UploadDownloadItem(download);
+      MoveFileToGDataCache(download);
       RemovePendingDownload(download);
       break;
 
     // TODO(achuith): Stop the pending upload and delete the file.
     case DownloadItem::CANCELLED:
     case DownloadItem::REMOVING:
     case DownloadItem::INTERRUPTED:
       RemovePendingDownload(download);
       break;
 
     default:
       NOTREACHED();
   }
+
   DVLOG(1) << "Number of pending downloads=" << pending_downloads_.size();
 }
 
 void GDataDownloadObserver::AddPendingDownload(DownloadItem* download) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 
   // Add ourself as an observer of this download if we've never seen it before.
   if (pending_downloads_.count(download->GetId()) == 0) {
     pending_downloads_[download->GetId()] = download;
     download->AddObserver(this);
@@ skipping 21 matching lines @@
 }
 
 void GDataDownloadObserver::UploadDownloadItem(DownloadItem* download) {
   // Update metadata of ongoing upload.
   UpdateUpload(download);
 
   if (!ShouldUpload(download))
     return;
 
   scoped_ptr<UploadFileInfo> upload_file_info = CreateUploadFileInfo(download);
+  const FilePath& virtual_dir_path = upload_file_info->gdata_path.DirName();
   const int upload_id = gdata_uploader_->UploadNewFile(
       upload_file_info.Pass());
 
   // TODO(achuith): Fix this.
   // We won't know the upload ID until the after the
   // GDataUploader::UploadNewFile() call.
   download->SetExternalData(&kUploadingKey,
-      new UploadingExternalData(gdata_uploader_, upload_id));
+      new UploadingExternalData(gdata_uploader_, upload_id, virtual_dir_path));
 }
 
 void GDataDownloadObserver::UpdateUpload(DownloadItem* download) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 
   UploadingExternalData* upload_data = GetUploadingExternalData(download);
   if (!upload_data) {
     DVLOG(1) << "No UploadingExternalData for download " << download->GetId();
     return;
   }
@@ skipping 39 matching lines @@
                  download->GetId());
 
   return upload_file_info.Pass();
 }
 
 void GDataDownloadObserver::OnUploadComplete(
     int32 download_id,
     base::PlatformFileError error,
     scoped_ptr<UploadFileInfo> upload_file_info) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
+  DCHECK(upload_file_info.get());
+  DCHECK(upload_file_info->entry.get());
+
+  // Look up the DownloadItem for the |download_id|.
   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_item = iter->second;
+
   UploadingExternalData* upload_data = GetUploadingExternalData(download_item);
   DCHECK(upload_data);
+
+  // Take ownership of the DocumentEntry from UploadFileInfo. This is used by
+  // GDataFileSystem::AddUploadedFile() to add the entry to GDataCache after the
+  // upload completes.
+  upload_data->set_entry(upload_file_info->entry.Pass());
+
+  // Allow the download item to complete.
   upload_data->CompleteDownload();
 }
 
+void GDataDownloadObserver::MoveFileToGDataCache(DownloadItem* download) {
+  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
+
+  UploadingExternalData* data = GetUploadingExternalData(download);
+  if (!data) {
+    NOTREACHED();
+    return;
+  }
+
+  // Take ownership of the DocumentEntry object. It will be released upon
+  // completion of the AddUploadedFile() call below.

[asanka, 2012/07/11 15:56:52]

Is it? It looks like |entry| will leak.

[hshi1, 2012/07/11 16:17:40]

It won't leak. Upon completion of the AddUploadedFile() call below, the callback
specified at line 537 will be invoked to release the |entry|:
base::Bind(&base::DeletePointer<DocumentEntry>, entry)

[asanka, 2012/07/11 16:31:37]

Ah. Sorry. You are right.

+  DocumentEntry* entry = data->entry_passed().release();
+  if (!entry) {
+    NOTREACHED();
+    return;
+  }
+
+  // Move downloaded file to gdata cache. Note that |content_file_path| should
+  // use the final target path when the download item is in COMPLETE state.
+  file_system_->AddUploadedFile(UPLOAD_NEW_FILE,
+                                data->virtual_dir_path(),
+                                entry,
+                                download->GetTargetFilePath(),
+                                GDataCache::FILE_OPERATION_MOVE,
+                                base::Bind(&base::DeletePointer<DocumentEntry>,
+                                           entry));
+}
+
 }  // namespace gdata