Switch IPC::ChannelProxy to use MessageLoopProxy instead of MessageLoop. This allows us to remove usage of the IOThread object, and generally makes IPC::ChannelProxy more robust for future uses.

Review URL: http://codereview.chromium.org/6901146

git-svn-id: svn://svn.chromium.org/chrome/trunk/src@83741 0039d316-1c4b-4281-b951-d872f2087c98

41 files changed, 110 insertions, 99 deletions

diff --git a/base/threading/thread.h b/base/threading/thread.h
index 034cb7d..9a181c0 100644
--- a/base/threading/thread.h
+++ b/base/threading/thread.h
@@ -112,7 +112,7 @@ class BASE_API Thread : PlatformThread::Delegate {
   // this will return NULL. Callers can hold on to this even after the thread
   // is gone.
   // TODO(sanjeevr): Look into merging MessageLoop and MessageLoopProxy.
-  scoped_refptr<MessageLoopProxy> message_loop_proxy() {
+  scoped_refptr<MessageLoopProxy> message_loop_proxy() const {
     return message_loop_proxy_;
   }
 
diff --git a/chrome/browser/automation/automation_provider.cc b/chrome/browser/automation/automation_provider.cc
index 4770701..5a86ca7 100644
--- a/chrome/browser/automation/automation_provider.cc
+++ b/chrome/browser/automation/automation_provider.cc
@@ -55,7 +55,6 @@
 #include "chrome/browser/extensions/extension_tabs_module.h"
 #include "chrome/browser/extensions/extension_toolbar_model.h"
 #include "chrome/browser/extensions/user_script_master.h"
-#include "chrome/browser/io_thread.h"
 #include "chrome/browser/net/url_request_mock_util.h"
 #include "chrome/browser/platform_util.h"
 #include "chrome/browser/prefs/pref_service.h"
@@ -166,7 +165,7 @@ bool AutomationProvider::InitializeChannel(const std::string& channel_id) {
       use_named_interface ? IPC::Channel::MODE_NAMED_SERVER
                           : IPC::Channel::MODE_CLIENT,
       this,
-      g_browser_process->io_thread()->message_loop(),
+      BrowserThread::GetMessageLoopProxyForThread(BrowserThread::IO),
       true, g_browser_process->shutdown_event()));
   channel_->AddFilter(automation_resource_message_filter_);
 
diff --git a/chrome/browser/service/service_process_control.cc b/chrome/browser/service/service_process_control.cc
index 6bcbabb..135d832 100644
--- a/chrome/browser/service/service_process_control.cc
+++ b/chrome/browser/service/service_process_control.cc
@@ -11,7 +11,6 @@
 #include "base/threading/thread.h"
 #include "base/threading/thread_restrictions.h"
 #include "chrome/browser/browser_process.h"
-#include "chrome/browser/io_thread.h"
 #include "chrome/browser/upgrade_detector.h"
 #include "chrome/common/chrome_switches.h"
 #include "chrome/common/service_messages.h"
@@ -43,15 +42,13 @@ void ServiceProcessControl::ConnectInternal() {
 
   // Actually going to connect.
   VLOG(1) << "Connecting to Service Process IPC Server";
-  // Run the IPC channel on the shared IO thread.
-  base::Thread* io_thread = g_browser_process->io_thread();
 
   // TODO(hclam): Handle error connecting to channel.
   const IPC::ChannelHandle channel_id = GetServiceProcessChannel();
-  channel_.reset(
-      new IPC::SyncChannel(channel_id, IPC::Channel::MODE_NAMED_CLIENT, this,
-                           io_thread->message_loop(), true,
-                           g_browser_process->shutdown_event()));
+  channel_.reset(new IPC::SyncChannel(
+      channel_id, IPC::Channel::MODE_NAMED_CLIENT, this,
+      BrowserThread::GetMessageLoopProxyForThread(BrowserThread::IO), true,
+      g_browser_process->shutdown_event()));
 }
 
 void ServiceProcessControl::RunConnectDoneTasks() {
diff --git a/chrome/renderer/devtools_agent_filter.h b/chrome/renderer/devtools_agent_filter.h
index a02443a..efe6280 100644
--- a/chrome/renderer/devtools_agent_filter.h
+++ b/chrome/renderer/devtools_agent_filter.h
@@ -10,6 +10,7 @@
 
 #include "ipc/ipc_channel_proxy.h"
 
+class MessageLoop;
 struct DevToolsMessageData;
 
 // DevToolsAgentFilter is registered as an IPC filter in order to be able to
diff --git a/chrome/service/service_ipc_server.cc b/chrome/service/service_ipc_server.cc
index 267a1a6..ffab169 100644
--- a/chrome/service/service_ipc_server.cc
+++ b/chrome/service/service_ipc_server.cc
@@ -27,7 +27,7 @@ void ServiceIPCServer::CreateChannel() {
   channel_.reset(NULL); // Tear down the existing channel, if any.
   channel_.reset(new IPC::SyncChannel(channel_handle_,
       IPC::Channel::MODE_NAMED_SERVER, this,
-      g_service_process->io_thread()->message_loop(), true,
+      g_service_process->io_thread()->message_loop_proxy(), true,
       g_service_process->shutdown_event()));
   DCHECK(sync_message_filter_.get());
   channel_->AddFilter(sync_message_filter_.get());
diff --git a/chrome/test/automation/automation_proxy.cc b/chrome/test/automation/automation_proxy.cc
index f6edd40..dc00fbe 100644
--- a/chrome/test/automation/automation_proxy.cc
+++ b/chrome/test/automation/automation_proxy.cc
@@ -157,7 +157,7 @@ void AutomationProxy::InitializeChannel(const std::string& channel_id,
     use_named_interface ? IPC::Channel::MODE_NAMED_CLIENT
                         : IPC::Channel::MODE_SERVER,
     this,  // we are the listener
-    thread_->message_loop(),
+    thread_->message_loop_proxy(),
     true,
     shutdown_event_.get()));
   channel_->AddFilter(new AutomationMessageFilter(this));
diff --git a/content/browser/DEPS b/content/browser/DEPS
index d5c8522..1098153 100644
--- a/content/browser/DEPS
+++ b/content/browser/DEPS
@@ -57,8 +57,6 @@ include_rules = [
   "+chrome/browser/history/history.h",

   "+chrome/browser/history/history_types.h",

 

-  "+chrome/browser/io_thread.h",

-

   "+chrome/browser/load_from_memory_cache_details.h",

   "+chrome/browser/load_notification_details.h",

 

diff --git a/content/browser/gpu_process_host_ui_shim.cc b/content/browser/gpu_process_host_ui_shim.cc
index 73a9531..d553e78 100644
--- a/content/browser/gpu_process_host_ui_shim.cc
+++ b/content/browser/gpu_process_host_ui_shim.cc
@@ -8,7 +8,6 @@
 #include "base/id_map.h"
 #include "base/process_util.h"
 #include "chrome/browser/browser_process.h"
-#include "chrome/browser/io_thread.h"
 #include "content/browser/browser_thread.h"
 #include "content/browser/gpu_data_manager.h"
 #include "content/browser/gpu_process_host.h"
@@ -117,7 +116,7 @@ GpuProcessHostUIShim::GpuProcessHostUIShim(int host_id)
     gpu_channel_manager_ = new GpuChannelManager(
         ui_thread_sender_,
         NULL,
-        g_browser_process->io_thread()->message_loop(),
+        BrowserThread::GetMessageLoopProxyForThread(BrowserThread::IO),
         g_browser_process->shutdown_event());
   }
 }
diff --git a/content/browser/renderer_host/browser_render_process_host.cc b/content/browser/renderer_host/browser_render_process_host.cc
index ee0e253..406e7fd 100644
--- a/content/browser/renderer_host/browser_render_process_host.cc
+++ b/content/browser/renderer_host/browser_render_process_host.cc
@@ -28,7 +28,6 @@
 #include "base/threading/thread_restrictions.h"
 #include "chrome/browser/browser_process.h"
 #include "chrome/browser/history/history.h"
-#include "chrome/browser/io_thread.h"
 #include "chrome/browser/net/resolve_proxy_msg_helper.h"
 #include "chrome/browser/platform_util.h"
 #include "chrome/browser/profiles/profile.h"
@@ -253,9 +252,6 @@ bool BrowserRenderProcessHost::Init(
   // content, e.g. if an extension calls window.open.
   extension_process_ = extension_process_ || is_extensions_process;
 
-  // run the IPC channel on the shared IO thread.
-  base::Thread* io_thread = g_browser_process->io_thread();
-
   CommandLine::StringType renderer_prefix;
 #if defined(OS_POSIX)
   // A command prefix is something prepended to the command line of the spawned
@@ -275,10 +271,10 @@ bool BrowserRenderProcessHost::Init(
   // Setup the IPC channel.
   const std::string channel_id =
       ChildProcessInfo::GenerateRandomChannelID(this);
-  channel_.reset(
-      new IPC::SyncChannel(channel_id, IPC::Channel::MODE_SERVER, this,
-                           io_thread->message_loop(), true,
-                           g_browser_process->shutdown_event()));
+  channel_.reset(new IPC::SyncChannel(
+      channel_id, IPC::Channel::MODE_SERVER, this,
+      BrowserThread::GetMessageLoopProxyForThread(BrowserThread::IO), true,
+      g_browser_process->shutdown_event()));
   // As a preventive mesure, we DCHECK if someone sends a synchronous message
   // with no time-out, which in the context of the browser process we should not
   // be doing.
diff --git a/content/common/child_process.h b/content/common/child_process.h
index 4c5dc67..e3786ae 100644
--- a/content/common/child_process.h
+++ b/content/common/child_process.h
@@ -30,6 +30,9 @@ class ChildProcess {
   void set_main_thread(ChildThread* thread);
 
   MessageLoop* io_message_loop() { return io_thread_.message_loop(); }
+  base::MessageLoopProxy* io_message_loop_proxy() {
+    return io_thread_.message_loop_proxy();
+  }
 
   // A global event object that is signalled when the main thread's message
   // loop exits.  This gives background threads a way to observe the main
diff --git a/content/common/child_thread.cc b/content/common/child_thread.cc
index 92d2cca..9aea6a1e 100644
--- a/content/common/child_thread.cc
+++ b/content/common/child_thread.cc
@@ -45,7 +45,7 @@ void ChildThread::Init() {
 
   channel_.reset(new IPC::SyncChannel(channel_name_,
       IPC::Channel::MODE_CLIENT, this,
-      ChildProcess::current()->io_message_loop(), true,
+      ChildProcess::current()->io_message_loop_proxy(), true,
       ChildProcess::current()->GetShutDownEvent()));
 #ifdef IPC_MESSAGE_LOG_ENABLED
   IPC::Logging::GetInstance()->SetIPCSender(this);
diff --git a/content/common/gpu/gpu_channel.cc b/content/common/gpu/gpu_channel.cc
index 5d346ad..a922d0c 100644
--- a/content/common/gpu/gpu_channel.cc
+++ b/content/common/gpu/gpu_channel.cc
@@ -303,7 +303,7 @@ void GpuChannel::OnCreateTransportTexture(int32 context_route_id,
  #endif
  }
 
-bool GpuChannel::Init(MessageLoop* io_message_loop,
+bool GpuChannel::Init(base::MessageLoopProxy* io_message_loop,
                       base::WaitableEvent* shutdown_event) {
   // Check whether we're already initialized.
   if (channel_.get())
diff --git a/content/common/gpu/gpu_channel.h b/content/common/gpu/gpu_channel.h
index 0b35666..dafd53e 100644
--- a/content/common/gpu/gpu_channel.h
+++ b/content/common/gpu/gpu_channel.h
@@ -23,10 +23,10 @@
 class GpuChannelManager;
 struct GPUCreateCommandBufferConfig;
 class GpuWatchdog;
-class MessageLoop;
 class TransportTexture;
 	 
 namespace base {
+class MessageLoopProxy;
 class WaitableEvent;
 }
 
@@ -42,7 +42,8 @@ class GpuChannel : public IPC::Channel::Listener,
              int renderer_id);
   virtual ~GpuChannel();
 
-  bool Init(MessageLoop* io_message_loop, base::WaitableEvent* shutdown_event);
+  bool Init(base::MessageLoopProxy* io_message_loop,
+            base::WaitableEvent* shutdown_event);
 
   // Get the GpuChannelManager that owns this channel.
   GpuChannelManager* gpu_channel_manager() const {
diff --git a/content/common/gpu/gpu_channel_manager.cc b/content/common/gpu/gpu_channel_manager.cc
index 842dda2..d772f48 100644
--- a/content/common/gpu/gpu_channel_manager.cc
+++ b/content/common/gpu/gpu_channel_manager.cc
@@ -19,7 +19,7 @@
 
 GpuChannelManager::GpuChannelManager(IPC::Message::Sender* browser_channel,
                                      GpuWatchdog* watchdog,
-                                     MessageLoop* io_message_loop,
+                                     base::MessageLoopProxy* io_message_loop,
                                      base::WaitableEvent* shutdown_event)
     : ALLOW_THIS_IN_INITIALIZER_LIST(method_factory_(this)),
       io_message_loop_(io_message_loop),
diff --git a/content/common/gpu/gpu_channel_manager.h b/content/common/gpu/gpu_channel_manager.h
index 351df3e..f031f76e 100644
--- a/content/common/gpu/gpu_channel_manager.h
+++ b/content/common/gpu/gpu_channel_manager.h
@@ -13,6 +13,7 @@
 #include "base/command_line.h"
 #include "base/memory/ref_counted.h"
 #include "base/memory/scoped_ptr.h"
+#include "base/message_loop_proxy.h"
 #include "base/time.h"
 #include "build/build_config.h"
 #include "content/common/child_thread.h"
@@ -44,7 +45,7 @@ class GpuChannelManager : public IPC::Channel::Listener,
  public:
   GpuChannelManager(IPC::Message::Sender* browser_channel,
                     GpuWatchdog* watchdog,
-                    MessageLoop* io_message_loop,
+                    base::MessageLoopProxy* io_message_loop,
                     base::WaitableEvent* shutdown_event);
   ~GpuChannelManager();
 
@@ -82,7 +83,7 @@ class GpuChannelManager : public IPC::Channel::Listener,
 
   void OnLoseAllContexts();
 
-  MessageLoop* io_message_loop_;
+  scoped_refptr<base::MessageLoopProxy> io_message_loop_;
   base::WaitableEvent* shutdown_event_;
 
   // Either an IPC channel to the browser or, if the GpuChannelManager is
diff --git a/content/common/pepper_plugin_registry.cc b/content/common/pepper_plugin_registry.cc
index b91e701..c8b1c78 100644
--- a/content/common/pepper_plugin_registry.cc
+++ b/content/common/pepper_plugin_registry.cc
@@ -219,10 +219,10 @@ PepperPluginRegistry::PepperPluginRegistry() {
   }
 }
 
-MessageLoop* PepperPluginRegistry::GetIPCMessageLoop() {
+base::MessageLoopProxy* PepperPluginRegistry::GetIPCMessageLoop() {
   // This is called only in the renderer so we know we have a child process.
   DCHECK(ChildProcess::current()) << "Must be in the renderer.";
-  return ChildProcess::current()->io_message_loop();
+  return ChildProcess::current()->io_message_loop_proxy();
 }
 
 base::WaitableEvent* PepperPluginRegistry::GetShutdownEvent() {
diff --git a/content/common/pepper_plugin_registry.h b/content/common/pepper_plugin_registry.h
index 22de281..7dd9038 100644
--- a/content/common/pepper_plugin_registry.h
+++ b/content/common/pepper_plugin_registry.h
@@ -97,7 +97,7 @@ class PepperPluginRegistry
   PepperPluginRegistry();
 
   // Dispatcher::Delegate implementation.
-  virtual MessageLoop* GetIPCMessageLoop();
+  virtual base::MessageLoopProxy* GetIPCMessageLoop();
   virtual base::WaitableEvent* GetShutdownEvent();
   virtual std::set<PP_Instance>* GetGloballySeenInstanceIDSet();
 
diff --git a/content/gpu/gpu_child_thread.cc b/content/gpu/gpu_child_thread.cc
index e3b90da..14bd90b 100644
--- a/content/gpu/gpu_child_thread.cc
+++ b/content/gpu/gpu_child_thread.cc
@@ -193,7 +193,7 @@ void GpuChildThread::OnInitialize() {
   gpu_channel_manager_.reset(new GpuChannelManager(
       this,
       watchdog_thread_,
-      ChildProcess::current()->io_message_loop(),
+      ChildProcess::current()->io_message_loop_proxy(),
       ChildProcess::current()->GetShutDownEvent()));
 
   // Ensure the browser process receives the GPU info before a reply to any
diff --git a/content/plugin/plugin_channel.cc b/content/plugin/plugin_channel.cc
index 9e2c2ce..cd2e99f 100644
--- a/content/plugin/plugin_channel.cc
+++ b/content/plugin/plugin_channel.cc
@@ -136,8 +136,8 @@ class PluginChannel::MessageFilter : public IPC::ChannelProxy::MessageFilter {
   IPC::Channel* channel_;
 };
 
-PluginChannel* PluginChannel::GetPluginChannel(int renderer_id,
-                                               MessageLoop* ipc_message_loop) {
+PluginChannel* PluginChannel::GetPluginChannel(
+    int renderer_id, base::MessageLoopProxy* ipc_message_loop) {
   // Map renderer ID to a (single) channel to that process.
   std::string channel_key = StringPrintf(
       "%d.r%d", base::GetCurrentProcId(), renderer_id);
@@ -323,7 +323,8 @@ void PluginChannel::CleanUp() {
   plugin_stubs_.clear();
 }
 
-bool PluginChannel::Init(MessageLoop* ipc_message_loop, bool create_pipe_now) {
+bool PluginChannel::Init(base::MessageLoopProxy* ipc_message_loop,
+                         bool create_pipe_now) {
   if (!PluginChannelBase::Init(ipc_message_loop, create_pipe_now))
     return false;
 
diff --git a/content/plugin/plugin_channel.h b/content/plugin/plugin_channel.h
index 50b2054..b0edd9d 100644
--- a/content/plugin/plugin_channel.h
+++ b/content/plugin/plugin_channel.h
@@ -25,8 +25,8 @@ class PluginChannel : public PluginChannelBase {
   // Get a new PluginChannel object for the current process to talk to the
   // given renderer process. The renderer ID is an opaque unique ID generated
   // by the browser.
-  static PluginChannel* GetPluginChannel(int renderer_id,
-                                         MessageLoop* ipc_message_loop);
+  static PluginChannel* GetPluginChannel(
+      int renderer_id, base::MessageLoopProxy* ipc_message_loop);
 
   // Send a message to all renderers that the process is going to shutdown.
   static void NotifyRenderersOfPendingShutdown();
@@ -62,7 +62,8 @@ class PluginChannel : public PluginChannelBase {
   virtual void CleanUp();
 
   // Overrides PluginChannelBase::Init.
-  virtual bool Init(MessageLoop* ipc_message_loop, bool create_pipe_now);
+  virtual bool Init(base::MessageLoopProxy* ipc_message_loop,
+                   bool create_pipe_now);
 
  private:
   class MessageFilter;
diff --git a/content/plugin/plugin_channel_base.cc b/content/plugin/plugin_channel_base.cc
index d78d48c..3b1aa4c 100644
--- a/content/plugin/plugin_channel_base.cc
+++ b/content/plugin/plugin_channel_base.cc
@@ -29,7 +29,7 @@ static int next_pipe_id = 0;
 
 PluginChannelBase* PluginChannelBase::GetChannel(
     const IPC::ChannelHandle& channel_handle, IPC::Channel::Mode mode,
-    PluginChannelFactory factory, MessageLoop* ipc_message_loop,
+    PluginChannelFactory factory, base::MessageLoopProxy* ipc_message_loop,
     bool create_pipe_now) {
   scoped_refptr<PluginChannelBase> channel;
   std::string channel_key = channel_handle.name;
@@ -112,7 +112,7 @@ NPObjectBase* PluginChannelBase::GetNPObjectListenerForRoute(int route_id) {
   return iter->second;
 }
 
-bool PluginChannelBase::Init(MessageLoop* ipc_message_loop,
+bool PluginChannelBase::Init(base::MessageLoopProxy* ipc_message_loop,
                              bool create_pipe_now) {
   channel_.reset(new IPC::SyncChannel(
       channel_handle_, mode_, this, ipc_message_loop, create_pipe_now,
diff --git a/content/plugin/plugin_channel_base.h b/content/plugin/plugin_channel_base.h
index 7062904f..fb69980 100644
--- a/content/plugin/plugin_channel_base.h
+++ b/content/plugin/plugin_channel_base.h
@@ -12,13 +12,16 @@
 #include "base/hash_tables.h"
 #include "base/memory/ref_counted.h"
 #include "base/memory/scoped_ptr.h"
-#include "base/message_loop.h"
 #include "content/common/message_router.h"
 #include "content/plugin/npobject_base.h"
 #include "ipc/ipc_channel_handle.h"
 #include "ipc/ipc_sync_channel.h"
 #include "ui/gfx/native_widget_types.h"
 
+namespace base {
+class MessageLoopProxy;
+}
+
 // Encapsulates an IPC channel between a renderer and a plugin process.
 class PluginChannelBase : public IPC::Channel::Listener,
                           public IPC::Message::Sender,
@@ -77,7 +80,7 @@ class PluginChannelBase : public IPC::Channel::Listener,
   // on the channel and its ref count is 0, the object deletes itself.
   static PluginChannelBase* GetChannel(
       const IPC::ChannelHandle& channel_handle, IPC::Channel::Mode mode,
-      PluginChannelFactory factory, MessageLoop* ipc_message_loop,
+      PluginChannelFactory factory, base::MessageLoopProxy* ipc_message_loop,
       bool create_pipe_now);
 
   // Sends a message to all instances.
@@ -100,7 +103,8 @@ class PluginChannelBase : public IPC::Channel::Listener,
     send_unblocking_only_during_unblock_dispatch_ = true;
   }
 
-  virtual bool Init(MessageLoop* ipc_message_loop, bool create_pipe_now);
+  virtual bool Init(base::MessageLoopProxy* ipc_message_loop,
+                    bool create_pipe_now);
 
   scoped_ptr<IPC::SyncChannel> channel_;
 
diff --git a/content/plugin/plugin_thread.cc b/content/plugin/plugin_thread.cc
index e0ce6d1..de08668 100644
--- a/content/plugin/plugin_thread.cc
+++ b/content/plugin/plugin_thread.cc
@@ -121,7 +121,7 @@ bool PluginThread::OnControlMessageReceived(const IPC::Message& msg) {
 void PluginThread::OnCreateChannel(int renderer_id,
                                    bool incognito) {
   scoped_refptr<PluginChannel> channel(PluginChannel::GetPluginChannel(
-      renderer_id, ChildProcess::current()->io_message_loop()));
+      renderer_id, ChildProcess::current()->io_message_loop_proxy()));
   IPC::ChannelHandle channel_handle;
   if (channel.get()) {
     channel_handle.name = channel->channel_handle().name;
diff --git a/content/ppapi_plugin/ppapi_thread.cc b/content/ppapi_plugin/ppapi_thread.cc
index 70bf573f..c2070b6 100644
--- a/content/ppapi_plugin/ppapi_thread.cc
+++ b/content/ppapi_plugin/ppapi_thread.cc
@@ -58,8 +58,8 @@ bool PpapiThread::OnMessageReceived(const IPC::Message& msg) {
   return true;
 }
 
-MessageLoop* PpapiThread::GetIPCMessageLoop() {
-  return ChildProcess::current()->io_message_loop();
+base::MessageLoopProxy* PpapiThread::GetIPCMessageLoop() {
+  return ChildProcess::current()->io_message_loop_proxy();
 }
 
 base::WaitableEvent* PpapiThread::GetShutdownEvent() {
diff --git a/content/ppapi_plugin/ppapi_thread.h b/content/ppapi_plugin/ppapi_thread.h
index ea8593c..50bda11 100644
--- a/content/ppapi_plugin/ppapi_thread.h
+++ b/content/ppapi_plugin/ppapi_thread.h
@@ -33,7 +33,7 @@ class PpapiThread : public ChildThread,
   virtual bool OnMessageReceived(const IPC::Message& msg);
 
   // Dispatcher::Delegate implementation.
-  virtual MessageLoop* GetIPCMessageLoop();
+  virtual base::MessageLoopProxy* GetIPCMessageLoop();
   virtual base::WaitableEvent* GetShutdownEvent();
   virtual std::set<PP_Instance>* GetGloballySeenInstanceIDSet();
 
diff --git a/content/renderer/audio_input_message_filter.h b/content/renderer/audio_input_message_filter.h
index ea927e6..f28ed6d 100644
--- a/content/renderer/audio_input_message_filter.h
+++ b/content/renderer/audio_input_message_filter.h
@@ -19,6 +19,8 @@
 #include "ipc/ipc_channel_proxy.h"
 #include "media/audio/audio_buffers_state.h"
 
+class MessageLoop;
+
 class AudioInputMessageFilter : public IPC::ChannelProxy::MessageFilter {
  public:
   class Delegate {
diff --git a/content/renderer/audio_message_filter.h b/content/renderer/audio_message_filter.h
index 806dd60..316ac1b 100644
--- a/content/renderer/audio_message_filter.h
+++ b/content/renderer/audio_message_filter.h
@@ -19,6 +19,8 @@
 #include "ipc/ipc_channel_proxy.h"
 #include "media/audio/audio_buffers_state.h"
 
+class MessageLoop;
+
 namespace base {
 class Time;
 }
diff --git a/content/renderer/gpu_channel_host.cc b/content/renderer/gpu_channel_host.cc
index 401e006..c73d32c 100644
--- a/content/renderer/gpu_channel_host.cc
+++ b/content/renderer/gpu_channel_host.cc
@@ -27,7 +27,7 @@ void GpuChannelHost::Connect(
   // Open a channel to the GPU process.
   channel_.reset(new IPC::SyncChannel(
       channel_handle, IPC::Channel::MODE_CLIENT, this,
-      ChildProcess::current()->io_message_loop(), true,
+      ChildProcess::current()->io_message_loop_proxy(), true,
       ChildProcess::current()->GetShutDownEvent()));
 
   // It is safe to send IPC messages before the channel completes the connection
diff --git a/content/renderer/plugin_channel_host.cc b/content/renderer/plugin_channel_host.cc
index 3d4993c..7fedc84 100644
--- a/content/renderer/plugin_channel_host.cc
+++ b/content/renderer/plugin_channel_host.cc
@@ -68,7 +68,8 @@ void PluginChannelHost::SetListening(bool flag) {
 }
 
 PluginChannelHost* PluginChannelHost::GetPluginChannelHost(
-    const IPC::ChannelHandle& channel_handle, MessageLoop* ipc_message_loop) {
+    const IPC::ChannelHandle& channel_handle,
+    base::MessageLoopProxy* ipc_message_loop) {
   PluginChannelHost* result =
       static_cast<PluginChannelHost*>(PluginChannelBase::GetChannel(
           channel_handle,
@@ -85,7 +86,7 @@ PluginChannelHost::PluginChannelHost() : expecting_shutdown_(false) {
 PluginChannelHost::~PluginChannelHost() {
 }
 
-bool PluginChannelHost::Init(MessageLoop* ipc_message_loop,
+bool PluginChannelHost::Init(base::MessageLoopProxy* ipc_message_loop,
                              bool create_pipe_now) {
   bool ret = PluginChannelBase::Init(ipc_message_loop, create_pipe_now);
   is_listening_filter_ = new IsListeningFilter;
diff --git a/content/renderer/plugin_channel_host.h b/content/renderer/plugin_channel_host.h
index 3e84412..ec6bfed 100644
--- a/content/renderer/plugin_channel_host.h
+++ b/content/renderer/plugin_channel_host.h
@@ -18,9 +18,11 @@ class NPObjectBase;
 class PluginChannelHost : public PluginChannelBase {
  public:
   static PluginChannelHost* GetPluginChannelHost(
-      const IPC::ChannelHandle& channel_handle, MessageLoop* ipc_message_loop);
+      const IPC::ChannelHandle& channel_handle,
+      base::MessageLoopProxy* ipc_message_loop);
 
-  virtual bool Init(MessageLoop* ipc_message_loop, bool create_pipe_now);
+  virtual bool Init(base::MessageLoopProxy* ipc_message_loop,
+                    bool create_pipe_now);
 
   virtual int GenerateRouteID();
 
diff --git a/content/renderer/webplugin_delegate_proxy.cc b/content/renderer/webplugin_delegate_proxy.cc
index e4575cf..0667ef4 100644
--- a/content/renderer/webplugin_delegate_proxy.cc
+++ b/content/renderer/webplugin_delegate_proxy.cc
@@ -298,7 +298,7 @@ bool WebPluginDelegateProxy::Initialize(
 
   scoped_refptr<PluginChannelHost> channel_host(
       PluginChannelHost::GetPluginChannelHost(
-          channel_handle, ChildProcess::current()->io_message_loop()));
+          channel_handle, ChildProcess::current()->io_message_loop_proxy()));
   if (!channel_host.get())
     return false;
 
diff --git a/ipc/ipc_channel_proxy.cc b/ipc/ipc_channel_proxy.cc
index c219829..8f981f4 100644
--- a/ipc/ipc_channel_proxy.cc
+++ b/ipc/ipc_channel_proxy.cc
@@ -4,7 +4,6 @@
 
 #include "base/memory/ref_counted.h"
 #include "base/memory/scoped_ptr.h"
-#include "base/message_loop.h"
 #include "ipc/ipc_channel_proxy.h"
 #include "ipc/ipc_logging.h"
 #include "ipc/ipc_message_utils.h"
@@ -60,14 +59,17 @@ void ChannelProxy::MessageFilter::OnDestruct() const {
 //------------------------------------------------------------------------------
 
 ChannelProxy::Context::Context(Channel::Listener* listener,
-                               MessageLoop* ipc_message_loop)
-    : listener_message_loop_(MessageLoop::current()),
+                               base::MessageLoopProxy* ipc_message_loop)
+    : listener_message_loop_(base::MessageLoopProxy::CreateForCurrentThread()),
       listener_(listener),
       ipc_message_loop_(ipc_message_loop),
       peer_pid_(0),
       channel_connected_called_(false) {
 }
 
+ChannelProxy::Context::~Context() {
+}
+
 void ChannelProxy::Context::CreateChannel(const IPC::ChannelHandle& handle,
                                           const Channel::Mode& mode) {
   DCHECK(channel_.get() == NULL);
@@ -280,14 +282,14 @@ void ChannelProxy::Context::OnDispatchError() {
 ChannelProxy::ChannelProxy(const IPC::ChannelHandle& channel_handle,
                            Channel::Mode mode,
                            Channel::Listener* listener,
-                           MessageLoop* ipc_thread)
+                           base::MessageLoopProxy* ipc_thread)
     : context_(new Context(listener, ipc_thread)) {
   Init(channel_handle, mode, ipc_thread, true);
 }
 
 ChannelProxy::ChannelProxy(const IPC::ChannelHandle& channel_handle,
                            Channel::Mode mode,
-                           MessageLoop* ipc_thread,
+                           base::MessageLoopProxy* ipc_thread,
                            Context* context,
                            bool create_pipe_now)
     : context_(context) {
@@ -299,7 +301,8 @@ ChannelProxy::~ChannelProxy() {
 }
 
 void ChannelProxy::Init(const IPC::ChannelHandle& channel_handle,
-                        Channel::Mode mode, MessageLoop* ipc_thread_loop,
+                        Channel::Mode mode,
+                        base::MessageLoopProxy* ipc_thread_loop,
                         bool create_pipe_now) {
 #if defined(OS_POSIX)
   // When we are creating a server on POSIX, we need its file descriptor
diff --git a/ipc/ipc_channel_proxy.h b/ipc/ipc_channel_proxy.h
index 0c0176f..2b1dea8 100644
--- a/ipc/ipc_channel_proxy.h
+++ b/ipc/ipc_channel_proxy.h
@@ -2,20 +2,19 @@
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
-#ifndef IPC_IPC_CHANNEL_PROXY_H__
-#define IPC_IPC_CHANNEL_PROXY_H__
+#ifndef IPC_IPC_CHANNEL_PROXY_H_
+#define IPC_IPC_CHANNEL_PROXY_H_
 #pragma once
 
 #include <vector>
 
 #include "base/memory/ref_counted.h"
 #include "base/memory/scoped_ptr.h"
+#include "base/message_loop_proxy.h"
 #include "base/synchronization/lock.h"
 #include "ipc/ipc_channel.h"
 #include "ipc/ipc_channel_handle.h"
 
-class MessageLoop;
-
 namespace IPC {
 
 class SendTask;
@@ -110,7 +109,7 @@ class ChannelProxy : public Message::Sender {
   ChannelProxy(const IPC::ChannelHandle& channel_handle,
                Channel::Mode mode,
                Channel::Listener* listener,
-               MessageLoop* ipc_thread_loop);
+               base::MessageLoopProxy* ipc_thread_loop);
 
   virtual ~ChannelProxy();
 
@@ -156,7 +155,7 @@ class ChannelProxy : public Message::Sender {
   // immediately.  Otherwise it's created on the IO thread.
   ChannelProxy(const IPC::ChannelHandle& channel_handle,
                Channel::Mode mode,
-               MessageLoop* ipc_thread_loop,
+               base::MessageLoopProxy* ipc_thread_loop,
                Context* context,
                bool create_pipe_now);
 
@@ -164,9 +163,11 @@ class ChannelProxy : public Message::Sender {
   class Context : public base::RefCountedThreadSafe<Context>,
                   public Channel::Listener {
    public:
-    Context(Channel::Listener* listener, MessageLoop* ipc_thread);
+    Context(Channel::Listener* listener, base::MessageLoopProxy* ipc_thread);
     void ClearIPCMessageLoop() { ipc_message_loop_ = NULL; }
-    MessageLoop* ipc_message_loop() const { return ipc_message_loop_; }
+    base::MessageLoopProxy* ipc_message_loop() const {
+      return ipc_message_loop_.get();
+    }
     const std::string& channel_id() const { return channel_id_; }
 
     // Dispatches a message on the listener thread.
@@ -174,7 +175,7 @@ class ChannelProxy : public Message::Sender {
 
    protected:
     friend class base::RefCountedThreadSafe<Context>;
-    virtual ~Context() { }
+    virtual ~Context();
 
     // IPC::Channel::Listener methods:
     virtual bool OnMessageReceived(const Message& message);
@@ -215,12 +216,12 @@ class ChannelProxy : public Message::Sender {
     void OnDispatchConnected();
     void OnDispatchError();
 
-    MessageLoop* listener_message_loop_;
+    scoped_refptr<base::MessageLoopProxy> listener_message_loop_;
     Channel::Listener* listener_;
 
     // List of filters.  This is only accessed on the IPC thread.
     std::vector<scoped_refptr<MessageFilter> > filters_;
-    MessageLoop* ipc_message_loop_;
+    scoped_refptr<base::MessageLoopProxy> ipc_message_loop_;
     scoped_ptr<Channel> channel_;
     std::string channel_id_;
     int peer_pid_;
@@ -239,7 +240,7 @@ class ChannelProxy : public Message::Sender {
   friend class SendTask;
 
   void Init(const IPC::ChannelHandle& channel_handle, Channel::Mode mode,
-            MessageLoop* ipc_thread_loop, bool create_pipe_now);
+            base::MessageLoopProxy* ipc_thread_loop, bool create_pipe_now);
 
   // By maintaining this indirection (ref-counted) to our internal state, we
   // can safely be destroyed while the background thread continues to do stuff
@@ -249,4 +250,4 @@ class ChannelProxy : public Message::Sender {
 
 }  // namespace IPC
 
-#endif  // IPC_IPC_CHANNEL_PROXY_H__
+#endif  // IPC_IPC_CHANNEL_PROXY_H_
diff --git a/ipc/ipc_sync_channel.cc b/ipc/ipc_sync_channel.cc
index 97e1c18..f3a6a47 100644
--- a/ipc/ipc_sync_channel.cc
+++ b/ipc/ipc_sync_channel.cc
@@ -6,7 +6,6 @@
 
 #include "base/lazy_instance.h"
 #include "base/logging.h"
-#include "base/message_loop.h"
 #include "base/threading/thread_local.h"
 #include "base/synchronization/waitable_event.h"
 #include "base/synchronization/waitable_event_watcher.h"
@@ -134,7 +133,9 @@ class SyncChannel::ReceivedSyncMsgQueue :
   }
 
   WaitableEvent* dispatch_event() { return &dispatch_event_; }
-  MessageLoop* listener_message_loop() { return listener_message_loop_; }
+  base::MessageLoopProxy* listener_message_loop() {
+    return listener_message_loop_;
+  }
 
   // Holds a pointer to the per-thread ReceivedSyncMsgQueue object.
   static base::LazyInstance<base::ThreadLocalPointer<ReceivedSyncMsgQueue> >
@@ -168,7 +169,7 @@ class SyncChannel::ReceivedSyncMsgQueue :
   // as manual reset.
   ReceivedSyncMsgQueue() :
       dispatch_event_(true, false),
-      listener_message_loop_(MessageLoop::current()),
+      listener_message_loop_(base::MessageLoopProxy::CreateForCurrentThread()),
       task_pending_(false),
       listener_count_(0),
       top_send_done_watcher_(NULL) {
@@ -192,7 +193,7 @@ class SyncChannel::ReceivedSyncMsgQueue :
   // sender needs its reply before it can reply to our original synchronous
   // message.
   WaitableEvent dispatch_event_;
-  MessageLoop* listener_message_loop_;
+  scoped_refptr<base::MessageLoopProxy> listener_message_loop_;
   base::Lock message_lock_;
   bool task_pending_;
   int listener_count_;
@@ -208,7 +209,7 @@ base::LazyInstance<base::ThreadLocalPointer<SyncChannel::ReceivedSyncMsgQueue> >
 
 SyncChannel::SyncContext::SyncContext(
     Channel::Listener* listener,
-    MessageLoop* ipc_thread,
+    base::MessageLoopProxy* ipc_thread,
     WaitableEvent* shutdown_event)
     : ChannelProxy::Context(listener, ipc_thread),
       received_sync_msgs_(ReceivedSyncMsgQueue::AddContext()),
@@ -371,7 +372,7 @@ SyncChannel::SyncChannel(
     const IPC::ChannelHandle& channel_handle,
     Channel::Mode mode,
     Channel::Listener* listener,
-    MessageLoop* ipc_message_loop,
+    base::MessageLoopProxy* ipc_message_loop,
     bool create_pipe_now,
     WaitableEvent* shutdown_event)
     : ChannelProxy(
diff --git a/ipc/ipc_sync_channel.h b/ipc/ipc_sync_channel.h
index 549c35d..8cea5a8 100644
--- a/ipc/ipc_sync_channel.h
+++ b/ipc/ipc_sync_channel.h
@@ -66,7 +66,7 @@ class SyncChannel : public ChannelProxy,
   SyncChannel(const IPC::ChannelHandle& channel_handle,
               Channel::Mode mode,
               Channel::Listener* listener,
-              MessageLoop* ipc_message_loop,
+              base::MessageLoopProxy* ipc_message_loop,
               bool create_pipe_now,
               base::WaitableEvent* shutdown_event);
   virtual ~SyncChannel();
@@ -101,7 +101,7 @@ class SyncChannel : public ChannelProxy,
                       public base::WaitableEventWatcher::Delegate {
    public:
     SyncContext(Channel::Listener* listener,
-                MessageLoop* ipc_thread,
+                base::MessageLoopProxy* ipc_thread,
                 base::WaitableEvent* shutdown_event);
 
     // Adds information about an outgoing sync message to the context so that
diff --git a/ipc/ipc_sync_channel_unittest.cc b/ipc/ipc_sync_channel_unittest.cc
index 6952aac..fe17c14 100644
--- a/ipc/ipc_sync_channel_unittest.cc
+++ b/ipc/ipc_sync_channel_unittest.cc
@@ -166,7 +166,7 @@ class Worker : public Channel::Listener, public Message::Sender {
     // Link ipc_thread_, listener_thread_ and channel_ altogether.
     StartThread(&ipc_thread_, MessageLoop::TYPE_IO);
     channel_.reset(new SyncChannel(
-        channel_name_, mode_, this, ipc_thread_.message_loop(), true,
+        channel_name_, mode_, this, ipc_thread_.message_loop_proxy(), true,
         &shutdown_event_));
     channel_created_->Signal();
     Run();
@@ -1250,7 +1250,7 @@ class RestrictedDispatchClient : public Worker {
 
     scoped_ptr<SyncChannel> non_restricted_channel(new SyncChannel(
         "non_restricted_channel", Channel::MODE_CLIENT, this,
-        ipc_thread().message_loop(), true, shutdown_event()));
+        ipc_thread().message_loop_proxy(), true, shutdown_event()));
 
     server_->ListenerThread()->message_loop()->PostTask(FROM_HERE,
         NewRunnableMethod(server_, &RestrictedDispatchServer::OnDoPing, 2));
diff --git a/ipc/ipc_tests.cc b/ipc/ipc_tests.cc
index 93276f4..d8e3aeb 100644
--- a/ipc/ipc_tests.cc
+++ b/ipc/ipc_tests.cc
@@ -251,7 +251,7 @@ TEST_F(IPCChannelTest, ChannelProxyTest) {
   {
     // setup IPC channel proxy
     IPC::ChannelProxy chan(kTestClientChannel, IPC::Channel::MODE_SERVER,
-                           &channel_listener, thread.message_loop());
+                           &channel_listener, thread.message_loop_proxy());
 
     channel_listener.Init(&chan);
 
diff --git a/ppapi/proxy/dispatcher.cc b/ppapi/proxy/dispatcher.cc
index f5d5668..b34ce48 100644
--- a/ppapi/proxy/dispatcher.cc
+++ b/ppapi/proxy/dispatcher.cc
@@ -250,7 +250,7 @@ const void* Dispatcher::GetLocalInterface(const char* interface_name) {
   return local_get_interface_(interface_name);
 }
 
-MessageLoop* Dispatcher::GetIPCMessageLoop() {
+base::MessageLoopProxy* Dispatcher::GetIPCMessageLoop() {
   return delegate()->GetIPCMessageLoop();
 }
 
diff --git a/ppapi/proxy/dispatcher.h b/ppapi/proxy/dispatcher.h
index 2d900b1..05f61d3 100644
--- a/ppapi/proxy/dispatcher.h
+++ b/ppapi/proxy/dispatcher.h
@@ -69,7 +69,7 @@ class Dispatcher : public ProxyChannel {
   // TODO(brettw) remove this. It's a hack to support the Flash
   // ModuleLocalThreadAdapter. When the thread stuff is sorted out, this
   // implementation detail should be hidden.
-  MessageLoop* GetIPCMessageLoop();
+  base::MessageLoopProxy* GetIPCMessageLoop();
 
   // Adds the given filter to the IO thread. Takes ownership of the pointer.
   // TODO(brettw) remove this. It's a hack to support the Flash
diff --git a/ppapi/proxy/ppb_flash_file_proxy.cc b/ppapi/proxy/ppb_flash_file_proxy.cc
index 8b55b4a..9e2aab66 100644
--- a/ppapi/proxy/ppb_flash_file_proxy.cc
+++ b/ppapi/proxy/ppb_flash_file_proxy.cc
@@ -9,7 +9,7 @@
 #include <vector>
 
 #include "base/logging.h"
-#include "base/message_loop.h"
+#include "base/message_loop_proxy.h"
 #include "base/synchronization/lock.h"
 #include "base/synchronization/waitable_event.h"
 #include "build/build_config.h"
@@ -111,10 +111,10 @@ class ModuleLocalThreadAdapter
 
   base::Lock lock_;
 
-  MessageLoop* main_thread_;
+  scoped_refptr<base::MessageLoopProxy> main_thread_;
 
   // Will be NULL before an instance routing is added.
-  MessageLoop* io_thread_;
+  scoped_refptr<base::MessageLoopProxy> io_thread_;
 
   typedef std::map<PP_Instance, Dispatcher*> InstanceToDispatcher;
   InstanceToDispatcher instance_to_dispatcher_;
@@ -188,8 +188,7 @@ bool ModuleLocalThreadAdapter::Filter::OnMessageReceived(
 }
 
 ModuleLocalThreadAdapter::ModuleLocalThreadAdapter()
-    : main_thread_(MessageLoop::current()),
-      io_thread_(NULL) {
+    : main_thread_(base::MessageLoopProxy::CreateForCurrentThread()) {
 }
 
 void ModuleLocalThreadAdapter::AddInstanceRouting(PP_Instance instance,
@@ -197,8 +196,8 @@ void ModuleLocalThreadAdapter::AddInstanceRouting(PP_Instance instance,
   base::AutoLock lock(lock_);
 
   // Now that we've had contact with a dispatcher, we can set up the IO thread.
-  DCHECK(MessageLoop::current() == main_thread_);
-  if (!io_thread_)
+  DCHECK(main_thread_->BelongsToCurrentThread());
+  if (!io_thread_.get())
     io_thread_ = dispatcher->GetIPCMessageLoop();
 
   // Set up the instance -> dispatcher routing.
@@ -275,7 +274,7 @@ bool ModuleLocalThreadAdapter::Send(PP_Instance instance, IPC::Message* msg) {
     dispatcher = found->second;
   }
 
-  if (MessageLoop::current() == main_thread_) {
+  if (main_thread_->BelongsToCurrentThread()) {
     // Easy case: We're on the same thread as the dispatcher, so we don't need
     // a lock to access it, and we can just use the normal sync channel stuff
     // to handle the message. Actually, we MUST use the normal sync channel
diff --git a/ppapi/proxy/proxy_channel.h b/ppapi/proxy/proxy_channel.h
index 8df6893..3dbb977 100644
--- a/ppapi/proxy/proxy_channel.h
+++ b/ppapi/proxy/proxy_channel.h
@@ -11,9 +11,8 @@
 #include "ipc/ipc_platform_file.h"
 #include "ipc/ipc_sync_channel.h"
 
-class MessageLoop;
-
 namespace base {
+class MessageLoopProxy;
 class WaitableEvent;
 }
 
@@ -34,7 +33,7 @@ class ProxyChannel : public IPC::Channel::Listener,
   class Delegate {
    public:
     // Returns the dedicated message loop for processing IPC requests.
-    virtual MessageLoop* GetIPCMessageLoop() = 0;
+    virtual base::MessageLoopProxy* GetIPCMessageLoop() = 0;
 
     // Returns the event object that becomes signalled when the main thread's
     // message loop exits.