chrome.experimental.downloads

chrome/browser/download/download_manager.cc

 // Copyright (c) 2011 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 "base/bind.h"
 #include "base/callback.h"
 #include "base/file_util.h"
 #include "base/i18n/case_conversion.h"
 #include "base/logging.h"
 #include "base/path_service.h"
 #include "base/rand_util.h"
 #include "base/stl_util-inl.h"
 #include "base/stringprintf.h"
 #include "base/sys_string_conversions.h"
 #include "base/task.h"
 #include "base/utf_string_conversions.h"
 #include "build/build_config.h"
 #include "chrome/browser/browser_process.h"
 #include "chrome/browser/download/download_create_info.h"
 #include "chrome/browser/download/download_extensions.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_prefs.h"
+#include "chrome/browser/download/download_query.h"
 #include "chrome/browser/download/download_request_handle.h"
 #include "chrome/browser/download/download_safe_browsing_client.h"
 #include "chrome/browser/download/download_status_updater.h"
 #include "chrome/browser/download/download_util.h"
 #include "chrome/browser/extensions/extension_service.h"
 #include "chrome/browser/history/download_history_info.h"
 #include "chrome/browser/platform_util.h"
 #include "chrome/browser/profiles/profile.h"
 #include "chrome/browser/tab_contents/tab_util.h"
 #include "chrome/browser/ui/browser.h"
@@ skipping 41 matching lines @@
 
   if (file_manager_) {
     BrowserThread::PostTask(BrowserThread::FILE, FROM_HERE,
         NewRunnableMethod(file_manager_,
                           &DownloadFileManager::OnDownloadManagerShutdown,
                           make_scoped_refptr(this)));
   }
 
   AssertContainersConsistent();
 
-  // Go through all downloads in downloads_.  Dangerous ones we need to
-  // remove on disk, and in progress ones we need to cancel.
-  for (DownloadSet::iterator it = downloads_.begin(); it != downloads_.end();) {
-    DownloadItem* download = *it;
-
-    // Save iterator from potential erases in this set done by called code.
-    // Iterators after an erasure point are still valid for lists and
-    // associative containers such as sets.
-    it++;
-
+  for (DownloadMap::iterator it = downloads_.begin(); it != downloads_.end();) {
+    DownloadItem* download = it->second;
+    ++it;
     if (download->safety_state() == DownloadItem::DANGEROUS &&
         download->IsPartialDownload()) {
-      // The user hasn't accepted it, so we need to remove it
-      // from the disk.  This may or may not result in it being
-      // removed from the DownloadManager queues and deleted
-      // (specifically, DownloadManager::RemoveDownload only
-      // removes and deletes it if it's known to the history service)
-      // so the only thing we know after calling this function is that
-      // the download was deleted if-and-only-if it was removed
-      // from all queues.
       download->Delete(DownloadItem::DELETE_DUE_TO_BROWSER_SHUTDOWN);
     } else if (download->IsPartialDownload()) {
       download->Cancel(false);
       download_history_->UpdateEntry(download);
     }
   }
-
-  // At this point, all dangerous downloads have had their files removed
-  // and all in progress downloads have been cancelled.  We can now delete
-  // anything left.
-
-  // Copy downloads_ to separate container so as not to set off checks
-  // in DownloadItem destruction.
-  DownloadSet downloads_to_delete;
-  downloads_to_delete.swap(downloads_);
-
-  in_progress_.clear();
-  active_downloads_.clear();
-  history_downloads_.clear();
-#if !defined(NDEBUG)
-  save_page_as_downloads_.clear();
-#endif
-  STLDeleteElements(&downloads_to_delete);
+  STLValueDeleter<DownloadMap> delete_items(&downloads_);
 
   file_manager_ = NULL;
 
   // 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();
   download_prefs_.reset();
-
-  shutdown_needed_ = false;
-}
-
-void DownloadManager::GetTemporaryDownloads(
-    const FilePath& dir_path, std::vector<DownloadItem*>* result) {
-  DCHECK(result);
-
-  for (DownloadMap::iterator it = history_downloads_.begin();
-       it != history_downloads_.end(); ++it) {
-    if (it->second->is_temporary() &&
-        it->second->full_path().DirName() == dir_path)
-      result->push_back(it->second);
-  }
-}
-
-void DownloadManager::GetAllDownloads(
-    const FilePath& dir_path, std::vector<DownloadItem*>* result) {
-  DCHECK(result);
-
-  for (DownloadMap::iterator it = history_downloads_.begin();
-       it != history_downloads_.end(); ++it) {
-    if (!it->second->is_temporary() &&
-        (dir_path.empty() || it->second->full_path().DirName() == dir_path))
-      result->push_back(it->second);
-  }
-}
-
-void DownloadManager::GetCurrentDownloads(
-    const FilePath& dir_path, std::vector<DownloadItem*>* result) {
-  DCHECK(result);
-
-  for (DownloadMap::iterator it = history_downloads_.begin();
-       it != history_downloads_.end(); ++it) {
-    DownloadItem* item =it->second;
-    // Skip temporary items.
-    if (item->is_temporary())
-      continue;
-    // Skip items that have all their data, and are OK to save.
-    if (!item->IsPartialDownload() &&
-        (item->safety_state() != DownloadItem::DANGEROUS))
-      continue;
-    // Skip items that don't match |dir_path|.
-    // If |dir_path| is empty, all remaining items match.
-    if (!dir_path.empty() && (it->second->full_path().DirName() != dir_path))
-      continue;
-
-    result->push_back(item);
-  }
-
-  // If we have a parent profile, let it add its downloads to the results.
-  Profile* original_profile = profile_->GetOriginalProfile();
-  if (original_profile != profile_)
-    original_profile->GetDownloadManager()->GetCurrentDownloads(dir_path,
-                                                                result);
-}
-
-void DownloadManager::SearchDownloads(const string16& query,
-                                      std::vector<DownloadItem*>* result) {
-  DCHECK(result);
-
-  string16 query_lower(base::i18n::ToLower(query));
-
-  for (DownloadMap::iterator it = history_downloads_.begin();
-       it != history_downloads_.end(); ++it) {
-    DownloadItem* download_item = it->second;
-
-    if (download_item->is_temporary() || download_item->is_extension_install())
-      continue;
-
-    // Display Incognito downloads only in Incognito window, and vice versa.
-    // The Incognito Downloads page will get the list of non-Incognito downloads
-    // from its parent profile.
-    if (profile_->IsOffTheRecord() != download_item->is_otr())
-      continue;
-
-    if (download_item->MatchesQuery(query_lower))
-      result->push_back(download_item);
-  }
-
-  // If we have a parent profile, let it add its downloads to the results.
-  Profile* original_profile = profile_->GetOriginalProfile();
-  if (original_profile != profile_)
-    original_profile->GetDownloadManager()->SearchDownloads(query, result);
 }
 
 // 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;
   download_history_.reset(new DownloadHistory(profile));
