Make DownloadItem derive SupportsUserData instead of re-implementing it.

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 "base/supports_user_data.h"
 #include "chrome/browser/chromeos/gdata/gdata.pb.h"
 #include "chrome/browser/chromeos/gdata/gdata_documents_service.h"
 #include "chrome/browser/chromeos/gdata/gdata_file_system_interface.h"
 #include "chrome/browser/chromeos/gdata/gdata_system_service.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_util.h"
 #include "chrome/browser/download/download_completion_blocker.h"
 #include "chrome/browser/profiles/profile_manager.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.
+// Keys for base::SupportsUserData::Data.
 const char kUploadingKey[] = "Uploading";
 const char kGDataPathKey[] = "GDataPath";
 
-// External Data stored in DownloadItem for ongoing uploads.
-class UploadingExternalData : public DownloadCompletionBlocker {
+// User Data stored in DownloadItem for ongoing uploads.
+class UploadingUserData : public DownloadCompletionBlocker {
  public:
-  explicit UploadingExternalData(GDataUploader* uploader)
+  explicit UploadingUserData(GDataUploader* uploader)
       : uploader_(uploader),
         upload_id_(-1) {
   }
-  virtual ~UploadingExternalData() {}
+  virtual ~UploadingUserData() {}
 
   GDataUploader* uploader() { return uploader_; }
   void set_upload_id(int upload_id) { upload_id_ = upload_id; }
   int upload_id() const { return upload_id_; }
   void set_virtual_dir_path(const FilePath& path) { virtual_dir_path_ = path; }
   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);
+  DISALLOW_COPY_AND_ASSIGN(UploadingUserData);
 };
 
