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.

[Avi (use Gerrit), 2012/08/07 19:06:24]

comment out of date

[benjhayden, 2012/08/08 13:21:19]

Done.

 const char kUploadingKey[] = "Uploading";
 const char kGDataPathKey[] = "GDataPath";
 
 // External Data stored in DownloadItem for ongoing uploads.
 class UploadingExternalData : public DownloadCompletionBlocker {

[Avi (use Gerrit), 2012/08/07 19:06:24]

rename class? Update comment above?

[benjhayden, 2012/08/08 13:21:19]

Done.

  public:
   explicit UploadingExternalData(GDataUploader* uploader)
       : uploader_(uploader),
         upload_id_(-1) {
   }
   virtual ~UploadingExternalData() {}
 
   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);
 };
 
 // External Data stored in DownloadItem for gdata path.
-class GDataExternalData : public DownloadItem::ExternalData {
+class GDataExternalData : public base::SupportsUserData::Data {
  public:
   explicit GDataExternalData(const FilePath& path) : file_path_(path) {}
   virtual ~GDataExternalData() {}
 
   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));
+      download->GetUserData(&kUploadingKey));
 }
 
 // Extracts GDataExternalData* from |download|.
 GDataExternalData* GetGDataExternalData(DownloadItem* download) {
   return static_cast<GDataExternalData*>(
-      download->GetExternalData(&kGDataPathKey));
+      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 GDataExternalData(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);
   // If data is NULL, we've somehow lost the gdata path selected by the file
@@ skipping 138 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,
+  download->SetUserData(&kUploadingKey,
                             new UploadingExternalData(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);
@@ skipping 143 matching lines @@
   // 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