@@ skipping 22 matching lines @@
 // 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 'history_downloads_' or inform our
 // observers at this point. OnCreateDownloadEntryComplete() handles that
 // finalization of the the download creation as a callback from the
 // history thread.
 void DownloadManager::StartDownload(int32 download_id) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 
   DownloadItem* download = GetActiveDownloadItem(download_id);
+  DVLOG(1) << __PRETTY_FUNCTION__ << " " << download_id << " " << download;
   if (!download)
     return;
 
 #if defined(ENABLE_SAFE_BROWSING)
   // Create a client to verify download URL with safebrowsing.
   // It deletes itself after the callback.
   scoped_refptr<DownloadSBClient> sb_client = new DownloadSBClient(
       download_id, download->url_chain(), download->referrer_url());
   sb_client->CheckDownloadUrl(
       NewCallback(this, &DownloadManager::CheckDownloadUrlDone));
 #else
   CheckDownloadUrlDone(download_id, false);
 #endif
 }
 
 void DownloadManager::CheckForHistoryFilesRemoval() {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
-  for (DownloadMap::iterator it = history_downloads_.begin();
-       it != history_downloads_.end(); ++it) {
+  DVLOG(1) << __PRETTY_FUNCTION__;
+  for (DownloadMap::iterator it = downloads_.begin();
+       it != downloads_.end(); ++it) {
     CheckForFileRemoval(it->second);
   }
 }
 
 void DownloadManager::CheckForFileRemoval(DownloadItem* download_item) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   if (download_item->IsComplete() &&
       !download_item->file_externally_removed()) {
     BrowserThread::PostTask(
         BrowserThread::FILE, FROM_HERE,
         NewRunnableMethod(this,
                           &DownloadManager::CheckForFileRemovalOnFileThread,
-                          download_item->db_handle(),
+                          download_item->id(),
                           download_item->GetTargetFilePath()));
   }
 }
 
 void DownloadManager::CheckForFileRemovalOnFileThread(
-    int64 db_handle, const FilePath& path) {
+    int64 id, const FilePath& path) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::FILE));
   if (!file_util::PathExists(path)) {
+    DVLOG(1) << __PRETTY_FUNCTION__ << " " << id;
     BrowserThread::PostTask(
         BrowserThread::UI, FROM_HERE,
         NewRunnableMethod(this,
                           &DownloadManager::OnFileRemovalDetected,
-                          db_handle));
+                          id));
   }
 }
 
-void DownloadManager::OnFileRemovalDetected(int64 db_handle) {
+void DownloadManager::OnFileRemovalDetected(int64 id) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
-  DownloadMap::iterator it = history_downloads_.find(db_handle);
-  if (it != history_downloads_.end()) {
+  DVLOG(1) << __PRETTY_FUNCTION__ << " " << id;
+  DownloadMap::iterator it = downloads_.find(id);
+  if (it != downloads_.end()) {
+    DVLOG(1) << __PRETTY_FUNCTION__ << " " << id;
     DownloadItem* download_item = it->second;
     download_item->OnDownloadedFileRemoved();
   }
 }
 
 void DownloadManager::CheckDownloadUrlDone(int32 download_id,
                                            bool is_dangerous_url) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 
   DownloadItem* download = GetActiveDownloadItem(download_id);
+  DVLOG(1) << __PRETTY_FUNCTION__ << " " << download_id << " "
+           << is_dangerous_url << " " << download;
   if (!download)
     return;
 
   if (is_dangerous_url)
     download->MarkUrlDangerous();
 
   download_history_->CheckVisitedReferrerBefore(download_id,
       download->referrer_url(),
       NewCallback(this, &DownloadManager::CheckVisitedReferrerBeforeDone));
 }
 
 void DownloadManager::CheckVisitedReferrerBeforeDone(
     int32 download_id,
     bool visited_referrer_before) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 
   DownloadItem* download = GetActiveDownloadItem(download_id);
+  DVLOG(1) << __PRETTY_FUNCTION__ << " " << download_id << " " << download;
   if (!download)
     return;
 
   // Check whether this download is for an extension install or not.
   // Allow extensions to be explicitly saved.
   DownloadStateInfo state = download->state_info();
   if (!state.prompt_user_for_save_location) {
     if (UserScript::IsURLUserScript(download->GetURL(),
         download->mime_type()) ||
         (download->mime_type() == Extension::kMimeType)) {
@@ skipping 56 matching lines @@
           &DownloadManager::CheckIfSuggestedPathExists,
           download->id(),
           state,
           download_prefs()->download_path()));
 }
 
 void DownloadManager::CheckIfSuggestedPathExists(int32 download_id,
                                                  DownloadStateInfo state,
                                                  const FilePath& default_path) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::FILE));