-// External Data stored in DownloadItem for gdata path.
-class GDataExternalData : public DownloadItem::ExternalData {
+// User Data stored in DownloadItem for gdata path.
+class GDataUserData : public base::SupportsUserData::Data {
  public:
-  explicit GDataExternalData(const FilePath& path) : file_path_(path) {}
-  virtual ~GDataExternalData() {}
+  explicit GDataUserData(const FilePath& path) : file_path_(path) {}
+  virtual ~GDataUserData() {}
 
   const FilePath& file_path() const { return file_path_; }
 
  private:
   FilePath file_path_;
 };
 
-// Extracts UploadingExternalData* from |download|.
-UploadingExternalData* GetUploadingExternalData(DownloadItem* download) {
-  return static_cast<UploadingExternalData*>(
-      download->GetExternalData(&kUploadingKey));
+// Extracts UploadingUserData* from |download|.
+UploadingUserData* GetUploadingUserData(DownloadItem* download) {
+  return static_cast<UploadingUserData*>(
+      download->GetUserData(&kUploadingKey));
 }
 
-// Extracts GDataExternalData* from |download|.
-GDataExternalData* GetGDataExternalData(DownloadItem* download) {
-  return static_cast<GDataExternalData*>(
-      download->GetExternalData(&kGDataPathKey));
+// Extracts GDataUserData* from |download|.
+GDataUserData* GetGDataUserData(DownloadItem* download) {
+  return static_cast<GDataUserData*>(
+      download->GetUserData(&kGDataPathKey));
 }
 
 void RunSubstituteGDataDownloadCallback(
     const GDataDownloadObserver::SubstituteGDataDownloadPathCallback& callback,
     const FilePath* file_path) {
   callback.Run(*file_path);
 }
 
 gdata::GDataSystemService* GetSystemService(Profile* profile) {
   gdata::GDataSystemService* system_service =
@@ skipping 134 matching lines @@
   }
 }
 
 // static
 void GDataDownloadObserver::SetDownloadParams(const FilePath& gdata_path,
                                               DownloadItem* download) {
   if (!download)
     return;
 
   if (gdata::util::IsUnderGDataMountPoint(gdata_path)) {
-    download->SetExternalData(&kGDataPathKey,
-                              new GDataExternalData(gdata_path));
+    download->SetUserData(&kGDataPathKey,
+                          new GDataUserData(gdata_path));
     download->SetDisplayName(gdata_path.BaseName());
     download->SetIsTemporary(true);
   } else if (IsGDataDownload(download)) {
     // This may have been previously set if the default download folder is
     // /drive, and the user has now changed the download target to a local
     // folder.
-    download->SetExternalData(&kGDataPathKey, NULL);
+    download->SetUserData(&kGDataPathKey, NULL);
     download->SetDisplayName(gdata_path);
     // TODO(achuith): This is not quite right.
     download->SetIsTemporary(false);
   }
 }
 
 // static
 FilePath GDataDownloadObserver::GetGDataPath(DownloadItem* download) {
-  GDataExternalData* data = GetGDataExternalData(download);
+  GDataUserData* data = GetGDataUserData(download);
   // If data is NULL, we've somehow lost the gdata path selected by the file
   // picker.
   DCHECK(data);
   return data ? util::ExtractGDataPath(data->file_path()) : FilePath();
 }
 
 // static
 bool GDataDownloadObserver::IsGDataDownload(DownloadItem* download) {
-  // We use the existence of the GDataExternalData object in download as a
+  // We use the existence of the GDataUserData object in download as a
   // signal that this is a GDataDownload.
-  return !!GetGDataExternalData(download);
+  return !!GetGDataUserData(download);
 }
 
 // static
 bool GDataDownloadObserver::IsReadyToComplete(
     DownloadItem* download,
     const base::Closure& complete_callback) {
   DVLOG(1) << "GDataDownloadObserver::IsReadyToComplete";
   // |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);
+  UploadingUserData* upload_data = GetUploadingUserData(download);
   DCHECK(upload_data);
   if (upload_data->is_complete())
     return true;
   upload_data->set_callback(complete_callback);
   return false;
 }
 
 // static
 int64 GDataDownloadObserver::GetUploadedBytes(DownloadItem* download) {
-  UploadingExternalData* upload_data = GetUploadingExternalData(download);
+  UploadingUserData* upload_data = GetUploadingUserData(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))
+  if (!GetUploadingUserData(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() :
                                             download->GetTotalBytes());
   DCHECK(total <= 0 || complete < total);
   if (total > 0)
@@ skipping 85 matching lines @@
   DCHECK(!download->IsInProgress());
 
   DownloadMap::iterator it = pending_downloads_.find(download->GetId());
   if (it != pending_downloads_.end()) {
     DetachFromDownload(download);
     pending_downloads_.erase(it);
   }
 }
 
 void GDataDownloadObserver::DetachFromDownload(DownloadItem* download) {
-  download->SetExternalData(&kUploadingKey, NULL);
-  download->SetExternalData(&kGDataPathKey, NULL);
+  download->SetUserData(&kUploadingKey, NULL);
+  download->SetUserData(&kGDataPathKey, NULL);
   download->RemoveObserver(this);
 }
 
 void GDataDownloadObserver::UploadDownloadItem(DownloadItem* download) {
   // Update metadata of ongoing upload.
   UpdateUpload(download);
 
   if (!ShouldUpload(download))
     return;
 
-  // Initialize uploading external data.
-  download->SetExternalData(&kUploadingKey,
-                            new UploadingExternalData(gdata_uploader_));
+  // Initialize uploading userdata.
+  download->SetUserData(&kUploadingKey,
+                            new UploadingUserData(gdata_uploader_));
 
   // Create UploadFileInfo structure for the download item.
   CreateUploadFileInfo(download);
 }
 
 void GDataDownloadObserver::UpdateUpload(DownloadItem* download) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 
-  UploadingExternalData* upload_data = GetUploadingExternalData(download);
+  UploadingUserData* upload_data = GetUploadingUserData(download);
   if (!upload_data) {
-    DVLOG(1) << "No UploadingExternalData for download " << download->GetId();
+    DVLOG(1) << "No UploadingUserData for download " << download->GetId();
     return;
   }
 
   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->AllDataSaved() ||
           download->GetReceivedBytes() > kStreamingFileSize) &&
-         (GetUploadingExternalData(download) == NULL);
+         (GetUploadingUserData(download) == NULL);
 }
 
 void GDataDownloadObserver::CreateUploadFileInfo(DownloadItem* download) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 
   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();
@@ skipping 50 matching lines @@
 
   // 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) << "Starting upload for download ID " << download_id;
   DownloadItem* download_item = iter->second;
 
-  UploadingExternalData* upload_data = GetUploadingExternalData(download_item);
+  UploadingUserData* upload_data = GetUploadingUserData(download_item);
   DCHECK(upload_data);
   upload_data->set_virtual_dir_path(upload_file_info->gdata_path.DirName());
 
   // Start upload and save the upload id for future reference.
   const int upload_id = gdata_uploader_->UploadNewFile(upload_file_info.Pass());
   upload_data->set_upload_id(upload_id);
 }
 
 void GDataDownloadObserver::OnUploadComplete(
     int32 download_id,
     GDataFileError 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);
+  UploadingUserData* upload_data = GetUploadingUserData(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* upload_data = GetUploadingExternalData(download);
+  UploadingUserData* upload_data = GetUploadingUserData(download);
   if (!upload_data) {
     NOTREACHED();
     return;
   }
 
   // Pass ownership of the DocumentEntry object to AddUploadedFile().
   scoped_ptr<DocumentEntry> entry = upload_data->entry_passed();
   if (!entry.get()) {
     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,
                                 upload_data->virtual_dir_path(),
                                 entry.Pass(),
                                 download->GetTargetFilePath(),
                                 GDataCache::FILE_OPERATION_MOVE,
                                 base::Bind(&base::DoNothing));
 }
 
 }  // namespace gdata