Remove DownloadManager::GetDownloadItem in favor of GetDownload()

chrome/browser/download/chrome_download_manager_delegate.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/download/chrome_download_manager_delegate.h"
 
 #include <string>
 
 #include "base/bind.h"
 #include "base/bind_helpers.h"
@@ skipping 606 matching lines @@
   DownloadPathReservationTracker::GetReservedPath(
       download, target_path, default_download_path, should_uniquify_path,
       callback);
 }
 
 void ChromeDownloadManagerDelegate::CheckDownloadUrlDone(
     int32 download_id,
     const content::DownloadTargetCallback& callback,
     DownloadProtectionService::DownloadCheckResult result) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
-  DownloadItem* download =
-      download_manager_->GetActiveDownloadItem(download_id);
+  DownloadItem* download = download_manager_->GetDownload(download_id);

[Randy Smith (Not in Mondays), 2012/09/11 19:02:21]

So this seems like a behavior change that I don't offhand see why we should do? 
If the item was cancelled during the download url check, we'd drop it on the
floor at this point; now we don't.  Do we want that?

Same comment for other GetActiveDownloadItem->GetDownload transitions in this
file.

[benjhayden, 2012/09/12 18:17:25]

Done.

   if (!download)
     return;
 
   VLOG(2) << __FUNCTION__ << "() download = " << download->DebugString(false)
           << " verdict = " << result;
   content::DownloadDangerType danger_type = download->GetDangerType();
   if (result != DownloadProtectionService::SAFE)
     danger_type = content::DOWNLOAD_DANGER_TYPE_DANGEROUS_URL;
 
   download_history_->CheckVisitedReferrerBefore(
       download_id, download->GetReferrerUrl(),
       base::Bind(&ChromeDownloadManagerDelegate::CheckVisitedReferrerBeforeDone,
                  this, download_id, callback, danger_type));
 }
 
 void ChromeDownloadManagerDelegate::CheckClientDownloadDone(
     int32 download_id,
     DownloadProtectionService::DownloadCheckResult result) {
-  DownloadItem* item = download_manager_->GetActiveDownloadItem(download_id);
+  DownloadItem* item = download_manager_->GetDownload(download_id);
   if (!item)
     return;
 
   VLOG(2) << __FUNCTION__ << "() download = " << item->DebugString(false)
           << " verdict = " << result;
   // We only mark the content as being dangerous if the download's safety state
   // has not been set to DANGEROUS yet.  We don't want to show two warnings.
   if (item->GetSafetyState() == DownloadItem::SAFE) {
     switch (result) {
       case DownloadProtectionService::SAFE:
@@ skipping 24 matching lines @@
 
   registrar_.Remove(this,
                     chrome::NOTIFICATION_CRX_INSTALLER_DONE,
                     source);
 
   scoped_refptr<extensions::CrxInstaller> installer =
       content::Source<extensions::CrxInstaller>(source).ptr();
   int download_id = crx_installers_[installer];
   crx_installers_.erase(installer.get());
 
-  DownloadItem* item = download_manager_->GetActiveDownloadItem(download_id);
+  DownloadItem* item = download_manager_->GetDownload(download_id);
   if (item)
     item->DelayedDownloadOpened(installer->did_handle_successfully());
 }
 
 void ChromeDownloadManagerDelegate::CheckVisitedReferrerBeforeDone(
     int32 download_id,
     const content::DownloadTargetCallback& callback,
     content::DownloadDangerType danger_type,
     bool visited_referrer_before) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 
   DownloadItem* download =
-      download_manager_->GetActiveDownloadItem(download_id);
+      download_manager_->GetDownload(download_id);
   if (!download)
     return;
 
   bool should_prompt = (download->GetTargetDisposition() ==
                         DownloadItem::TARGET_DISPOSITION_PROMPT);
   bool is_forced_path = !download->GetForcedFilePath().empty();
   FilePath suggested_path;
 
   // Check whether this download is for an extension install or not.
   // Allow extensions to be explicitly saved.
@@ skipping 90 matching lines @@
 // TODO(asanka): Merge this logic with the logic in DownloadFilePickerChromeOS.
 void ChromeDownloadManagerDelegate::SubstituteDriveDownloadPathCallback(
     int32 download_id,
     const content::DownloadTargetCallback& callback,
     bool should_prompt,
     bool is_forced_path,
     content::DownloadDangerType danger_type,
     const FilePath& suggested_path) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   DownloadItem* download =
-      download_manager_->GetActiveDownloadItem(download_id);
+      download_manager_->GetDownload(download_id);
   if (!download)
     return;
 
   GetReservedPath(
       *download, suggested_path, download_prefs_->DownloadPath(),
       !is_forced_path,
       base::Bind(&ChromeDownloadManagerDelegate::OnPathReservationAvailable,
                  this, download->GetId(), callback, should_prompt,
                  danger_type));
 }
 #endif
 
 void ChromeDownloadManagerDelegate::OnPathReservationAvailable(
     int32 download_id,
     const content::DownloadTargetCallback& callback,
     bool should_prompt,
     content::DownloadDangerType danger_type,
     const FilePath& reserved_path,
     bool reserved_path_verified) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   DownloadItem* download =
-      download_manager_->GetActiveDownloadItem(download_id);
+      download_manager_->GetDownload(download_id);
   if (!download)
     return;
   if (should_prompt || !reserved_path_verified) {
     // If the target path could not be verified then the path was non-existant,
     // non writeable or could not be uniquified. Prompt the user.
     ChooseDownloadPath(
         download, reserved_path,
         base::Bind(&ChromeDownloadManagerDelegate::OnTargetPathDetermined,
                    this, download_id, callback,
                    DownloadItem::TARGET_DISPOSITION_PROMPT, danger_type));
   } else {
     OnTargetPathDetermined(download_id, callback,
                            DownloadItem::TARGET_DISPOSITION_OVERWRITE,
                            danger_type, reserved_path);
   }
 }
 
 void ChromeDownloadManagerDelegate::OnTargetPathDetermined(
     int32 download_id,
     const content::DownloadTargetCallback& callback,
     DownloadItem::TargetDisposition disposition,
     content::DownloadDangerType danger_type,
     const FilePath& target_path) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   FilePath intermediate_path;
   DownloadItem* download =
-      download_manager_->GetActiveDownloadItem(download_id);
+      download_manager_->GetDownload(download_id);
   if (!download)
     return;
 
   // If |target_path| is empty, then that means that the user wants to cancel
   // the download.
   if (!target_path.empty()) {
     intermediate_path = GetIntermediatePath(target_path, danger_type);
 
     // Retain the last directory. Exclude temporary downloads since the path
     // likely points at the location of a temporary file.
@@ skipping 12 matching lines @@
     int32 download_id, int64 db_handle) {
   // It's not immediately obvious, but HistoryBackend::CreateDownload() can
   // call this function with an invalid |db_handle|. For instance, this can
   // happen when the history database is offline. We cannot have multiple
   // DownloadItems with the same invalid db_handle, so we need to assign a
   // unique |db_handle| here.
   if (db_handle == DownloadItem::kUninitializedHandle)
     db_handle = download_history_->GetNextFakeDbHandle();
   download_manager_->OnItemAddedToPersistentStore(download_id, db_handle);
 }