Switch IPC::ChannelProxy to use MessageLoopProxy instead of MessageLoop. This allows us to remov...

ppapi/proxy/ppb_flash_file_proxy.cc

 // Copyright (c) 2011 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 "ppapi/proxy/ppb_flash_file_proxy.h"
 
 #include <map>
 #include <set>
 #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"
 #include "ipc/ipc_channel_proxy.h"
 #include "ipc/ipc_message.h"
 #include "ipc/ipc_sync_message.h"
 #include "ppapi/c/dev/pp_file_info_dev.h"
 #include "ppapi/c/pp_errors.h"
 #include "ppapi/c/private/ppb_flash_file.h"
 #include "ppapi/proxy/plugin_dispatcher.h"
@@ skipping 81 matching lines @@
   };
 
   virtual void SendFromIOThread(Dispatcher* dispatcher, IPC::Message* msg);
 
   // Internal version of OnModuleLocalMessageFailed which assumes the lock
   // is already held.
   void OnModuleLocalMessageFailedLocked(int message_id);
 
   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_;
 
   // The filters are owned by the channel.
   typedef std::map<Dispatcher*, Filter*> DispatcherToFilter;
   DispatcherToFilter dispatcher_to_filter_;
 
   // Tracks all messages with currently waiting threads. This does not own
   // the pointer, the pointer lifetime is managed by Send().
@@ skipping 53 matching lines @@
   if (g_module_local_thread_adapter->OnModuleLocalMessageReceived(message)) {
     // The message was consumed, this means we can remove the message ID from
     // the list of messages this channel is waiting on.
     pending_requests_for_filter_.erase(IPC::SyncMessage::GetMessageId(message));
     return true;
   }
   return false;
 }
 
 ModuleLocalThreadAdapter::ModuleLocalThreadAdapter()
-    : main_thread_(MessageLoop::current()),
-      io_thread_(NULL) {
+    : main_thread_(base::MessageLoopProxy::CreateForCurrentThread()) {
 }
 
 void ModuleLocalThreadAdapter::AddInstanceRouting(PP_Instance instance,
                                                   Dispatcher* dispatcher) {
   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(base::MessageLoopProxy::CreateForCurrentThread() == main_thread_);

[sanjeevr, 2011/05/02 17:27:37]

This should be main_thread_->BelongsToCurrentThread()

[jam, 2011/05/02 17:43:47]

Done.

+  if (!io_thread_.get())
     io_thread_ = dispatcher->GetIPCMessageLoop();
 
   // Set up the instance -> dispatcher routing.
   DCHECK(instance_to_dispatcher_.find(instance) ==
          instance_to_dispatcher_.end());
   instance_to_dispatcher_[instance] = dispatcher;
 
   DispatcherToFilter::iterator found_filter =
       dispatcher_to_filter_.find(dispatcher);
   if (found_filter == dispatcher_to_filter_.end()) {
@@ skipping 56 matching lines @@
     InstanceToDispatcher::iterator found =
         instance_to_dispatcher_.find(instance);
     if (found == instance_to_dispatcher_.end()) {
       NOTREACHED();
       delete msg;
       return false;
     }
     dispatcher = found->second;
   }
 
-  if (MessageLoop::current() == main_thread_) {
+  if (base::MessageLoopProxy::CreateForCurrentThread() == main_thread_) {

[sanjeevr, 2011/05/02 17:27:37]

Same here (and everywhere else where we replace the "MessageLoop::current() ==
foo" check)

[jam, 2011/05/02 17:43:47]

Done (didn't see any other uses).

     // 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
     // stuff since there may be incoming sync messages that need processing.
     // The code below doesn't handle any nested message loops.
     return dispatcher->Send(msg);
   }
 
   // Background thread case
   // ----------------------
@@ skipping 435 matching lines @@
 void PPB_Flash_File_FileRef_Proxy::OnMsgQueryFile(
     const HostResource& host_resource,
     PP_FileInfo_Dev* info,
     int32_t* result) {
   *result = ppb_flash_file_module_local_target()->
       QueryFile(host_resource.host_resource(), info);
 }
 
 }  // namespace proxy
 }  // namespace pp