Fourth patch in getting rid of caching MessageLoop pointers.

chrome/browser/download/download_manager.cc

 // Copyright (c) 2006-2009 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 "base/file_util.h"
 #include "base/logging.h"
 #include "base/message_loop.h"
 #include "base/path_service.h"
 #include "base/rand_util.h"
 #include "base/stl_util-inl.h"
 #include "base/string_util.h"
 #include "base/sys_string_conversions.h"
 #include "base/task.h"
 #include "base/thread.h"
 #include "base/timer.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.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/net/chrome_url_request_context.h"
 #include "chrome/browser/profile.h"
 #include "chrome/browser/renderer_host/render_process_host.h"
 #include "chrome/browser/renderer_host/render_view_host.h"
 #include "chrome/browser/renderer_host/resource_dispatcher_host.h"
@@ skipping 309 matching lines @@
       prefs->SetString(prefs::kDownloadDefaultDirectory,
                        default_download_path.ToWStringHack());
     }
     prefs->SetBoolean(prefs::kDownloadDirUpgraded, true);
   }
 }
 
 DownloadManager::DownloadManager()
     : shutdown_needed_(false),
       profile_(NULL),
-      file_manager_(NULL),
-      ui_loop_(MessageLoop::current()),
-      file_loop_(NULL) {
+      file_manager_(NULL) {
 }
 
 DownloadManager::~DownloadManager() {
   if (shutdown_needed_)
     Shutdown();
 }
 
 void DownloadManager::Shutdown() {
   DCHECK(shutdown_needed_) << "Shutdown called when not needed.";
 
@@ skipping 124 matching lines @@
     NOTREACHED();
     return false;
   }
 
   file_manager_ = rdh->download_file_manager();
   if (!file_manager_) {
     NOTREACHED();
     return false;
   }
 
-  file_loop_ = g_browser_process->file_thread()->message_loop();
-  if (!file_loop_) {
-    NOTREACHED();
-    return false;
-  }
-
   // Get our user preference state.
   PrefService* prefs = profile_->GetPrefs();
   DCHECK(prefs);
   prompt_for_download_.Init(prefs::kPromptForDownload, prefs, NULL);
 
   download_path_.Init(prefs::kDownloadDefaultDirectory, prefs, NULL);
 
   // This variable is needed to resolve which CreateDirectory we want to point
   // to. Without it, the NewRunnableFunction cannot resolve the ambiguity.
   // TODO(estade): when file_util::CreateDirectory(wstring) is removed,
   // get rid of |CreateDirectoryPtr|.
   bool (*CreateDirectoryPtr)(const FilePath&) = &file_util::CreateDirectory;
   // Ensure that the download directory specified in the preferences exists.
-  file_loop_->PostTask(FROM_HERE, NewRunnableFunction(
-      CreateDirectoryPtr, download_path()));
+  ChromeThread::PostTask(
+      ChromeThread::FILE, FROM_HERE,
+      NewRunnableFunction(CreateDirectoryPtr, download_path()));
 
   // We use this to determine possibly dangerous downloads.
   download_util::InitializeExeTypes(&exe_types_);
 
   // We store any file extension that should be opened automatically at
   // download completion in this pref.
   std::wstring extensions_to_open =
       prefs->GetString(prefs::kDownloadExtensionsToOpen);
   std::vector<std::wstring> extensions;
   SplitString(extensions_to_open, L':', &extensions);
@@ skipping 16 matching lines @@
 }
 
 // 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(MessageLoop::current() == ui_loop_);