+  DVLOG(1) << __PRETTY_FUNCTION__ << " " << download_id;
 
   // Make sure the default download directory exists.
   // TODO(phajdan.jr): only create the directory when we're sure the user
   // is going to save there and not to another directory of his choice.
   file_util::CreateDirectory(default_path);
 
   // Check writability of the suggested path. If we can't write to it, default
   // to the user's "My Documents" directory. We'll prompt them in this case.
   FilePath dir = state.suggested_path.DirName();
   FilePath filename = state.suggested_path.BaseName();
@@ skipping 70 matching lines @@
                         &DownloadManager::OnPathExistenceAvailable,
                         download_id,
                         state));
 }
 
 void DownloadManager::OnPathExistenceAvailable(
     int32 download_id, const DownloadStateInfo& new_state) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 
   DownloadItem* download = GetActiveDownloadItem(download_id);
+  DVLOG(1) << __PRETTY_FUNCTION__ << " " << download << " " << download_id;
   if (!download)
     return;
 
   VLOG(20) << __FUNCTION__ << "()"
            << " download = " << download->DebugString(true);
 
   download->SetFileCheckResults(new_state);
 
   FilePath suggested_path = download->suggested_path();
 
@@ skipping 30 matching lines @@
     // No prompting for download, just continue with the suggested name.
     ContinueDownloadWithPath(download, suggested_path);
   }
 }
 
 void DownloadManager::CreateDownloadItem(DownloadCreateInfo* info) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 
   DownloadItem* download = new DownloadItem(this, *info,
                                             profile_->IsOffTheRecord());
+  DVLOG(1) << __PRETTY_FUNCTION__ << " " << info->download_id << " "
+           << download;
   int32 download_id = info->download_id;
-  DCHECK(!ContainsKey(in_progress_, download_id));
-  DCHECK(!ContainsKey(active_downloads_, download_id));
-  downloads_.insert(download);
-  active_downloads_[download_id] = download;
+  DCHECK(!ContainsKey(downloads_, download_id));
+  downloads_[download_id] = download;
 }
 
 void DownloadManager::ContinueDownloadWithPath(DownloadItem* download,
                                                const FilePath& chosen_file) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   DCHECK(download);
 
   int32 download_id = download->id();
-
-  // NOTE(ahendrickson) Eventually |active_downloads_| will replace
-  // |in_progress_|, but we don't want to change the semantics yet.
-  DCHECK(!ContainsKey(in_progress_, download_id));
-  DCHECK(ContainsKey(downloads_, download));
-  DCHECK(ContainsKey(active_downloads_, download_id));
+  DVLOG(1) << __PRETTY_FUNCTION__ << " " << download_id << " " << download
+           << " " << chosen_file.value();
 
   // Make sure the initial file name is set only once.
   DCHECK(download->full_path().empty());
   download->OnPathDetermined(chosen_file);
   download->UpdateTarget();
 
   VLOG(20) << __FUNCTION__ << "()"
            << " download = " << download->DebugString(true);
 
-  in_progress_[download_id] = download;
-  UpdateAppIcon();  // Reflect entry into in_progress_.
+  UpdateAppIcon();  // Reflect entry into .
 
   // Rename to intermediate name.
   FilePath download_path;
   if (download->IsDangerous()) {
     // The download is not safe.  We can now rename the file to its
     // tentative name using RenameInProgressDownloadFile.
     // NOTE: The |Rename| below will be a no-op for dangerous files, as we're
     // renaming it to the same name.
     download_path = download->full_path();
   } else {
@@ skipping 12 matching lines @@
           download->id(), download_path));
 
   download->Rename(download_path);
 
   download_history_->AddEntry(download,
       NewCallback(this, &DownloadManager::OnCreateDownloadEntryComplete));
 }
 
 void DownloadManager::UpdateDownload(int32 download_id, int64 size) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
-  DownloadMap::iterator it = active_downloads_.find(download_id);
-  if (it != active_downloads_.end()) {
+  DownloadMap::iterator it = downloads_.find(download_id);
+  if (it != downloads_.end()) {
     DownloadItem* download = it->second;
     if (download->IsInProgress()) {
       download->Update(size);
       UpdateAppIcon();  // Reflect size updates.
       download_history_->UpdateEntry(download);
     }
   }
 }
 
 void DownloadManager::OnResponseCompleted(int32 download_id,
@@ skipping 11 matching lines @@
   if (os_error == 0) {
     OnAllDataSaved(download_id, size, hash);
   } else {
     OnDownloadError(download_id, size, os_error);
   }
 }
 
 void DownloadManager::OnAllDataSaved(int32 download_id,
                                      int64 size,
                                      const std::string& hash) {
-  VLOG(20) << __FUNCTION__ << "()" << " download_id = " << download_id
+  DVLOG(1) << __FUNCTION__ << "()" << " download_id = " << download_id
            << " size = " << size;
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 
-  // If it's not in active_downloads_, that means it was cancelled; just
-  // ignore the notification.
-  if (active_downloads_.count(download_id) == 0)
+  DownloadItem* download = downloads_[download_id];
+  DVLOG(1) << __PRETTY_FUNCTION__ << " " << download_id << " " << size << " "
+           << hash << " " << download;
+  if (!download) {
     return;
-
-  DownloadItem* download = active_downloads_[download_id];
+  }
   download->OnAllDataSaved(size);
 
   // When hash is not available, it means either it is not calculated
   // or there is error while it is calculated. We will skip the download hash
   // check in that case.
   if (!hash.empty()) {
 #if defined(ENABLE_SAFE_BROWSING)
     scoped_refptr<DownloadSBClient> sb_client =
         new DownloadSBClient(download_id,
                              download->url_chain(),
                              download->referrer_url());
     sb_client->CheckDownloadHash(
         hash, NewCallback(this, &DownloadManager::CheckDownloadHashDone));
 #else
     CheckDownloadHashDone(download_id, false);
 #endif
   }
   MaybeCompleteDownload(download);
 }
 
 // TODO(lzheng): This function currently works as a callback place holder.
 // Once we decide the hash check is reliable, we could move the
 // MaybeCompleteDownload in OnAllDataSaved to this function.
 void DownloadManager::CheckDownloadHashDone(int32 download_id,
                                             bool is_dangerous_hash) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   DVLOG(1) << "CheckDownloadHashDone, download_id: " << download_id
            << " is dangerous_hash: " << is_dangerous_hash;
