Third patch in getting rid of caching MessageLoop pointers and always using C...

chrome/browser/renderer_host/buffered_resource_handler.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.
 
 #include "chrome/browser/renderer_host/buffered_resource_handler.h"
 
 #include <vector>
 
 #include "base/histogram.h"
 #include "base/logging.h"
@@ skipping 386 matching lines @@
 
   // Schedule plugin loading on the file thread.
   // Note: it's possible that the only reference to this object is the task.  If
   // If the task executes on the file thread, and before it returns, the task it
   // posts to the IO thread runs, then this object will get destructed on the
   // file thread.  This breaks assumptions in other message handlers (i.e. when
   // unregistering with NotificationService in the destructor).
   AddRef();
   ChromeThread::PostTask(
       ChromeThread::FILE, FROM_HERE,
-      NewRunnableFunction(&BufferedResourceHandler::LoadPlugins,
-          this, host_->ui_loop()));
+      NewRunnableFunction(&BufferedResourceHandler::LoadPlugins, this));
   return true;
 }
 
 // This test mirrors the decision that WebKit makes in
 // WebFrameLoaderClient::dispatchDecidePolicyForMIMEType.
 bool BufferedResourceHandler::ShouldDownload(bool* need_plugin_list) {
   if (need_plugin_list)
     *need_plugin_list = false;
   std::string type = StringToLowerASCII(response_->response_head.mime_type);
   std::string disposition;
@@ skipping 43 matching lines @@
     DCHECK(NPAPI::PluginList::Singleton()->PluginsLoaded());
   }
 
   // Finally, check the plugin list.
   WebPluginInfo info;
   bool allow_wildcard = false;
   return !NPAPI::PluginList::Singleton()->GetPluginInfo(
       GURL(), type, allow_wildcard, &info, NULL);
 }
 
-void BufferedResourceHandler::LoadPlugins(BufferedResourceHandler* handler,
-                                          MessageLoop* main_message_loop) {
+void BufferedResourceHandler::LoadPlugins(BufferedResourceHandler* handler) {
   std::vector<WebPluginInfo> plugins;
   NPAPI::PluginList::Singleton()->GetPlugins(false, &plugins);
 
-  // Note, we want to get to the IO thread now, but the file thread outlives it
-  // so we can't post a task to it directly as it might be in the middle of
-  // destruction.  So hop through the main thread, where the destruction of the
-  // IO thread happens and hence no race conditions exist.
-  main_message_loop->PostTask(FROM_HERE,
-      NewRunnableFunction(&BufferedResourceHandler::NotifyPluginsLoaded,
+  ChromeThread::PostTask(
+      ChromeThread::IO, FROM_HERE,
+      NewRunnableFunction(&BufferedResourceHandler::OnPluginsLoaded,
           handler));
 }
 
-void BufferedResourceHandler::NotifyPluginsLoaded(
+void BufferedResourceHandler::OnPluginsLoaded(
     BufferedResourceHandler* handler) {
-  g_browser_process->io_thread()->message_loop()->PostTask(FROM_HERE,
-      NewRunnableMethod(handler, &BufferedResourceHandler::OnPluginsLoaded));
+  handler->wait_for_plugins_ = false;
+  if (handler->request_) {
+    ResourceDispatcherHostRequestInfo* info =
+        ResourceDispatcherHost::InfoForRequest(handler->request_);
+    handler->host_->PauseRequest(info->child_id(), info->request_id(), false);
+    if (!handler->CompleteResponseStarted(info->request_id(), false))
+      handler->host_->CancelRequest(
+          info->child_id(), info->request_id(), false);
+  }
+  handler->Release();
 }
-
-void BufferedResourceHandler::OnPluginsLoaded() {
-  wait_for_plugins_ = false;
-  if (request_) {
-    ResourceDispatcherHostRequestInfo* info =
-        ResourceDispatcherHost::InfoForRequest(request_);
-    host_->PauseRequest(info->child_id(), info->request_id(), false);
-    if (!CompleteResponseStarted(info->request_id(), false))
-      host_->CancelRequest(info->child_id(), info->request_id(), false);
-  }
-  Release();
-}