+  DCHECK(ChromeThread::CurrentlyOn(ChromeThread::UI));
   DCHECK(info);
 
   // Freeze the user's preference for showing a Save As dialog.  We're going to
   // bounce around a bunch of threads and we don't want to worry about race
   // conditions where the user changes this pref out from under us.
   if (*prompt_for_download_) {
     // But never obey the preference for extension installation. Note that we
     // only care here about the case where an extension is installed, not when
     // one is downloaded with "save as...".
     if (!IsExtensionInstall(info))
@@ skipping 18 matching lines @@
       info->is_dangerous = true;
     else if (IsExtensionInstall(info) &&
              !ExtensionsService::IsDownloadFromGallery(info->url,
                                                        info->referrer_url)) {
       info->is_dangerous = true;
     }
   }
 
   // We need to move over to the download thread because we don't want to stat
   // the suggested path on the UI thread.
-  file_loop_->PostTask(FROM_HERE,
-      NewRunnableMethod(this,
-                        &DownloadManager::CheckIfSuggestedPathExists,
-                        info));
+  ChromeThread::PostTask(
+      ChromeThread::FILE, FROM_HERE,
+      NewRunnableMethod(
+          this, &DownloadManager::CheckIfSuggestedPathExists, info));
 }
 
 void DownloadManager::CheckIfSuggestedPathExists(DownloadCreateInfo* info) {
   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)) {
@@ skipping 33 matching lines @@
   }
 
   if (!info->save_as) {
     // Create an empty file at the suggested path so that we don't allocate the
     // same "non-existant" path to multiple downloads.
     // See: http://code.google.com/p/chromium/issues/detail?id=3662
     file_util::WriteFile(info->suggested_path, "", 0);
   }
 
   // Now we return to the UI thread.
-  ui_loop_->PostTask(FROM_HERE,
+  ChromeThread::PostTask(
+      ChromeThread::UI, FROM_HERE,
       NewRunnableMethod(this,
                         &DownloadManager::OnPathExistenceAvailable,
                         info));
 }
 
 void DownloadManager::OnPathExistenceAvailable(DownloadCreateInfo* info) {
-  DCHECK(MessageLoop::current() == ui_loop_);
+  DCHECK(ChromeThread::CurrentlyOn(ChromeThread::UI));
   DCHECK(info);
 
   if (info->save_as) {
     // We must ask the user for the place to put the download.
     if (!select_file_dialog_.get())
       select_file_dialog_ = SelectFileDialog::Create(this);
 
     TabContents* contents = tab_util::GetTabContentsByID(info->child_id,
                                                          info->render_view_id);
     SelectFileDialog::FileTypeInfo file_type_info;
@@ skipping 38 matching lines @@
                                 info->save_as);
     download->set_manager(this);
     in_progress_[info->download_id] = download;
   } else {
     NOTREACHED();  // Should not exist!
     return;
   }
 
   // Called before DownloadFinished in order to avoid a race condition where we
   // attempt to open a completed download before it has been renamed.
-  file_loop_->PostTask(FROM_HERE,
-      NewRunnableMethod(file_manager_,
-                        &DownloadFileManager::OnFinalDownloadName,
-                        download->id(),
-                        target_path,
-                        this));
+  ChromeThread::PostTask(
+      ChromeThread::FILE, FROM_HERE,
+      NewRunnableMethod(
+          file_manager_, &DownloadFileManager::OnFinalDownloadName,
+          download->id(), target_path, this));
 
   // If the download already completed by the time we reached this point, then
   // notify observers that it did.
   PendingFinishedMap::iterator pending_it =
       pending_finished_downloads_.find(info->download_id);
   if (pending_it != pending_finished_downloads_.end())
     DownloadFinished(pending_it->first, pending_it->second);
 
   download->Rename(target_path);
 
