Fourth patch in getting rid of caching MessageLoop pointers.

chrome/browser/renderer_host/resource_dispatcher_host.cc

 // Copyright (c) 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.
 
 // See http://dev.chromium.org/developers/design-documents/multi-process-resource-loading
 
 #include "chrome/browser/renderer_host/resource_dispatcher_host.h"
 
 #include <vector>
 
@@ skipping 239 matching lines @@
 
 }  // namespace
 
 ResourceDispatcherHost::ResourceDispatcherHost(MessageLoop* io_loop)
     : ui_loop_(MessageLoop::current()),
       io_loop_(io_loop),
       ALLOW_THIS_IN_INITIALIZER_LIST(
           download_file_manager_(new DownloadFileManager(this))),
       download_request_manager_(new DownloadRequestManager(io_loop, ui_loop_)),
       ALLOW_THIS_IN_INITIALIZER_LIST(
-          save_file_manager_(new SaveFileManager(ui_loop_, io_loop, this))),
+          save_file_manager_(new SaveFileManager(this))),
       ALLOW_THIS_IN_INITIALIZER_LIST(user_script_listener_(
           new UserScriptListener(this))),
       safe_browsing_(new SafeBrowsingService),
       webkit_thread_(new WebKitThread),
       request_id_(-1),
       ALLOW_THIS_IN_INITIALIZER_LIST(method_runner_(this)),
       is_shutdown_(false),
       max_outstanding_requests_cost_per_process_(
           kMaxOutstandingRequestsCostPerProcess),
       receiver_(NULL) {
@@ skipping 17 matching lines @@
   }
   for (std::set<ProcessRouteIDs>::const_iterator iter = ids.begin();
        iter != ids.end(); ++iter) {
     CancelBlockedRequestsForRoute(iter->first, iter->second);
   }
 
   user_script_listener_->OnResourceDispatcherHostGone();
 }
 
 void ResourceDispatcherHost::Initialize() {
-  DCHECK(MessageLoop::current() == ui_loop_);
-  safe_browsing_->Initialize(io_loop_);
-  io_loop_->PostTask(
-      FROM_HERE,
+  DCHECK(ChromeThread::CurrentlyOn(ChromeThread::UI));
+  safe_browsing_->Initialize();
+  ChromeThread::PostTask(
+      ChromeThread::IO, FROM_HERE,
       NewRunnableFunction(&appcache::AppCacheInterceptor::EnsureRegistered));
 }
 
 void ResourceDispatcherHost::Shutdown() {
-  DCHECK(MessageLoop::current() == ui_loop_);
-  io_loop_->PostTask(FROM_HERE, new ShutdownTask(this));
+  DCHECK(ChromeThread::CurrentlyOn(ChromeThread::UI));
+  ChromeThread::PostTask(ChromeThread::IO, FROM_HERE, new ShutdownTask(this));
 }
 
 void ResourceDispatcherHost::SetRequestInfo(
     URLRequest* request,
     ResourceDispatcherHostRequestInfo* info) {
   request->SetUserData(NULL, info);
 }
 
 void ResourceDispatcherHost::OnShutdown() {
-  DCHECK(MessageLoop::current() == io_loop_);
+  DCHECK(ChromeThread::CurrentlyOn(ChromeThread::IO));
   is_shutdown_ = true;
   STLDeleteValues(&pending_requests_);
   // Make sure we shutdown the timer now, otherwise by the time our destructor
   // runs if the timer is still running the Task is deleted twice (once by
   // the MessageLoop and the second time by RepeatingTimer).
   update_load_states_timer_.Stop();
 }
 
 bool ResourceDispatcherHost::HandleExternalProtocol(int request_id,
                                                     int child_id,
                                                     int route_id,
                                                     const GURL& url,
                                                     ResourceType::Type type,
                                                     ResourceHandler* handler) {
   if (!ResourceType::IsFrame(type) || URLRequest::IsHandledURL(url))
     return false;
 
-  ui_loop_->PostTask(FROM_HERE, NewRunnableFunction(
-      &ExternalProtocolHandler::LaunchUrl, url, child_id, route_id));
+  ChromeThread::PostTask(
+      ChromeThread::UI, FROM_HERE,
+      NewRunnableFunction(
+          &ExternalProtocolHandler::LaunchUrl, url, child_id, route_id));
 
   handler->OnResponseCompleted(request_id, URLRequestStatus(
                                                URLRequestStatus::FAILED,
                                                net::ERR_ABORTED),
                                std::string());  // No security info necessary.
   return true;
 }
 
 bool ResourceDispatcherHost::OnMessageReceived(const IPC::Message& message,
                                                Receiver* receiver,
@@ skipping 323 matching lines @@
     if (i != pending_requests_.end()) {
       // The response we were meant to resume could have already been canceled.
       ResourceDispatcherHostRequestInfo* info = InfoForRequest(i->second);
       if (info->cross_site_handler())
         info->cross_site_handler()->ResumeResponse();
     }
   } else {
     // This is a tab close, so just forward the message to close it.
     DCHECK(params.new_render_process_host_id == -1);
     DCHECK(params.new_request_id == -1);
-    ui_loop_->PostTask(
-        FROM_HERE,
+    ChromeThread::PostTask(
+        ChromeThread::UI, FROM_HERE,
         new RVHCloseNotificationTask(params.closing_process_id,
                                      params.closing_route_id));
   }
 }
 
 // We are explicitly forcing the download of 'url'.
 void ResourceDispatcherHost::BeginDownload(const GURL& url,
                                            const GURL& referrer,
                                            int child_id,
                                            int route_id,
@@ skipping 818 matching lines @@
 void ResourceDispatcherHost::AddObserver(Observer* obs) {
   observer_list_.AddObserver(obs);
 }
 
 void ResourceDispatcherHost::RemoveObserver(Observer* obs) {
   observer_list_.RemoveObserver(obs);
 }
 
 URLRequest* ResourceDispatcherHost::GetURLRequest(
     GlobalRequestID request_id) const {
-  // This should be running in the IO loop. io_loop_ can be NULL during the
-  // unit_tests.
-  DCHECK(MessageLoop::current() == io_loop_ && io_loop_);
+  // This should be running in the IO loop.
+  DCHECK(ChromeThread::CurrentlyOn(ChromeThread::IO));
 
   PendingRequestList::const_iterator i = pending_requests_.find(request_id);
   if (i == pending_requests_.end())
     return NULL;
 
   return i->second;
 }
 
 static int GetCertID(URLRequest* request, int child_id) {
   if (request->ssl_info().cert) {
@@ skipping 11 matching lines @@
          (request->response_headers()->response_code() <= 599)));
   return 0;
 }
 
 void ResourceDispatcherHost::NotifyResponseStarted(URLRequest* request,
                                                    int child_id) {
   // Notify the observers on the IO thread.
   FOR_EACH_OBSERVER(Observer, observer_list_, OnRequestStarted(this, request));
 
   // Notify the observers on the UI thread.
-  ui_loop_->PostTask(FROM_HERE, new RVHDelegateNotificationTask(request,
-      &RenderViewHostDelegate::Resource::DidStartReceivingResourceResponse,
-      new ResourceRequestDetails(request, GetCertID(request, child_id))));
+  ChromeThread::PostTask(
+      ChromeThread::UI, FROM_HERE,
+      new RVHDelegateNotificationTask(
+          request,
+          &RenderViewHostDelegate::Resource::DidStartReceivingResourceResponse,
+          new ResourceRequestDetails(request, GetCertID(request, child_id))));
 }
 
 void ResourceDispatcherHost::NotifyResponseCompleted(URLRequest* request,
                                                      int child_id) {
   // Notify the observers on the IO thread.
   FOR_EACH_OBSERVER(Observer, observer_list_,
                     OnResponseCompleted(this, request));
 }
 
 void ResourceDispatcherHost::NotifyReceivedRedirect(URLRequest* request,
                                                     int child_id,
                                                     const GURL& new_url) {
   // Notify the observers on the IO thread.
   FOR_EACH_OBSERVER(Observer, observer_list_,
                     OnReceivedRedirect(this, request, new_url));
 
   int cert_id = GetCertID(request, child_id);
 
   // Notify the observers on the UI thread.
-  ui_loop_->PostTask(FROM_HERE,
-      new RVHDelegateNotificationTask(request,
-          &RenderViewHostDelegate::Resource::DidRedirectResource,
+  ChromeThread::PostTask(
+      ChromeThread::UI, FROM_HERE,
+      new RVHDelegateNotificationTask(
+          request, &RenderViewHostDelegate::Resource::DidRedirectResource,
           new ResourceRedirectDetails(request, cert_id, new_url)));
 }
 
 namespace {
 
 // This function attempts to return the "more interesting" load state of |a|
 // and |b|.  We don't have temporal information about these load states
 // (meaning we don't know when we transitioned into these states), so we just
 // rank them according to how "interesting" the states are.
 //
@@ skipping 100 matching lines @@
       load_info.upload_size = info->upload_size();
       load_info.upload_position = request->GetUploadProgress();
     }
   }
 
   if (info_map.empty())
     return;
 
   LoadInfoUpdateTask* task = new LoadInfoUpdateTask;
   task->info_map.swap(info_map);
-  ui_loop_->PostTask(FROM_HERE, task);
+  ChromeThread::PostTask(ChromeThread::UI, FROM_HERE, task);
 }
 
 // Calls the ResourceHandler to send upload progress messages to the renderer.
 // Returns true iff an upload progress message should be sent to the UI thread.
 bool ResourceDispatcherHost::MaybeUpdateUploadProgress(
     ResourceDispatcherHostRequestInfo *info,
     URLRequest *request) {
 
   if (!info->upload_size() || info->waiting_for_upload_progress_ack())
     return false;
@@ skipping 89 matching lines @@
     case ViewHostMsg_UploadProgress_ACK::ID:
     case ViewHostMsg_SyncLoad::ID:
       return true;
 
     default:
       break;
   }
 
   return false;
 }