Last patch in removing MessageLoop* caching.

chrome/browser/download/download_request_manager.cc

 // Copyright (c) 2006-2008 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_request_manager.h"
 
-#include "base/message_loop.h"
-#include "base/thread.h"
+#include "chrome/browser/chrome_thread.h"
 #include "chrome/browser/download/download_request_infobar_delegate.h"
 #include "chrome/browser/tab_contents/navigation_controller.h"
 #include "chrome/browser/tab_contents/navigation_entry.h"
 #include "chrome/browser/tab_contents/tab_contents_delegate.h"
 #include "chrome/browser/tab_contents/tab_util.h"
 #include "chrome/browser/tab_contents/tab_contents.h"
 #include "chrome/common/notification_service.h"
 
 // TabDownloadState ------------------------------------------------------------
 
@@ skipping 126 matching lines @@
       DownloadRequestManager::ALLOW_ALL_DOWNLOADS :
       DownloadRequestManager::DOWNLOADS_NOT_ALLOWED;
   std::vector<DownloadRequestManager::Callback*> callbacks;
   callbacks.swap(callbacks_);
   for (size_t i = 0; i < callbacks.size(); ++i)
     host_->ScheduleNotification(callbacks[i], allow);
 }
 
 // DownloadRequestManager ------------------------------------------------------
 
-DownloadRequestManager::DownloadRequestManager(MessageLoop* io_loop,
-                                               MessageLoop* ui_loop)
-    : io_loop_(io_loop),
-      ui_loop_(ui_loop) {
+DownloadRequestManager::DownloadRequestManager() {
 }
 
 DownloadRequestManager::~DownloadRequestManager() {
   // All the tabs should have closed before us, which sends notification and
   // removes from state_map_. As such, there should be no pending callbacks.
   DCHECK(state_map_.empty());
 }
 
 DownloadRequestManager::DownloadStatus
     DownloadRequestManager::GetDownloadStatus(TabContents* tab) {
   TabDownloadState* state = GetDownloadState(&tab->controller(), NULL, false);
   return state ? state->download_status() : ALLOW_ONE_DOWNLOAD;
 }
 
 void DownloadRequestManager::CanDownloadOnIOThread(int render_process_host_id,
                                                    int render_view_id,
                                                    Callback* callback) {
   // This is invoked on the IO thread. Schedule the task to run on the UI
   // thread so that we can query UI state.
-  DCHECK(!io_loop_ || io_loop_ == MessageLoop::current());
-  ui_loop_->PostTask(FROM_HERE,
+  DCHECK(ChromeThread::CurrentlyOn(ChromeThread::IO));
+  ChromeThread::PostTask(
+      ChromeThread::UI, FROM_HERE,
       NewRunnableMethod(this, &DownloadRequestManager::CanDownload,
                         render_process_host_id, render_view_id, callback));
 }
 
 void DownloadRequestManager::OnUserGesture(TabContents* tab) {
   TabDownloadState* state = GetDownloadState(&tab->controller(), NULL, false);
   if (!state)
     return;
 
   state->OnUserGesture();
@@ skipping 18 matching lines @@
 
   TabDownloadState* state =
       new TabDownloadState(this, controller, originating_controller);
   state_map_[controller] = state;
   return state;
 }
 
 void DownloadRequestManager::CanDownload(int render_process_host_id,
                                          int render_view_id,
                                          Callback* callback) {
-  DCHECK(!ui_loop_ || MessageLoop::current() == ui_loop_);
+  DCHECK(ChromeThread::CurrentlyOn(ChromeThread::UI));
 
   TabContents* originating_tab =
       tab_util::GetTabContentsByID(render_process_host_id, render_view_id);
   if (!originating_tab) {
     // The tab was closed, don't allow the download.
     ScheduleNotification(callback, false);
     return;
   }
   CanDownloadImpl(originating_tab, callback);
 }
@@ skipping 29 matching lines @@
       state->PromptUserForDownload(effective_tab, callback);
       break;
 
     default:
       NOTREACHED();
   }
 }
 
 void DownloadRequestManager::ScheduleNotification(Callback* callback,
                                                   bool allow) {
-  if (io_loop_) {
-    io_loop_->PostTask(FROM_HERE,
-        NewRunnableMethod(this, &DownloadRequestManager::NotifyCallback,
-                          callback, allow));
-  } else {
-    NotifyCallback(callback, allow);
-  }
+  ChromeThread::PostTask(
+      ChromeThread::IO, FROM_HERE,
+      NewRunnableMethod(
+          this, &DownloadRequestManager::NotifyCallback, callback, allow));
 }
 
 void DownloadRequestManager::NotifyCallback(Callback* callback, bool allow) {
   // We better be on the IO thread now.
-  DCHECK(!io_loop_ || MessageLoop::current() == io_loop_);
+  DCHECK(ChromeThread::CurrentlyOn(ChromeThread::IO));
   if (allow)
     callback->ContinueDownload();
   else
     callback->CancelDownload();
 }
 
 void DownloadRequestManager::Remove(TabDownloadState* state) {
   DCHECK(state_map_.find(state->controller()) != state_map_.end());
   state_map_.erase(state->controller());
   delete state;
 }
 
 // static
 DownloadRequestManager::TestingDelegate* DownloadRequestManager::delegate_ =
     NULL;