-
-  // If it's not in active_downloads_, that means it was cancelled or
-  // the download already finished.
-  if (active_downloads_.count(download_id) == 0)
-    return;
-
-  DVLOG(1) << "CheckDownloadHashDone, url: "
-           << active_downloads_[download_id]->GetURL().spec();
 }
 
 void DownloadManager::AssertQueueStateConsistent(DownloadItem* download) {
-  // TODO(rdsmith): Change to DCHECK after http://crbug.com/85408 resolved.
-  if (download->state() == DownloadItem::REMOVING) {
-    CHECK(!ContainsKey(downloads_, download));
-    CHECK(!ContainsKey(active_downloads_, download->id()));
-    CHECK(!ContainsKey(in_progress_, download->id()));
-    CHECK(!ContainsKey(history_downloads_, download->db_handle()));
-    return;
-  }
-
-  // Should be in downloads_ if we're not REMOVING.
-  CHECK(ContainsKey(downloads_, download));
-
-  // Check history_downloads_ consistency.
-  if (download->db_handle() != DownloadHistory::kUninitializedHandle) {
-    CHECK(ContainsKey(history_downloads_, download->db_handle()));
-  } else {
-    // TODO(rdsmith): Somewhat painful; make sure to disable in
-    // release builds after resolution of http://crbug.com/85408.
-    for (DownloadMap::iterator it = history_downloads_.begin();
-         it != history_downloads_.end(); ++it) {
-      CHECK(it->second != download);
-    }
-  }
-
-  CHECK(ContainsKey(active_downloads_, download->id()) ==
-        (download->state() == DownloadItem::IN_PROGRESS));
-  CHECK(ContainsKey(in_progress_, download->id()) ==
-        (download->state() == DownloadItem::IN_PROGRESS));
+  DVLOG(1) << __PRETTY_FUNCTION__ << " " << download;
 }
 
 bool DownloadManager::IsDownloadReadyForCompletion(DownloadItem* download) {
+  DVLOG(1) << __PRETTY_FUNCTION__ << " p=" << download << " id="
+           << download->id() << " data=" << download->all_data_saved()
+           << " safety=" << download->safety_state() << " path="
+           << download->full_path().value();
+  return download->all_data_saved() &&
+         download->safety_state() != DownloadItem::DANGEROUS &&
+         !download->full_path().value().empty();
   // If we don't have all the data, the download is not ready for
   // completion.
   if (!download->all_data_saved())
     return false;
 
   // If the download is dangerous, but not yet validated, it's not ready for
   // completion.
   if (download->safety_state() == DownloadItem::DANGEROUS)
     return false;
 
-  // If the download isn't active (e.g. has been cancelled) it's not
-  // ready for completion.
-  if (active_downloads_.count(download->id()) == 0)
-    return false;
-
-  // If the download hasn't been inserted into the history system
-  // (which occurs strictly after file name determination, intermediate
-  // file rename, and UI display) then it's not ready for completion.
-  if (download->db_handle() == DownloadHistory::kUninitializedHandle)
-    return false;
-
   return true;
 }
 
 void DownloadManager::MaybeCompleteDownload(DownloadItem* download) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
-  VLOG(20) << __FUNCTION__ << "()" << " download = "
-           << download->DebugString(false);
+  DVLOG(1) << __FUNCTION__ << " " << download->DebugString(true);
 
   if (!IsDownloadReadyForCompletion(download))
     return;
 
   // TODO(rdsmith): DCHECK that we only pass through this point
   // once per download.  The natural way to do this is by a state
   // transition on the DownloadItem.
 
   // Confirm we're in the proper set of states to be here;
-  // in in_progress_, have all data, have a history handle, (validated or safe).
+  // in , have all data, have a history handle, (validated or safe).
   DCHECK_NE(DownloadItem::DANGEROUS, download->safety_state());
-  DCHECK_EQ(1u, in_progress_.count(download->id()));
   DCHECK(download->all_data_saved());
-  DCHECK(download->db_handle() != DownloadHistory::kUninitializedHandle);
-  DCHECK_EQ(1u, history_downloads_.count(download->db_handle()));
+  DCHECK(!download->full_path().value().empty());
 
-  VLOG(20) << __FUNCTION__ << "()" << " executing: download = "
-           << download->DebugString(false);
+  DVLOG(1) << __FUNCTION__ << " " << download->DebugString(true);
 
-  // Remove the id from in_progress
-  in_progress_.erase(download->id());
-  UpdateAppIcon();  // Reflect removal from in_progress_.
+  UpdateAppIcon();  // Reflect removal from .
 
   download_history_->UpdateEntry(download);
 
   // Finish the download.
   download->OnDownloadCompleting(file_manager_);
+  DVLOG(1) << __FUNCTION__ << " " << download->DebugString(true);
 }
 
 void DownloadManager::DownloadCompleted(int32 download_id) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   DownloadItem* download = GetDownloadItem(download_id);
   DCHECK(download);
   download_history_->UpdateEntry(download);
