GData downloads cleanup

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_uploader.h"
 #include "chrome/browser/chromeos/gdata/gdata_upload_file_info.h"
 #include "chrome/browser/chromeos/gdata/gdata_util.h"
@@ skipping 70 matching lines @@
 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(const FilePath& temp_download_path,
-                                       GDataUploader* gdata_uploader,
-                                       DownloadManager* download_manager) {
-  temp_download_path_ = temp_download_path;
+void GDataDownloadObserver::Initialize(
+    GDataUploader* gdata_uploader,
+    DownloadManager* download_manager,
+    const FilePath& gdata_tmp_download_path) {
   gdata_uploader_ = gdata_uploader;

[Ben Chan, 2012/03/28 05:29:36]

nit: Seems like |gdata_uploader_| is not expected to be NULL.  perhaps adding
DCHECK(gdata_uploader_)

[achuithb, 2012/03/28 09:14:04]

Done.

   download_manager_ = download_manager;
   if (download_manager_)
     download_manager_->AddObserver(this);
+  gdata_tmp_download_path_ = gdata_tmp_download_path;
 }
 
 // static
 void GDataDownloadObserver::SetGDataPath(DownloadItem* download,
                                          const FilePath& path) {
   if (download)
       download->SetExternalData(&kGDataPathKey,
                                 new GDataExternalData(path));
 }
 
@@ skipping 63 matching lines @@
     DownloadManager* download_manager) {
   download_manager->RemoveObserver(this);
   download_manager_ = NULL;
 }
 
 void GDataDownloadObserver::ModelChanged(DownloadManager* download_manager) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 
   DownloadManager::DownloadVector downloads;
   // GData downloads are considered temporary downloads.
-  download_manager->GetTemporaryDownloads(temp_download_path_,
+  download_manager->GetTemporaryDownloads(gdata_tmp_download_path_,
                                           &downloads);
   for (size_t i = 0; i < downloads.size(); ++i) {
     // Only accept downloads that have the GData meta data associated with
     // them. Otherwise we might trip over non-GData downloads being saved to
-    // temp_download_path_.
+    // gdata_tmp_download_path_.
     if (IsGDataDownload(downloads[i]))
       OnDownloadUpdated(downloads[i]);
   }
 }
 
 void GDataDownloadObserver::OnDownloadUpdated(DownloadItem* download) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 
   const DownloadItem::DownloadState state = download->GetState();
   switch (state) {
@@ skipping 50 matching lines @@
   download->RemoveObserver(this);
 }
 
 void GDataDownloadObserver::UploadDownloadItem(DownloadItem* download) {
   // Update metadata of ongoing upload.
   UpdateUpload(download);
 
   if (!ShouldUpload(download))
     return;
 
-  UploadFileInfo* upload_file_info = CreateUploadFileInfo(download);
-  gdata_uploader_->UploadFile(upload_file_info);
+  scoped_ptr<UploadFileInfo> upload_file_info = CreateUploadFileInfo(download);
+  const int upload_id = gdata_uploader_->UploadFile(upload_file_info.Pass());
 
+  // TODO(achuith): Fix this.
   // We won't know the upload ID until the after the GDataUploader::UploadFile()
   // call.
   download->SetExternalData(&kUploadingKey,
-      new UploadingExternalData(gdata_uploader_, upload_file_info->upload_id));
+      new UploadingExternalData(gdata_uploader_, upload_id));
 }
 
 void GDataDownloadObserver::UpdateUpload(DownloadItem* download) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 
-  UploadingExternalData* external_data = GetUploadingExternalData(download);
-  if (!external_data) {
+  UploadingExternalData* upload_data = GetUploadingExternalData(download);
+  if (!upload_data) {
     DVLOG(1) << "No UploadingExternalData for download " << download->GetId();
     return;
   }
 
-  gdata_uploader_->UpdateUpload(external_data->upload_id(), download);
+  gdata_uploader_->UpdateUpload(upload_data->upload_id(), download);
 }
 
 bool GDataDownloadObserver::ShouldUpload(DownloadItem* download) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 
   // Upload if the item is in pending_downloads_,
   // is complete or large enough to stream, and,
   // is not already being uploaded.
   return pending_downloads_.count(download->GetId()) != 0 &&
          (download->IsComplete() ||
              download->GetReceivedBytes() > kStreamingFileSize) &&
          GetUploadingExternalData(download) == NULL;
 }
 
-UploadFileInfo* GDataDownloadObserver::CreateUploadFileInfo(
+scoped_ptr<UploadFileInfo> GDataDownloadObserver::CreateUploadFileInfo(
     DownloadItem* download) {
-  UploadFileInfo* upload_file_info = new UploadFileInfo();
+  scoped_ptr<UploadFileInfo> upload_file_info(new UploadFileInfo());
 
   // GetFullPath will be a temporary location if we're streaming.
   upload_file_info->file_path = download->GetFullPath();
   upload_file_info->file_size = download->GetReceivedBytes();
 
   // Extract the final path from DownloadItem.
   upload_file_info->gdata_path = GetGDataPath(download);
 
   // Use the file name as the title.
   upload_file_info->title = upload_file_info->gdata_path.BaseName().value();
   upload_file_info->content_type = download->GetMimeType();
   // GData api handles -1 as unknown file length.
   upload_file_info->content_length = download->AllDataSaved() ?
                                      download->GetReceivedBytes() : -1;
 
   upload_file_info->all_bytes_present = download->AllDataSaved();
 
   upload_file_info->completion_callback =
       base::Bind(&GDataDownloadObserver::OnUploadComplete,
-                 weak_ptr_factory_.GetWeakPtr(), download->GetId());
+                 weak_ptr_factory_.GetWeakPtr(),
+                 download->GetId());
 
-  return upload_file_info;
+  return upload_file_info.Pass();
 }
 
 void GDataDownloadObserver::OnUploadComplete(int32 download_id,
                                              base::PlatformFileError error,
-                                             DocumentEntry* unused_entry) {
+                                             UploadFileInfo* upload_file_info) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   DownloadMap::iterator iter = pending_downloads_.find(download_id);
   if (iter == pending_downloads_.end())
     return;
   DVLOG(1) << "Completing upload for download ID " << download_id;
   DownloadItem* download = iter->second;
   UploadingExternalData* upload_data = GetUploadingExternalData(download);
   DCHECK(upload_data);
   upload_data->MarkAsComplete();
   download->MaybeCompleteDownload();
 }
 
 }  // namespace gdata