Download code cleanup patch of death:

chrome/browser/download/download_manager.cc

 // Copyright (c) 2010 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/download_manager.h"
 
 #include "app/l10n_util.h"
 #include "app/resource_bundle.h"
 #include "base/callback.h"
 #include "base/file_util.h"
 #include "base/logging.h"
 #include "base/path_service.h"
 #include "base/rand_util.h"
 #include "base/sys_string_conversions.h"
 #include "base/task.h"
 #include "build/build_config.h"
 #include "chrome/browser/browser.h"
 #include "chrome/browser/browser_list.h"
 #include "chrome/browser/browser_process.h"
 #include "chrome/browser/chrome_thread.h"
 #include "chrome/browser/download/download_file_manager.h"
+#include "chrome/browser/download/download_history.h"
 #include "chrome/browser/download/download_item.h"
 #include "chrome/browser/download/download_util.h"
 #include "chrome/browser/extensions/crx_installer.h"
 #include "chrome/browser/extensions/extension_install_ui.h"
 #include "chrome/browser/extensions/extensions_service.h"
 #include "chrome/browser/history/download_types.h"
 #include "chrome/browser/net/chrome_url_request_context.h"
 #include "chrome/browser/platform_util.h"
 #include "chrome/browser/profile.h"
 #include "chrome/browser/renderer_host/render_process_host.h"
@@ skipping 27 matching lines @@
 void DeleteDownloadedFile(const FilePath& path) {
   DCHECK(ChromeThread::CurrentlyOn(ChromeThread::FILE));
 
   // Make sure we only delete files.
   if (!file_util::DirectoryExists(path))
     file_util::Delete(path, false);
 }
 
 }  // namespace
 
-// Our download table ID starts at 1, so we use 0 to represent a download that
-// has started, but has not yet had its data persisted in the table. We use fake
-// database handles in incognito mode starting at -1 and progressively getting
-// more negative.
-// static
-const int DownloadManager::kUninitializedHandle = 0;
-
 // static
 void DownloadManager::RegisterUserPrefs(PrefService* prefs) {
   prefs->RegisterBooleanPref(prefs::kPromptForDownload, false);
   prefs->RegisterStringPref(prefs::kDownloadExtensionsToOpen, "");
   prefs->RegisterBooleanPref(prefs::kDownloadDirUpgraded, false);
 
   // The default download path is userprofile\download.
   const FilePath& default_download_path =
       download_util::GetDefaultDownloadDirectory();
   prefs->RegisterFilePathPref(prefs::kDownloadDefaultDirectory,
@@ skipping 16 matching lines @@
       prefs->SetFilePath(prefs::kDownloadDefaultDirectory,
                          default_download_path);
     }
     prefs->SetBoolean(prefs::kDownloadDirUpgraded, true);
   }
 }
 
 DownloadManager::DownloadManager()
     : shutdown_needed_(false),
       profile_(NULL),