-  active_downloads_.erase(download_id);
 }
 
 void DownloadManager::OnDownloadRenamedToFinalName(int download_id,
                                                    const FilePath& full_path,
                                                    int uniquifier) {
-  VLOG(20) << __FUNCTION__ << "()" << " download_id = " << download_id
+  DVLOG(1) << __FUNCTION__ << "()" << " download_id = " << download_id
            << " full_path = \"" << full_path.value() << "\""
            << " uniquifier = " << uniquifier;
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 
   DownloadItem* item = GetDownloadItem(download_id);
   if (!item)
     return;
 
   if (item->safety_state() == DownloadItem::SAFE) {
     DCHECK_EQ(0, uniquifier) << "We should not uniquify SAFE downloads twice";
   }
 
   BrowserThread::PostTask(
       BrowserThread::FILE, FROM_HERE,
       NewRunnableMethod(
           file_manager_, &DownloadFileManager::CompleteDownload, download_id));
 
   if (uniquifier)
     item->set_path_uniquifier(uniquifier);
 
   item->OnDownloadRenamedToFinalName(full_path);
   download_history_->UpdateDownloadPath(item, full_path);
+  UpdateAppIcon();
 }
 
 void DownloadManager::DownloadCancelled(int32 download_id) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
-  DownloadMap::iterator it = in_progress_.find(download_id);
-  if (it == in_progress_.end())
-    return;
-  DownloadItem* download = it->second;
-
-  VLOG(20) << __FUNCTION__ << "()" << " download_id = " << download_id
-           << " download = " << download->DebugString(true);
-
-  // 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() != DownloadHistory::kUninitializedHandle) {
-    in_progress_.erase(it);
-    active_downloads_.erase(download_id);
-    UpdateAppIcon();  // Reflect removal from in_progress_.
-    download_history_->UpdateEntry(download);
-  }
-
+  DownloadItem* download = downloads_[download_id];
+  DVLOG(1) << __PRETTY_FUNCTION__ << " " << download_id << " " << download
+           << " " << (download ? download->DebugString(true) : "");
+  DCHECK(download);
+  UpdateAppIcon();  // Reflect removal from .
+  download_history_->UpdateEntry(download);
   DownloadCancelledInternal(download_id, download->request_handle());
 }
 
 void DownloadManager::DownloadCancelledInternal(
     int download_id, const DownloadRequestHandle& request_handle) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   request_handle.CancelRequest();
 
   BrowserThread::PostTask(
       BrowserThread::FILE, FROM_HERE,
       NewRunnableMethod(
           file_manager_, &DownloadFileManager::CancelDownload, download_id));
 }
 
 void DownloadManager::OnDownloadError(int32 download_id,
                                       int64 size,
                                       int os_error) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
-  DownloadMap::iterator it = active_downloads_.find(download_id);
-  // A cancel at the right time could remove the download from the
-  // |active_downloads_| map before we get here.
-  if (it == active_downloads_.end())
-    return;
-
-  DownloadItem* download = it->second;
-
-  VLOG(20) << __FUNCTION__ << "()" << " Error " << os_error
-           << " at offset " << download->received_bytes()
-           << " for download = " << download->DebugString(true);
-
+  DownloadItem* download = downloads_[download_id];
+  DVLOG(1) << __PRETTY_FUNCTION__ << " " << download_id << " " << download
+    << " " << (download ? download->DebugString(true) : "");
+  DCHECK(download);
   download->Interrupted(size, os_error);
-
-  // TODO(ahendrickson) - Remove this when we add resuming of interrupted
-  // downloads, as we will keep the download item around in that case.
-  //
-  // 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() != DownloadHistory::kUninitializedHandle) {
-    in_progress_.erase(download_id);
-    active_downloads_.erase(download_id);
-    UpdateAppIcon();  // Reflect removal from in_progress_.
-    download_history_->UpdateEntry(download);
-  }
-
+  UpdateAppIcon();  // Reflect removal from .
+  download_history_->UpdateEntry(download);
   BrowserThread::PostTask(
       BrowserThread::FILE, FROM_HERE,
       NewRunnableMethod(
           file_manager_, &DownloadFileManager::CancelDownload, download_id));
 }
 
 void DownloadManager::UpdateAppIcon() {
   if (status_updater_)
     status_updater_->Update();
 }
 
