Download code cleanup:

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"
@@ skipping 447 matching lines @@
 
   // We need to move over to the download thread because we don't want to stat
   // the suggested path on the UI thread.
   ChromeThread::PostTask(
       ChromeThread::FILE, FROM_HERE,
       NewRunnableMethod(
           this, &DownloadManager::CheckIfSuggestedPathExists, info));
 }
 
 void DownloadManager::CheckIfSuggestedPathExists(DownloadCreateInfo* info) {
+  DCHECK(ChromeThread::CurrentlyOn(ChromeThread::FILE));
   DCHECK(info);
 
   // 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 = info->suggested_path.DirName();
   FilePath filename = info->suggested_path.BaseName();
   if (!file_util::PathIsWritable(dir)) {
     info->prompt_user_for_save_location = true;
     PathService::Get(chrome::DIR_USER_DOCUMENTS, &info->suggested_path);
     info->suggested_path = info->suggested_path.Append(filename);
@@ skipping 39 matching lines @@
   // See: http://code.google.com/p/chromium/issues/detail?id=3662
   if (!info->prompt_user_for_save_location &&
       info->save_info.file_path.empty()) {
     if (info->is_dangerous)
       file_util::WriteFile(info->suggested_path, "", 0);
     else
       file_util::WriteFile(download_util::GetCrDownloadPath(
           info->suggested_path), "", 0);
   }
 
-  // Now we return to the UI thread.
   ChromeThread::PostTask(
       ChromeThread::UI, FROM_HERE,
       NewRunnableMethod(this,
                         &DownloadManager::OnPathExistenceAvailable,
                         info));
 }
 
 void DownloadManager::OnPathExistenceAvailable(DownloadCreateInfo* info) {
   DCHECK(ChromeThread::CurrentlyOn(ChromeThread::UI));
   DCHECK(info);
@@ skipping 19 matching lines @@
                                     &file_type_info, 0, FILE_PATH_LITERAL(""),
                                     owning_window, info);
   } else {
     // No prompting for download, just continue with the suggested name.
     ContinueStartDownload(info, info->suggested_path);
   }
 }
 
 void DownloadManager::ContinueStartDownload(DownloadCreateInfo* info,
                                             const FilePath& target_path) {
+  DCHECK(ChromeThread::CurrentlyOn(ChromeThread::UI));
+
   scoped_ptr<DownloadCreateInfo> infop(info);
   info->path = target_path;
 
-  DownloadItem* download = NULL;
-  DownloadMap::iterator it = in_progress_.find(info->download_id);
-  if (it == in_progress_.end()) {
-    download = new DownloadItem(info->download_id,
-                                info->path,
-                                info->path_uniquifier,
-                                info->url,
-                                info->referrer_url,
-                                info->mime_type,
-                                info->original_mime_type,
-                                info->original_name,
-                                info->start_time,
-                                info->total_bytes,
-                                info->child_id,
-                                info->request_id,
-                                info->is_dangerous,
-                                info->prompt_user_for_save_location,
-                                profile_->IsOffTheRecord(),
-                                info->is_extension_install,
-                                !info->save_info.file_path.empty());
-    download->set_manager(this);
-    in_progress_[info->download_id] = download;
-  } else {
-    NOTREACHED();  // Should not exist!
-    return;
-  }
+  DownloadItem* download = new DownloadItem(this, *info,
+                                            profile_->IsOffTheRecord());
+  DCHECK(!ContainsKey(in_progress_, info->download_id));
+  in_progress_[info->download_id] = download;
 
-  PendingFinishedMap::iterator pending_it =
-      pending_finished_downloads_.find(info->download_id);
-  bool download_finished = (pending_it != pending_finished_downloads_.end());
+  bool download_finished = ContainsKey(pending_finished_downloads_,
+                                       info->download_id);
 
   if (download_finished || info->is_dangerous) {
     // The download has already finished or the download is not safe.
     // We can now rename the file to its final name (or its tentative name
     // in dangerous download cases).
     ChromeThread::PostTask(
         ChromeThread::FILE, FROM_HERE,
         NewRunnableMethod(
             file_manager_, &DownloadFileManager::OnFinalDownloadName,
             download->id(), target_path, !info->is_dangerous, this));
   } else {
     // The download hasn't finished and it is a safe download.  We need to
     // rename it to its intermediate '.crdownload' path.
     FilePath download_path = download_util::GetCrDownloadPath(target_path);
     ChromeThread::PostTask(
         ChromeThread::FILE, FROM_HERE,
         NewRunnableMethod(
             file_manager_, &DownloadFileManager::OnIntermediateDownloadName,
             download->id(), download_path, this));
     download->set_need_final_rename(true);
   }
 
   if (download_finished) {
     // If the download already completed by the time we reached this point, then
     // notify observers that it did.
-    DownloadFinished(pending_it->first, pending_it->second);
+    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
@@ skipping 119 matching lines @@
             file_manager_, &DownloadFileManager::OnFinalDownloadName,
             download->id(), download->full_path(), false, this));
     return;
   }
 
   ContinueDownloadFinished(download);
 }
 
 void DownloadManager::DownloadRenamedToFinalName(int download_id,
                                                  const FilePath& full_path) {
+  DCHECK(ChromeThread::CurrentlyOn(ChromeThread::UI));
+
   DownloadItem* item = GetDownloadItem(download_id);
   if (!item)
     return;
   item->OnNameFinalized();
 
   // This was called from DownloadFinished; continue to call
   // ContinueDownloadFinished.
   if (item->need_final_rename()) {
     item->set_need_final_rename(false);
     ContinueDownloadFinished(item);
   }
 }
 
 void DownloadManager::ContinueDownloadFinished(DownloadItem* download) {
+  DCHECK(ChromeThread::CurrentlyOn(ChromeThread::UI));
+
   // If this was a dangerous download, it has now been approved and must be
   // removed from dangerous_finished_ so it does not get deleted on shutdown.
-  DownloadMap::iterator it = dangerous_finished_.find(download->id());
-  if (it != dangerous_finished_.end())
-    dangerous_finished_.erase(it);
+  dangerous_finished_.erase(download->id());
 
   // Handle chrome extensions explicitly and skip the shell execute.
   if (download->is_extension_install()) {
     OpenChromeExtension(download->full_path(),
                         download->url(),
                         download->referrer_url(),
                         download->original_mime_type());
     download->set_auto_opened(true);
   } else if (download->open_when_complete() ||
              ShouldOpenFileBasedOnExtension(download->full_path()) ||
@@ skipping 694 matching lines @@
 #endif
 }
 
 // Operations posted to us from the history service ----------------------------
 
 // The history service has retrieved all download entries. 'entries' contains
 // 'DownloadCreateInfo's in sorted order (by ascending start_time).
 void DownloadManager::OnQueryDownloadEntriesComplete(
     std::vector<DownloadCreateInfo>* entries) {
   for (size_t i = 0; i < entries->size(); ++i) {
-    DownloadItem* download = new DownloadItem(entries->at(i));
-    DCHECK(downloads_.find(download->db_handle()) == downloads_.end());
+    DownloadItem* download = new DownloadItem(this, entries->at(i));
+    DCHECK(!ContainsKey(downloads_, download->db_handle()));
     downloads_[download->db_handle()] = download;
-    download->set_manager(this);
   }
   NotifyModelChanged();
 }
 
 // Once the new DownloadItem's creation info has been committed to the history
 // service, we associate the DownloadItem with the db handle, update our
 // 'downloads_' map and inform observers.
 void DownloadManager::OnCreateDownloadEntryComplete(DownloadCreateInfo info,
                                                     int64 db_handle) {
   DownloadMap::iterator it = in_progress_.find(info.download_id);
@@ skipping 120 matching lines @@
   observing_download_manager_->NotifyModelChanged();
 }
 
 void DownloadManager::OtherDownloadManagerObserver::SetDownloads(
     std::vector<DownloadItem*>& downloads) {
 }
 
 void DownloadManager::OtherDownloadManagerObserver::ManagerGoingDown() {
   observed_download_manager_ = NULL;
 }