Simplify threading in browser thread by making only ChromeThread deal with di...

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"
@@ skipping 913 matching lines @@
     // name when calling GetFileName().
     download->set_path_uniquifier(new_path_uniquifier);
     RenameDownload(download, new_path);
   }
 
   // Continue the download finished sequence.
   ContinueDownloadFinished(download);
 }
 
 // static
-// We have to tell the ResourceDispatcherHost to cancel the download from this
-// thread, since we can't forward tasks from the file thread to the IO thread
-// reliably (crash on shutdown race condition).
-void DownloadManager::CancelDownloadRequest(int render_process_id,
-                                            int request_id) {
-  ResourceDispatcherHost* rdh = g_browser_process->resource_dispatcher_host();
-  base::Thread* io_thread = g_browser_process->io_thread();
-  if (!io_thread || !rdh)
-    return;
-  io_thread->message_loop()->PostTask(FROM_HERE,
-      NewRunnableFunction(&DownloadManager::OnCancelDownloadRequest,
-                          rdh,
-                          render_process_id,
-                          request_id));
-}
-
-// static
 void DownloadManager::OnCancelDownloadRequest(ResourceDispatcherHost* rdh,
                                               int render_process_id,
                                               int request_id) {
+  DCHECK(ChromeThread::CurrentlyOn(ChromeThread::IO));
   rdh->CancelRequest(render_process_id, request_id, false);
 }
 
 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) {
     in_progress_.erase(it);
     UpdateHistoryForDownload(download);
   }
 
   DownloadCancelledInternal(download_id,
                             download->render_process_id(),
                             download->request_id());
 }
 
 void DownloadManager::DownloadCancelledInternal(int download_id,
                                                 int render_process_id,
                                                 int request_id) {
-  // Cancel the network request.
-  CancelDownloadRequest(render_process_id, request_id);
+  // 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));
 }
 
 void DownloadManager::PauseDownload(int32 download_id, bool pause) {
   DownloadMap::iterator it = in_progress_.find(download_id);
-  if (it != in_progress_.end()) {
-    DownloadItem* download = it->second;
-    if (pause == download->is_paused())
-      return;
+  if (it == in_progress_.end())
+    return;
 
-    // Inform the ResourceDispatcherHost of the new pause state.
-    base::Thread* io_thread = g_browser_process->io_thread();
-    ResourceDispatcherHost* rdh = g_browser_process->resource_dispatcher_host();
-    if (!io_thread || !rdh)
-      return;
+  DownloadItem* download = it->second;
+  if (pause == download->is_paused())
+    return;
 
-    io_thread->message_loop()->PostTask(FROM_HERE,
-        NewRunnableFunction(&DownloadManager::OnPauseDownloadRequest,
-                            rdh,
-                            download->render_process_id(),
-                            download->request_id(),
-                            pause));
-  }
+  // Inform the ResourceDispatcherHost of the new pause state.
+  ChromeThread::PostTask(
+      ChromeThread::IO, FROM_HERE,
+       NewRunnableFunction(&DownloadManager::OnPauseDownloadRequest,

[darin (slow to review), 2009/10/27 00:06:52]

nit: indentation

[jam, 2009/10/27 02:38:18]

Done.

+                          g_browser_process->resource_dispatcher_host(),
+                          download->render_process_id(),
+                          download->request_id(),
+                          pause));     
 }
 
 // static
 void DownloadManager::OnPauseDownloadRequest(ResourceDispatcherHost* rdh,
                                              int render_process_id,
                                              int request_id,
                                              bool pause) {
   rdh->PauseRequest(render_process_id, request_id, pause);
 }
 
@@ skipping 530 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();
 }