@@ skipping 97 matching lines @@
   // 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;
   }
 
   if (download->safety_state() == DownloadItem::DANGEROUS_BUT_VALIDATED) {
     // We first need to rename the downloaded file from its temporary name to
     // its final name before we can continue.
-    file_loop_->PostTask(FROM_HERE,
+    ChromeThread::PostTask(
+      ChromeThread::FILE, FROM_HERE,
         NewRunnableMethod(
             this, &DownloadManager::ProceedWithFinishedDangerousDownload,
             download->db_handle(),
             download->full_path(), download->original_name()));
     return;
   }
   ContinueDownloadFinished(download);
 }
 
 void DownloadManager::DownloadRenamedToFinalName(int download_id,
@@ skipping 39 matching lines @@
     // start, and at that time the first file does not exists yet, so the second
     // file gets the same name.
     uniquifier = GetUniquePathNumber(new_path);
     if (uniquifier > 0)
       AppendNumberToPath(&new_path, uniquifier);
     success = file_util::Move(path, new_path);
   } else {
     NOTREACHED();
   }
 
-  ui_loop_->PostTask(FROM_HERE,
+  ChromeThread::PostTask(
+      ChromeThread::UI, FROM_HERE,
       NewRunnableMethod(this, &DownloadManager::DangerousDownloadRenamed,
                         download_handle, success, new_path, uniquifier));
 }
 
 // Call from the file thread when the finished dangerous download was renamed.
 void DownloadManager::DangerousDownloadRenamed(int64 download_handle,
                                                bool success,
                                                const FilePath& new_path,
                                                int new_path_uniquifier) {
   DownloadMap::iterator it = downloads_.find(download_handle);
@@ skipping 47 matching lines @@
   // Cancel the network request.  RDH is guaranteed to outlive the IO thread.
   ChromeThread::PostTask(
       ChromeThread::IO, FROM_HERE,
       NewRunnableFunction(&DownloadManager::OnCancelDownloadRequest,
                           g_browser_process->resource_dispatcher_host(),
                           render_process_id,
                           request_id));
 
   // Tell the file manager to cancel the download.
   file_manager_->RemoveDownload(download_id, this);  // On the UI thread
-  file_loop_->PostTask(FROM_HERE,
-      NewRunnableMethod(file_manager_,
-                        &DownloadFileManager::CancelDownload,
-                        download_id));
+  ChromeThread::PostTask(
+      ChromeThread::FILE, FROM_HERE,
+      NewRunnableMethod(
+          file_manager_, &DownloadFileManager::CancelDownload, download_id));
 }
 
 void DownloadManager::PauseDownload(int32 download_id, bool pause) {
   DownloadMap::iterator it = in_progress_.find(download_id);
   if (it == in_progress_.end())
     return;
 
   DownloadItem* download = it->second;
   if (pause == download->is_paused())
     return;
@@ skipping 224 matching lines @@
 }
 
 void DownloadManager::RemoveObserver(Observer* observer) {
   observers_.RemoveObserver(observer);
 }
 
 // Post Windows Shell operations to the Download thread, to avoid blocking the
 // user interface.
 void DownloadManager::ShowDownloadInShell(const DownloadItem* download) {
   DCHECK(file_manager_);
-  DCHECK(MessageLoop::current() == ui_loop_);
+  DCHECK(ChromeThread::CurrentlyOn(ChromeThread::UI));
 #if defined(OS_MACOSX)
   // Mac needs to run this operation on the UI thread.
   platform_util::ShowItemInFolder(download->full_path());
 #else
-  file_loop_->PostTask(FROM_HERE,
-      NewRunnableMethod(file_manager_,
-                        &DownloadFileManager::OnShowDownloadInShell,
-                        FilePath(download->full_path())));
+  ChromeThread::PostTask(
+      ChromeThread::FILE, FROM_HERE,
+      NewRunnableMethod(
+          file_manager_, &DownloadFileManager::OnShowDownloadInShell,
+          FilePath(download->full_path())));
 #endif
 }
 
 void DownloadManager::OpenDownload(const DownloadItem* download,
                                    gfx::NativeView parent_window) {
   // Open Chrome extensions with ExtensionsService. For everything else do shell
   // execute.
   if (IsExtensionInstall(download)) {
     OpenChromeExtension(download->full_path(), download->url(),
                         download->referrer_url());
@@ skipping 19 matching lines @@
                         true,  // please delete crx on completion
                         true,  // privilege increase allowed
                         service,
                         new ExtensionInstallUI(profile_));
   }
 }
 
 void DownloadManager::OpenDownloadInShell(const DownloadItem* download,
                                           gfx::NativeView parent_window) {
   DCHECK(file_manager_);
-  DCHECK(MessageLoop::current() == ui_loop_);
+  DCHECK(ChromeThread::CurrentlyOn(ChromeThread::UI));
 #if defined(OS_MACOSX)
   // Mac OS X requires opening downloads on the UI thread.
   platform_util::OpenItem(download->full_path());
 #else
-  file_loop_->PostTask(FROM_HERE,
-      NewRunnableMethod(file_manager_,
-                        &DownloadFileManager::OnOpenDownloadInShell,
-                        download->full_path(), download->url(), parent_window));
+  ChromeThread::PostTask(
+      ChromeThread::FILE, FROM_HERE,
+      NewRunnableMethod(
+          file_manager_, &DownloadFileManager::OnOpenDownloadInShell,
+          download->full_path(), download->url(), parent_window));
 #endif
 }
 
 void DownloadManager::OpenFilesBasedOnExtension(
     const FilePath& path, bool open) {
   FilePath::StringType extension = path.Extension();
   if (extension.empty())
     return;
   DCHECK(extension[0] == FilePath::kExtensionSeparator);
   extension.erase(0, 1);
@@ skipping 118 matching lines @@
 void DownloadManager::FileSelectionCanceled(void* params) {
   // The user didn't pick a place to save the file, so need to cancel the
   // download that's already in progress to the temporary location.
   DownloadCreateInfo* info = reinterpret_cast<DownloadCreateInfo*>(params);
   DownloadCancelledInternal(info->download_id,
                             info->child_id,
                             info->request_id);
 }
 
 void DownloadManager::DeleteDownload(const FilePath& path) {
-  file_loop_->PostTask(FROM_HERE, NewRunnableFunction(
-      &DownloadFileManager::DeleteFile, FilePath(path)));
+  ChromeThread::PostTask(
+      ChromeThread::FILE, FROM_HERE,
+      NewRunnableFunction(&DownloadFileManager::DeleteFile, FilePath(path)));
 }
 
 
 void DownloadManager::DangerousDownloadValidated(DownloadItem* download) {
   DCHECK_EQ(DownloadItem::DANGEROUS, download->safety_state());
   download->set_safety_state(DownloadItem::DANGEROUS_BUT_VALIDATED);
   download->UpdateObservers();
 
   // If the download is not complete, nothing to do.  The required
   // post-processing will be performed when it does complete.
   if (download->state() != DownloadItem::COMPLETE)
     return;
 
-  file_loop_->PostTask(FROM_HERE,
-      NewRunnableMethod(this,
-                        &DownloadManager::ProceedWithFinishedDangerousDownload,
-                        download->db_handle(), download->full_path(),
-                        download->original_name()));
+  ChromeThread::PostTask(
+      ChromeThread::FILE, FROM_HERE,
+      NewRunnableMethod(
+          this, &DownloadManager::ProceedWithFinishedDangerousDownload,
+          download->db_handle(), download->full_path(),
+          download->original_name()));
 }
 
 void DownloadManager::GenerateSafeFilename(const std::string& mime_type,
                                            FilePath* file_name) {
   // Make sure we get the right file extension
   FilePath::StringType extension;
   GenerateExtension(*file_name, mime_type, &extension);
   file_util::ReplaceExtension(file_name, extension);
 
 #if defined(OS_WIN)
@@ skipping 107 matching lines @@
 
   if (contents)
     contents->OnStartDownload(download);
 }
 
 // Clears the last download path, used to initialize "save as" dialogs.
 void DownloadManager::ClearLastDownloadPath() {
   last_download_path_ = FilePath();
 }