-      file_manager_(NULL),
-      fake_db_handle_(kUninitializedHandle - 1) {
+      file_manager_(NULL) {
 }
 
 DownloadManager::~DownloadManager() {
   FOR_EACH_OBSERVER(Observer, observers_, ManagerGoingDown());
 
   if (shutdown_needed_)
     Shutdown();
 }
 
 void DownloadManager::Shutdown() {
   DCHECK(shutdown_needed_) << "Shutdown called when not needed.";
 
   // Stop receiving download updates
   if (file_manager_)
     file_manager_->RemoveDownloadManager(this);
 
-  // Stop making history service requests
-  cancelable_consumer_.CancelAllRequests();
-
   // 'in_progress_' may contain DownloadItems that have not finished the start
   // complete (from the history service) and thus aren't in downloads_.
   DownloadMap::iterator it = in_progress_.begin();
   std::set<DownloadItem*> to_remove;
   for (; it != in_progress_.end(); ++it) {
     DownloadItem* download = it->second;
     if (download->safety_state() == DownloadItem::DANGEROUS) {
       // Forget about any download that the user did not approve.
       // Note that we cannot call download->Remove() this would invalidate our
       // iterator.
       to_remove.insert(download);
       continue;
     }
     DCHECK_EQ(DownloadItem::IN_PROGRESS, download->state());
     download->Cancel(false);
-    UpdateHistoryForDownload(download);
-    if (download->db_handle() == kUninitializedHandle) {
+    download_history_->UpdateEntry(download);
+    if (download->db_handle() == DownloadHistory::kUninitializedHandle) {
       // An invalid handle means that 'download' does not yet exist in
       // 'downloads_', so we have to delete it here.
       delete download;
     }
   }
 
   // 'dangerous_finished_' contains all complete downloads that have not been
   // approved.  They should be removed.
   it = dangerous_finished_.begin();
   for (; it != dangerous_finished_.end(); ++it)
     to_remove.insert(it->second);
 
   // Remove the dangerous download that are not approved.
   for (std::set<DownloadItem*>::const_iterator rm_it = to_remove.begin();
        rm_it != to_remove.end(); ++rm_it) {
     DownloadItem* download = *rm_it;
     int64 handle = download->db_handle();
     download->Remove(true);
     // Same as above, delete the download if it is not in 'downloads_' (as the
     // Remove() call above won't have deleted it).
-    if (handle == kUninitializedHandle)
+    if (handle == DownloadHistory::kUninitializedHandle)
       delete download;
   }
   to_remove.clear();
 
   in_progress_.clear();
   dangerous_finished_.clear();
   STLDeleteValues(&downloads_);
 
   file_manager_ = NULL;
 
   // Save our file extensions to auto open.
   SaveAutoOpens();
 
   // Make sure the save as dialog doesn't notify us back if we're gone before
   // it returns.
   if (select_file_dialog_.get())
     select_file_dialog_->ListenerDestroyed();
 
+  download_history_.reset();
+
   shutdown_needed_ = false;
 }
 
-// Issue a history query for downloads matching 'search_text'. If 'search_text'
-// is empty, return all downloads that we know about.
-void DownloadManager::GetDownloads(Observer* observer,
-                                   const std::wstring& search_text) {
-  std::vector<DownloadItem*> otr_downloads;
-
-  if (profile_->IsOffTheRecord() && search_text.empty()) {
-    // List all incognito downloads and add that to the downloads the parent
-    // profile lists.
-    otr_downloads.reserve(downloads_.size());
-    for (DownloadMap::iterator it = downloads_.begin();
-         it != downloads_.end(); ++it) {
-      DownloadItem* download = it->second;
-      if (download->is_otr() && !download->is_extension_install() &&
-          !download->is_temporary()) {
-        otr_downloads.push_back(download);
-      }
-    }
-  }
-
-  profile_->GetOriginalProfile()->GetDownloadManager()->
-    DoGetDownloads(observer, search_text, otr_downloads);
-}
-
-void DownloadManager::DoGetDownloads(
-    Observer* observer,
-    const std::wstring& search_text,
-    std::vector<DownloadItem*>& otr_downloads) {
-  DCHECK(observer);
-
-  // Return a empty list if we've not yet received the set of downloads from the
-  // history system (we'll update all observers once we get that list in
-  // OnQueryDownloadEntriesComplete), or if there are no downloads at all.
-  if (downloads_.empty()) {
-    observer->SetDownloads(otr_downloads);
-    return;
-  }
-
-  std::vector<DownloadItem*> download_copy;
-  // We already know all the downloads and there is no filter, so just return a
-  // copy to the observer.
-  if (search_text.empty()) {
-    download_copy.reserve(downloads_.size());
-    for (DownloadMap::iterator it = downloads_.begin();
-         it != downloads_.end(); ++it) {
-      if (it->second->db_handle() > kUninitializedHandle)
-        download_copy.push_back(it->second);
-    }
-
-    // Merge sort based on start time.
-    std::vector<DownloadItem*> merged_downloads;
-    std::merge(otr_downloads.begin(), otr_downloads.end(),
-               download_copy.begin(), download_copy.end(),
-               std::back_inserter(merged_downloads),
-               CompareStartTime);
-
-    // We retain ownership of the DownloadItems.
-    observer->SetDownloads(merged_downloads);
-    return;
-  }
-
-  DCHECK(otr_downloads.empty());
-
-  // Issue a request to the history service for a list of downloads matching
-  // our search text.
-  HistoryService* hs =
-      profile_->GetHistoryService(Profile::EXPLICIT_ACCESS);
-  if (hs) {
-    HistoryService::Handle h =
-        hs->SearchDownloads(WideToUTF16(search_text),
-                            &cancelable_consumer_,
-                            NewCallback(this,
-                                        &DownloadManager::OnSearchComplete));
-    cancelable_consumer_.SetClientData(hs, h, observer);
-  }
-}
-
-void DownloadManager::GetTemporaryDownloads(Observer* observer,
-                                            const FilePath& dir_path) {
-  DCHECK(observer);
-
-  std::vector<DownloadItem*> download_copy;
+void DownloadManager::GetTemporaryDownloads(
+    const FilePath& dir_path, std::vector<DownloadItem*>* result) {
+  DCHECK(result);
 
   for (DownloadMap::iterator it = downloads_.begin();
        it != downloads_.end(); ++it) {
     if (it->second->is_temporary() &&
         it->second->full_path().DirName() == dir_path)
-      download_copy.push_back(it->second);
+      result->push_back(it->second);
   }
-
-  observer->SetDownloads(download_copy);
 }
 
-void DownloadManager::GetAllDownloads(Observer* observer,
-                                      const FilePath& dir_path) {
-  DCHECK(observer);
-
-  std::vector<DownloadItem*> download_copy;
+void DownloadManager::GetAllDownloads(
+    const FilePath& dir_path, std::vector<DownloadItem*>* result) {
+  DCHECK(result);
 
   for (DownloadMap::iterator it = downloads_.begin();
        it != downloads_.end(); ++it) {
     if (!it->second->is_temporary() &&
         (dir_path.empty() || it->second->full_path().DirName() == dir_path))
-      download_copy.push_back(it->second);
+      result->push_back(it->second);
   }
-
-  observer->SetDownloads(download_copy);
 }
 
-void DownloadManager::GetCurrentDownloads(Observer* observer,
-                                          const FilePath& dir_path) {
-  DCHECK(observer);
-
-  std::vector<DownloadItem*> download_copy;
+void DownloadManager::GetCurrentDownloads(
+    const FilePath& dir_path, std::vector<DownloadItem*>* result) {
+  DCHECK(result);
 
   for (DownloadMap::iterator it = downloads_.begin();
        it != downloads_.end(); ++it) {
     if (!it->second->is_temporary() &&
         (it->second->state() == DownloadItem::IN_PROGRESS ||
          it->second->safety_state() == DownloadItem::DANGEROUS) &&
         (dir_path.empty() || it->second->full_path().DirName() == dir_path))
-      download_copy.push_back(it->second);
+      result->push_back(it->second);
   }
-
-  observer->SetDownloads(download_copy);
 }
 
 // Query the history service for information about all persisted downloads.
 bool DownloadManager::Init(Profile* profile) {
   DCHECK(profile);
   DCHECK(!shutdown_needed_)  << "DownloadManager already initialized.";
   shutdown_needed_ = true;
 
   profile_ = profile;
   request_context_getter_ = profile_->GetRequestContext();
-
-  // 'incognito mode' will have access to past downloads, but we won't store
-  // information about new downloads while in that mode.
-  QueryHistoryForDownloads();
-
-  // Cleans up entries only when called for the first time. Subsequent calls are
-  // a no op.
-  CleanUpInProgressHistoryEntries();
+  download_history_.reset(new DownloadHistory(profile, this));
+  download_history_->Load(
+      NewCallback(this, &DownloadManager::OnQueryDownloadEntriesComplete));
 
   // In test mode, there may be no ResourceDispatcherHost.  In this case it's
   // safe to avoid setting |file_manager_| because we only call a small set of
   // functions, none of which need it.
   ResourceDispatcherHost* rdh = g_browser_process->resource_dispatcher_host();
   if (rdh) {
     file_manager_ = rdh->download_file_manager();
     DCHECK(file_manager_);
   }
 
@@ skipping 24 matching lines @@
     if (!extensions[i].empty() && !IsExecutableFile(path))
       auto_open_.insert(path.value());
   }
 
   other_download_manager_observer_.reset(
       new OtherDownloadManagerObserver(this));
 
   return true;
 }
 
-void DownloadManager::QueryHistoryForDownloads() {
-  HistoryService* hs = profile_->GetHistoryService(Profile::EXPLICIT_ACCESS);
-  if (hs) {
-    hs->QueryDownloads(
-        &cancelable_consumer_,
-        NewCallback(this, &DownloadManager::OnQueryDownloadEntriesComplete));
-  }
-}
-
-void DownloadManager::CleanUpInProgressHistoryEntries() {
-  static bool already_cleaned_up = false;
-
-  if (!already_cleaned_up) {
-    HistoryService* hs = profile_->GetHistoryService(Profile::EXPLICIT_ACCESS);
-    if (hs) {
-      hs->CleanUpInProgressEntries();
-      already_cleaned_up = true;
-    }
-  }
-}
-
 // We have received a message from DownloadFileManager about a new download. We
 // create a download item and store it in our download map, and inform the
 // history system of a new download. Since this method can be called while the
 // history service thread is still reading the persistent state, we do not
 // insert the new DownloadItem into 'downloads_' or inform our observers at this
 // point. OnCreateDatabaseEntryComplete() handles that finalization of the the
 // download creation as a callback from the history thread.
 void DownloadManager::StartDownload(DownloadCreateInfo* info) {
   DCHECK(ChromeThread::CurrentlyOn(ChromeThread::UI));
   DCHECK(info);
@@ skipping 196 matching lines @@
 
   if (download_finished) {
     // If the download already completed by the time we reached this point, then
     // notify observers that it did.
     DownloadFinished(info->download_id,
                      pending_finished_downloads_[info->download_id]);
   }
 
   download->Rename(target_path);
 
-  // Do not store the download in the history database for a few special cases:
-  // - incognito mode (that is the point of this mode)
-  // - extensions (users don't think of extension installation as 'downloading')
-  // - temporary download, like in drag-and-drop
-  // - history service is not available (e.g. in tests)
-  // We have to make sure that these handles don't collide with normal db
-  // handles, so we use a negative value. Eventually, they could overlap, but
-  // you'd have to do enough downloading that your ISP would likely stab you in
-  // the neck first. YMMV.
-  // FIXME(paulg) see bug 958058. EXPLICIT_ACCESS below is wrong.
-  HistoryService* hs = profile_->GetHistoryService(Profile::EXPLICIT_ACCESS);
-  if (download->is_otr() || download->is_extension_install() ||
-      download->is_temporary() || !hs) {
-    OnCreateDownloadEntryComplete(*info, fake_db_handle_.GetNext());
-  } else {
-    // Update the history system with the new download.
-    hs->CreateDownload(
-        *info, &cancelable_consumer_,
-        NewCallback(this, &DownloadManager::OnCreateDownloadEntryComplete));
-  }
+  download_history_->AddEntry(*info, download,
+      NewCallback(this, &DownloadManager::OnCreateDownloadEntryComplete));
 
   UpdateAppIcon();
 }
 
-// Convenience function for updating the history service for a download.
-void DownloadManager::UpdateHistoryForDownload(DownloadItem* download) {
-  DCHECK(download);
-
-  // Don't store info in the database if the download was initiated while in
-  // incognito mode or if it hasn't been initialized in our database table.
-  if (download->db_handle() <= kUninitializedHandle)
-    return;
-
-  // FIXME(paulg) see bug 958058. EXPLICIT_ACCESS below is wrong.
-  HistoryService* hs = profile_->GetHistoryService(Profile::EXPLICIT_ACCESS);
-  if (hs) {
-    hs->UpdateDownload(download->received_bytes(),
-                       download->state(),
-                       download->db_handle());
-  }
-}
-
-void DownloadManager::RemoveDownloadFromHistory(DownloadItem* download) {
-  DCHECK(download);
-  // FIXME(paulg) see bug 958058. EXPLICIT_ACCESS below is wrong.
-  HistoryService* hs = profile_->GetHistoryService(Profile::EXPLICIT_ACCESS);
-  if (download->db_handle() > kUninitializedHandle && hs)
-    hs->RemoveDownload(download->db_handle());
-}
-
-void DownloadManager::RemoveDownloadsFromHistoryBetween(
-    const base::Time remove_begin,
-    const base::Time remove_end) {
-  // FIXME(paulg) see bug 958058. EXPLICIT_ACCESS below is wrong.
-  HistoryService* hs = profile_->GetHistoryService(Profile::EXPLICIT_ACCESS);
-  if (hs)
-    hs->RemoveDownloadsBetween(remove_begin, remove_end);
-}
-
 void DownloadManager::UpdateDownload(int32 download_id, int64 size) {
   DownloadMap::iterator it = in_progress_.find(download_id);
   if (it != in_progress_.end()) {
     DownloadItem* download = it->second;
     download->Update(size);
-    UpdateHistoryForDownload(download);
+    download_history_->UpdateEntry(download);
   }
   UpdateAppIcon();
 }
 
 void DownloadManager::DownloadFinished(int32 download_id, int64 size) {
   DownloadMap::iterator it = in_progress_.find(download_id);
   if (it == in_progress_.end()) {
     // The download is done, but the user hasn't selected a final location for
     // it yet (the Save As dialog box is probably still showing), so just keep
     // track of the fact that this download id is complete, when the
     // DownloadItem is constructed later we'll notify its completion then.
     PendingFinishedMap::iterator erase_it =
         pending_finished_downloads_.find(download_id);
     DCHECK(erase_it == pending_finished_downloads_.end());
     pending_finished_downloads_[download_id] = size;
     return;
   }
 
   // Remove the id from the list of pending ids.
   PendingFinishedMap::iterator erase_it =
       pending_finished_downloads_.find(download_id);
   if (erase_it != pending_finished_downloads_.end())
     pending_finished_downloads_.erase(erase_it);
 
   DownloadItem* download = it->second;
   download->Finished(size);
 
   // Clean up will happen when the history system create callback runs if we
   // don't have a valid db_handle yet.
-  if (download->db_handle() != kUninitializedHandle) {
+  if (download->db_handle() != DownloadHistory::kUninitializedHandle) {
     in_progress_.erase(it);
-    UpdateHistoryForDownload(download);
+    download_history_->UpdateEntry(download);
   }
 
   UpdateAppIcon();
 
   // If this a dangerous download not yet validated by the user, don't do
   // anything. When the user notifies us, it will trigger a call to
   // ProceedWithFinishedDangerousDownload.
   if (download->safety_state() == DownloadItem::DANGEROUS) {
     dangerous_finished_[download_id] = download;
     return;
@@ skipping 131 matching lines @@
 }
 
 void DownloadManager::DownloadCancelled(int32 download_id) {
   DownloadMap::iterator it = in_progress_.find(download_id);
   if (it == in_progress_.end())
     return;
   DownloadItem* download = it->second;
 
   // Clean up will happen when the history system create callback runs if we
   // don't have a valid db_handle yet.
-  if (download->db_handle() != kUninitializedHandle) {
+  if (download->db_handle() != DownloadHistory::kUninitializedHandle) {
     in_progress_.erase(it);
-    UpdateHistoryForDownload(download);
+    download_history_->UpdateEntry(download);
   }
 
   DownloadCancelledInternal(download_id,
                             download->render_process_id(),
                             download->request_id());
   UpdateAppIcon();
 }
 
 void DownloadManager::DownloadCancelledInternal(int download_id,
                                                 int render_process_id,
@@ skipping 72 matching lines @@
     progress = (float)received_bytes / total_bytes;
 
   download_util::UpdateAppIconDownloadProgress(download_count,
                                                progress_known,
                                                progress);
 }
 
 void DownloadManager::RenameDownload(DownloadItem* download,
                                      const FilePath& new_path) {
   download->Rename(new_path);
-
-  // Update the history.
-
-  // No update necessary if the download was initiated while in incognito mode.
-  if (download->db_handle() <= kUninitializedHandle)
-    return;
-
-  // FIXME(paulg) see bug 958058. EXPLICIT_ACCESS below is wrong.
-  HistoryService* hs = profile_->GetHistoryService(Profile::EXPLICIT_ACCESS);
-  if (hs)
-    hs->UpdateDownloadPath(new_path, download->db_handle());
+  download_history_->UpdateDownloadPath(download, new_path);
 }
 
 void DownloadManager::RemoveDownload(int64 download_handle) {
   DownloadMap::iterator it = downloads_.find(download_handle);
   if (it == downloads_.end())
     return;
 
   // Make history update.
   DownloadItem* download = it->second;
-  RemoveDownloadFromHistory(download);
+  download_history_->RemoveEntry(download);
 
   // Remove from our tables and delete.
   downloads_.erase(it);
   it = dangerous_finished_.find(download->id());
   if (it != dangerous_finished_.end())
     dangerous_finished_.erase(it);
 
   // Tell observers to refresh their views.
   NotifyModelChanged();
 
   delete download;
 }
 
 int DownloadManager::RemoveDownloadsBetween(const base::Time remove_begin,
                                             const base::Time remove_end) {
-  RemoveDownloadsFromHistoryBetween(remove_begin, remove_end);
+  download_history_->RemoveEntriesBetween(remove_begin, remove_end);
 
   DownloadMap::iterator it = downloads_.begin();
   std::vector<DownloadItem*> pending_deletes;
   while (it != downloads_.end()) {
     DownloadItem* download = it->second;
     DownloadItem::DownloadState state = download->state();
     if (download->start_time() >= remove_begin &&
         (remove_end.is_null() || download->start_time() < remove_end) &&
         (state == DownloadItem::COMPLETE ||
          state == DownloadItem::CANCELLED)) {
@@ skipping 399 matching lines @@
 #endif
       extensions += this_extension + ":";
     }
     if (!extensions.empty())
       extensions.erase(extensions.size() - 1);
 
     prefs->SetString(prefs::kDownloadExtensionsToOpen, extensions);
   }
 }
 
+DownloadItem* DownloadManager::GetDownloadItemFromDbHandle(int64 db_handle) {
+  for (DownloadMap::iterator it = downloads_.begin();
+       it != downloads_.end(); ++it) {
+    DownloadItem* item = it->second;
+    if (item->db_handle() == db_handle)
+      return item;
+  }
+  return NULL;
+}
+
 void DownloadManager::FileSelected(const FilePath& path,
                                    int index, void* params) {
   DownloadCreateInfo* info = reinterpret_cast<DownloadCreateInfo*>(params);
   if (info->prompt_user_for_save_location)
     last_download_path_ = path.DirName();
   ContinueStartDownload(info, path);
 }
 
 void DownloadManager::FileSelectionCanceled(void* params) {
   // The user didn't pick a place to save the file, so need to cancel the
@@ skipping 73 matching lines @@
   DownloadMap::iterator it = in_progress_.find(info.download_id);
   DCHECK(it != in_progress_.end());
 
   DownloadItem* download = it->second;
 
   // 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 == kUninitializedHandle)
-    db_handle = fake_db_handle_.GetNext();
+  if (db_handle == DownloadHistory::kUninitializedHandle)
+    db_handle = download_history_->GetNextFakeDbHandle();
 
-  DCHECK(download->db_handle() == kUninitializedHandle);
+  DCHECK(download->db_handle() == DownloadHistory::kUninitializedHandle);
   download->set_db_handle(db_handle);
 
   // Insert into our full map.
   DCHECK(downloads_.find(download->db_handle()) == downloads_.end());
   downloads_[download->db_handle()] = download;
 
   // Show in the appropropriate browser UI.
   ShowDownloadInBrowser(info, download);
 
   // Inform interested objects about the new download.
   NotifyModelChanged();
 
   // If this download has been completed before we've received the db handle,
   // post one final message to the history service so that it can be properly
   // in sync with the DownloadItem's completion status, and also inform any
   // observers so that they get more than just the start notification.
   if (download->state() != DownloadItem::IN_PROGRESS) {
     in_progress_.erase(it);
-    UpdateHistoryForDownload(download);
+    download_history_->UpdateEntry(download);
     download->UpdateObservers();
   }
 
   UpdateAppIcon();
 }
 
-// Called when the history service has retrieved the list of downloads that
-// match the search text.
-void DownloadManager::OnSearchComplete(HistoryService::Handle handle,
-                                       std::vector<int64>* results) {
-  HistoryService* hs = profile_->GetHistoryService(Profile::EXPLICIT_ACCESS);
-  Observer* requestor = cancelable_consumer_.GetClientData(hs, handle);
-  if (!requestor)
-    return;
-
-  std::vector<DownloadItem*> searched_downloads;
-  for (std::vector<int64>::iterator it = results->begin();
-       it != results->end(); ++it) {
-    DownloadMap::iterator dit = downloads_.find(*it);
-    if (dit != downloads_.end())
-      searched_downloads.push_back(dit->second);
-  }
-
-  requestor->SetDownloads(searched_downloads);
-}
-
 void DownloadManager::ShowDownloadInBrowser(const DownloadCreateInfo& info,
                                             DownloadItem* download) {
   // The 'contents' may no longer exist if the user closed the tab before we
   // get this start completion event. If it does, tell the origin TabContents
   // to display its download shelf.
   TabContents* contents = tab_util::GetTabContentsByID(info.child_id,
                                                        info.render_view_id);
 
   // If the contents no longer exists, we start the download in the last active
   // browser. This is not ideal but better than fully hiding the download from
@@ skipping 45 matching lines @@
 
 DownloadManager::OtherDownloadManagerObserver::~OtherDownloadManagerObserver() {
   if (observed_download_manager_)
     observed_download_manager_->RemoveObserver(this);
 }
 
 void DownloadManager::OtherDownloadManagerObserver::ModelChanged() {
   observing_download_manager_->NotifyModelChanged();
 }
 
-void DownloadManager::OtherDownloadManagerObserver::SetDownloads(
-    std::vector<DownloadItem*>& downloads) {
-}
-
 void DownloadManager::OtherDownloadManagerObserver::ManagerGoingDown() {
   observed_download_manager_ = NULL;
 }