-void DownloadManager::RemoveDownload(int64 download_handle) {
-  DownloadMap::iterator it = history_downloads_.find(download_handle);
-  if (it == history_downloads_.end())
+void DownloadManager::RemoveDownload(int64 id) {
+  DownloadMap::iterator it = downloads_.find(id);
+  scoped_ptr<DownloadItem> download(it->second);
+  DVLOG(1) << __PRETTY_FUNCTION__ << " " << id << " " << download.get();
+  if (download.get() == NULL) {
     return;
+  }
+  download_history_->RemoveEntry(download.get());
+  downloads_.erase(it);
+  NotifyModelChanged();
+}
 
-  // Make history update.
-  DownloadItem* download = it->second;
-  download_history_->RemoveEntry(download);
+void DownloadManager::GetTemporaryDownloads(
+    const FilePath& dir_path, ItemVector* result) {
+  DCHECK(result);
+  Search(DOWNLOAD_QUERY_FILTER(item.is_temporary()).
+         filenameRegex("^" + dir_path.value() + "/.*"),
+         result);
+  DVLOG(1) << __PRETTY_FUNCTION__ << " " << result->size();
+}
 
-  // Remove from our tables and delete.
-  history_downloads_.erase(it);
-  int downloads_count = downloads_.erase(download);
-  DCHECK_EQ(1, downloads_count);
+void DownloadManager::GetAllDownloads(
+    const FilePath& dir_path, ItemVector* result) {
+  DCHECK(result);
+  Search(DOWNLOAD_QUERY_FILTER(!item.is_temporary()).
+         filenameRegex("^" + dir_path.value() + "/.*"),
+         result);
+}
 
-  // Tell observers to refresh their views.
-  NotifyModelChanged();
+void DownloadManager::GetCurrentDownloads(
+    const FilePath& dir_path, ItemVector* result) {
+  DCHECK(result);
+  Search(DOWNLOAD_QUERY_FILTER(
+      !item.is_temporary() &&
+      (item.IsPartialDownload() ||
+       (item.safety_state() == DownloadItem::DANGEROUS))).
+      filenameRegex("^" + dir_path.value() + "/.*"),
+      result);
+}
 
-  delete download;
+bool DownloadManager::Search(const download_util::DownloadQuery& query,
+                             ItemVector* items,
+                             bool merge_parent_manager,
+                             std::string* error_msg,
+                             ListValue* json_results) const {
+  ItemVector default_items;
+  if (items == NULL) {
+    items = &default_items;
+  }
+  MergeItems(merge_parent_manager, items);
+  return query.Search(items, error_msg, json_results);
+}
+
+void DownloadManager::MergeItems(
+    bool merge_parent_manager, ItemVector* items) const {
+  for (DownloadMap::const_iterator it = downloads_.begin();
+       it != downloads_.end(); ++it) items->push_back(it->second);
+  if (!merge_parent_manager ||
+      (profile_ == NULL)) return;
+  Profile* original_profile = profile_->GetOriginalProfile();
+  if ((profile_ != NULL) &&
+      (original_profile != NULL) &&
+      (original_profile != profile_) &&
+      (original_profile->GetDownloadManager() != NULL)) {
+    original_profile->GetDownloadManager()->MergeItems(
+        merge_parent_manager, items);
+  }
+}
+
+void DownloadManager::SearchDownloads(const string16& query,
+                                      ItemVector* result) {
+  DCHECK(result);
+  bool otr = false;
+  if (profile_ != NULL) otr = profile_->IsOffTheRecord();
+  Search(DOWNLOAD_QUERY_FILTER1(otr,
+      !item.is_temporary() &&
+      !item.is_extension_install() &&
+      (item.is_otr() == otr)).
+      query(UTF16ToASCII(query)),
+      result);
 }
 
 int DownloadManager::RemoveDownloadsBetween(const base::Time remove_begin,
                                             const base::Time remove_end) {
   download_history_->RemoveEntriesBetween(remove_begin, remove_end);
-
-  // All downloads visible to the user will be in the history,
-  // so scan that map.
-  DownloadMap::iterator it = history_downloads_.begin();
-  std::vector<DownloadItem*> pending_deletes;
-  while (it != history_downloads_.end()) {
-    DownloadItem* download = it->second;
-    if (download->start_time() >= remove_begin &&
-        (remove_end.is_null() || download->start_time() < remove_end) &&
-        (download->IsComplete() ||
-         download->IsCancelled() ||
-         download->IsInterrupted())) {
-      AssertQueueStateConsistent(download);
-
-      // Remove from the map and move to the next in the list.
-      history_downloads_.erase(it++);
-
-      // Also remove it from any completed dangerous downloads.
-      pending_deletes.push_back(download);
-
-      continue;
-    }
-
-    ++it;
+  ItemVector pending_deletes;
+  STLElementDeleter<ItemVector> delete_pending_deletes(&pending_deletes);
+  const base::Time unix_epoch = base::Time::UnixEpoch();
+  Search(DOWNLOAD_QUERY_FILTER(
+      item.IsComplete() ||
+      item.IsCancelled() ||
+      item.IsInterrupted()).
+      startedAfter((remove_begin - unix_epoch).InMilliseconds()).
+      startedBefore((remove_end - unix_epoch).InMilliseconds()),
+      &pending_deletes);
+  if (pending_deletes.empty()) return 0;
+  for (ItemVector::const_iterator iter = pending_deletes.begin();
+       iter != pending_deletes.end(); ++iter) {
+    downloads_.erase(downloads_.find((*iter)->id()));
   }
-
-  // If we aren't deleting anything, we're done.
-  if (pending_deletes.empty())
-    return 0;
-
-  // Remove the chosen downloads from the main owning container.
-  for (std::vector<DownloadItem*>::iterator it = pending_deletes.begin();
-       it != pending_deletes.end(); it++) {
-    downloads_.erase(*it);
-  }
-
-  // Tell observers to refresh their views.
   NotifyModelChanged();
-
-  // Delete the download items themselves.
   int num_deleted = static_cast<int>(pending_deletes.size());
-
-  STLDeleteContainerPointers(pending_deletes.begin(), pending_deletes.end());
-  pending_deletes.clear();
-
   return num_deleted;
 }
 
 int DownloadManager::RemoveDownloads(const base::Time remove_begin) {
   return RemoveDownloadsBetween(remove_begin, base::Time());
 }
 
 int DownloadManager::RemoveAllDownloads() {
   if (this != profile_->GetOriginalProfile()->GetDownloadManager()) {
     // This is an incognito downloader. Clear All should clear main download
     // manager as well.
     profile_->GetOriginalProfile()->GetDownloadManager()->RemoveAllDownloads();
   }
   // The null times make the date range unbounded.
   return RemoveDownloadsBetween(base::Time(), base::Time());
 }
 
 void DownloadManager::SavePageAsDownloadStarted(DownloadItem* download) {
 #if !defined(NDEBUG)
   save_page_as_downloads_.insert(download);
 #endif
-  downloads_.insert(download);
+  downloads_[download->id()] = download;
   // Add to history and notify observers.
-  AddDownloadItemToHistory(download, DownloadHistory::kUninitializedHandle);
+  AddDownloadItemToHistory(download);
   NotifyModelChanged();
 }
 
 // Initiate a download of a specific URL. We send the request to the
 // ResourceDispatcherHost, and let it send us responses like a regular
 // download.
 void DownloadManager::DownloadUrl(const GURL& url,
                                   const GURL& referrer,
                                   const std::string& referrer_charset,
                                   TabContents* tab_contents) {
@@ skipping 36 matching lines @@
   if (extension.empty())
     return false;
   if (Extension::IsExtension(path))
     return false;
   DCHECK(extension[0] == FilePath::kExtensionSeparator);
   extension.erase(0, 1);
   return download_prefs_->IsAutoOpenEnabledForExtension(extension);
 }
 
 bool DownloadManager::IsDownloadProgressKnown() {
-  for (DownloadMap::iterator i = in_progress_.begin();
-       i != in_progress_.end(); ++i) {
-    if (i->second->total_bytes() <= 0)
+  for (DownloadMap::iterator i = downloads_.begin();
+       i != downloads_.end(); ++i) {
+    if (i->second->total_bytes() <= 0) {
       return false;
+    }
   }
-
   return true;
 }
 
-int64 DownloadManager::GetInProgressDownloadCount() {
-  return in_progress_.size();
+int64 DownloadManager::GetInProgressDownloadCount() const {
+  ItemVector in_progress;
+  Search(download_util::DownloadQuery().state_enum(DownloadItem::IN_PROGRESS),
+         &in_progress);
+  DVLOG(1) << __PRETTY_FUNCTION__ << " " << in_progress.size();
+  return in_progress.size();
 }
 
 int64 DownloadManager::GetReceivedDownloadBytes() {
   DCHECK(IsDownloadProgressKnown());
   int64 received_bytes = 0;
-  for (DownloadMap::iterator i = in_progress_.begin();
-       i != in_progress_.end(); ++i) {
+  for (DownloadMap::iterator i = downloads_.begin();
+       i != downloads_.end(); ++i) {
     received_bytes += i->second->received_bytes();
   }
+  DVLOG(1) << __PRETTY_FUNCTION__ << " " << received_bytes;
   return received_bytes;
 }
 
 int64 DownloadManager::GetTotalDownloadBytes() {
   DCHECK(IsDownloadProgressKnown());
   int64 total_bytes = 0;
-  for (DownloadMap::iterator i = in_progress_.begin();
-       i != in_progress_.end(); ++i) {
+  for (DownloadMap::iterator i = downloads_.begin();
+       i != downloads_.end(); ++i) {
     total_bytes += i->second->total_bytes();
   }
+  DVLOG(1) << __PRETTY_FUNCTION__ << " " << total_bytes;
   return total_bytes;
 }
 
 void DownloadManager::FileSelected(const FilePath& path,
                                    int index, void* params) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 
   int32* id_ptr = reinterpret_cast<int32*>(params);
   DCHECK(id_ptr != NULL);
   int32 download_id = *id_ptr;
@@ skipping 66 matching lines @@
 
   MaybeCompleteDownload(download);
 }
 
 // Operations posted to us from the history service ----------------------------
 
 // The history service has retrieved all download entries. 'entries' contains
 // 'DownloadHistoryInfo's in sorted order (by ascending start_time).
 void DownloadManager::OnQueryDownloadEntriesComplete(
     std::vector<DownloadHistoryInfo>* entries) {
-  for (size_t i = 0; i < entries->size(); ++i) {
-    DownloadItem* download = new DownloadItem(this, entries->at(i));
-    DCHECK(!ContainsKey(history_downloads_, download->db_handle()));
-    downloads_.insert(download);
-    history_downloads_[download->db_handle()] = download;
-    VLOG(20) << __FUNCTION__ << "()" << i << ">"
-             << " download = " << download->DebugString(true);
+  for (std::vector<DownloadHistoryInfo>::iterator it = entries->begin();
+       it != entries->end(); ++it) {
+    DownloadItem* download = new DownloadItem(this, *it);
+    DVLOG(2) << __PRETTY_FUNCTION__ << " " << download->id() << " " << download;
+    DCHECK(!ContainsKey(downloads_, download->id()));
+    downloads_[download->id()] = download;
   }
   NotifyModelChanged();
   CheckForHistoryFilesRemoval();
 }
 
-void DownloadManager::AddDownloadItemToHistory(DownloadItem* download,
-                                               int64 db_handle) {
+void DownloadManager::AddDownloadItemToHistory(DownloadItem* download) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
-
-  // 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 == DownloadHistory::kUninitializedHandle)
-    db_handle = download_history_->GetNextFakeDbHandle();
-
-  // TODO(rdsmith): Convert to DCHECK() when http://crbug.com/84508
-  // is fixed.
-  CHECK_NE(DownloadHistory::kUninitializedHandle, db_handle);
-
-  DCHECK(download->db_handle() == DownloadHistory::kUninitializedHandle);
-  download->set_db_handle(db_handle);
-
-  DCHECK(!ContainsKey(history_downloads_, download->db_handle()));
-  history_downloads_[download->db_handle()] = download;
 }
 
 // Once the new DownloadItem's creation info has been committed to the history
 // service, we associate the DownloadItem with the db handle, update our
 // 'history_downloads_' map and inform observers.
-void DownloadManager::OnCreateDownloadEntryComplete(int32 download_id,
-                                                    int64 db_handle) {
+void DownloadManager::OnCreateDownloadEntryComplete(
+    int32 download_id) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   DownloadItem* download = GetActiveDownloadItem(download_id);
-  if (!download)
-    return;
+  DVLOG(1) << __PRETTY_FUNCTION__ << " " << download_id << " " << download;
+  if (download == NULL) return;
+  download->SetIsInHistory(true);
+  VLOG(20) << __FUNCTION__ << download->DebugString(true);
 
-  VLOG(20) << __FUNCTION__ << "()" << " db_handle = " << db_handle
-           << " download_id = " << download_id
-           << " download = " << download->DebugString(true);
+  AddDownloadItemToHistory(download);
 
-  AddDownloadItemToHistory(download, db_handle);
+  DVLOG(1) << __PRETTY_FUNCTION__ << " " << download_id << " " << download;
 
   // Show in the appropriate browser UI.
   // This includes buttons to save or cancel, for a dangerous download.
   ShowDownloadInBrowser(download);
 
   // Inform interested objects about the new download.
   NotifyModelChanged();
 
   // If the download is still in progress, try to complete it.
   //
   // Otherwise, download has been cancelled or interrupted before we've
   // received the DB handle.  We 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->IsInProgress()) {
     MaybeCompleteDownload(download);
   } else {
-    DCHECK(download->IsCancelled())
-        << " download = " << download->DebugString(true);
-    in_progress_.erase(download_id);
-    active_downloads_.erase(download_id);
     download_history_->UpdateEntry(download);
     download->UpdateObservers();
   }
 }
 
 void DownloadManager::ShowDownloadInBrowser(DownloadItem* download) {
+  DVLOG(1) << __PRETTY_FUNCTION__ << " " << download << " " << download->id();
+
   // 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.
   DownloadRequestHandle request_handle = download->request_handle();
   TabContents* contents = request_handle.GetTabContents();
   TabContentsWrapper* wrapper = NULL;
   if (contents)
       wrapper = TabContentsWrapper::GetCurrentWrapperForContents(contents);
 
   // If the contents no longer exists, we start the download in the last active
@@ skipping 14 matching lines @@
 // Clears the last download path, used to initialize "save as" dialogs.
 void DownloadManager::ClearLastDownloadPath() {
   last_download_path_ = FilePath();
 }
 
 void DownloadManager::NotifyModelChanged() {
   FOR_EACH_OBSERVER(Observer, observers_, ModelChanged());
 }
 
 DownloadItem* DownloadManager::GetDownloadItem(int download_id) {
-  // The |history_downloads_| map is indexed by the download's db_handle,
-  // not its id, so we have to iterate.
-  for (DownloadMap::iterator it = history_downloads_.begin();
-       it != history_downloads_.end(); ++it) {
-    DownloadItem* item = it->second;
-    if (item->id() == download_id)
-      return item;
-  }
-  return NULL;
+  DownloadItem* download = downloads_[download_id];
+  DVLOG(1) << __PRETTY_FUNCTION__ << " " << download_id << " " << download;
+  return download;
 }
 
 DownloadItem* DownloadManager::GetActiveDownloadItem(int download_id) {
-  DCHECK(ContainsKey(active_downloads_, download_id));
-  DownloadItem* download = active_downloads_[download_id];
-  DCHECK(download != NULL);
-  return download;
+  return GetDownloadItem(download_id);
 }
 
-// Confirm that everything in all maps is also in |downloads_|, and that
-// everything in |downloads_| is also in some other map.
+// Confirm that there's only one of any download_id, and that they are all > -1
 void DownloadManager::AssertContainersConsistent() const {
-#if !defined(NDEBUG)
-  // Turn everything into sets.
-  DownloadSet active_set, history_set;
-  const DownloadMap* input_maps[] = {&active_downloads_, &history_downloads_};
-  DownloadSet* local_sets[] = {&active_set, &history_set};
-  DCHECK_EQ(ARRAYSIZE_UNSAFE(input_maps), ARRAYSIZE_UNSAFE(local_sets));
-  for (size_t i = 0; i < ARRAYSIZE_UNSAFE(input_maps); i++) {
-    for (DownloadMap::const_iterator it = input_maps[i]->begin();
-         it != input_maps[i]->end(); it++) {
-      local_sets[i]->insert(&*it->second);
-    }
+  std::vector<int> ids;
+  for (DownloadMap::const_iterator iter = downloads_.begin();
+       iter != downloads_.end(); ++iter) {
+    ids.push_back(iter->second->id());
   }
-
-  // Check if each set is fully present in downloads, and create a union.
-  const DownloadSet* all_sets[] = {&active_set, &history_set,
-                                   &save_page_as_downloads_};
-  DownloadSet downloads_union;
-  for (int i = 0; i < static_cast<int>(ARRAYSIZE_UNSAFE(all_sets)); i++) {
-    DownloadSet remainder;
-    std::insert_iterator<DownloadSet> insert_it(remainder, remainder.begin());
-    std::set_difference(all_sets[i]->begin(), all_sets[i]->end(),
-                        downloads_.begin(), downloads_.end(),
-                        insert_it);
-    DCHECK(remainder.empty());
-    std::insert_iterator<DownloadSet>
-        insert_union(downloads_union, downloads_union.end());
-    std::set_union(downloads_union.begin(), downloads_union.end(),
-                   all_sets[i]->begin(), all_sets[i]->end(),
-                   insert_union);
+  std::sort(ids.begin(), ids.end());
+  int prev_id = -1;
+  for (std::vector<int>::const_iterator iter = ids.begin();
+       iter != ids.end(); ++iter) {
+    CHECK_GT(*iter, prev_id) << *iter << " " << prev_id;
+    prev_id = *iter;
   }
-
-  // Is everything in downloads_ present in one of the other sets?
-  DownloadSet remainder;
-  std::insert_iterator<DownloadSet>
-      insert_remainder(remainder, remainder.begin());
-  std::set_difference(downloads_.begin(), downloads_.end(),
-                      downloads_union.begin(), downloads_union.end(),
-                      insert_remainder);
-  DCHECK(remainder.empty());
-#endif
 }
 
 // DownloadManager::OtherDownloadManagerObserver implementation ----------------
 
 DownloadManager::OtherDownloadManagerObserver::OtherDownloadManagerObserver(
     DownloadManager* observing_download_manager)
     : observing_download_manager_(observing_download_manager),
       observed_download_manager_(NULL) {
   if (observing_download_manager->profile_->GetOriginalProfile() ==
       observing_download_manager->profile_) {
@@ skipping 10 matching lines @@
     observed_download_manager_->RemoveObserver(this);
 }
 
 void DownloadManager::OtherDownloadManagerObserver::ModelChanged() {
   observing_download_manager_->NotifyModelChanged();
 }
 
 void DownloadManager::OtherDownloadManagerObserver::ManagerGoingDown() {
   observed_download_manager_ = NULL;
 }