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

ipc/ipc_sync_channel_unittest.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.
 //
 // Unit test for SyncChannel.
 
 #include "ipc/ipc_sync_channel.h"
 
 #include <string>
 #include <vector>
@@ skipping 148 matching lines @@
   }
 
   const base::Thread& ipc_thread() const { return ipc_thread_; }
 
  private:
   // Called on the listener thread to create the sync channel.
   void OnStart() {
     // 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();
   }
 
   void OnListenerThreadShutdown1(WaitableEvent* listener_event,
                                  WaitableEvent* ipc_event) {
     // SyncChannel needs to be destructed on the thread that it was created on.
     channel_.reset();
 
@@ skipping 1063 matching lines @@
         NewRunnableMethod(server_, &RestrictedDispatchServer::OnDoPing, 1));
     sent_ping_event_->Wait();
     Send(new SyncChannelTestMsg_NoArgs);
     if (ping_ == 1)
       ++*success_;
     else
       LOG(ERROR) << "Send failed to dispatch incoming message on same channel";
 
     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));
     sent_ping_event_->Wait();
     // Check that the incoming message is *not* dispatched when sending on the
     // non restricted channel.
     // TODO(piman): there is a possibility of a false positive race condition
     // here, if the message that was posted on the server-side end of the pipe
     // is not visible yet on the client side, but I don't know how to solve this
     // without hooking into the internals of SyncChannel. I haven't seen it in
@@ skipping 44 matching lines @@
       new RestrictedDispatchServer(&sent_ping_event);
   int success = 0;
   std::vector<Worker*> workers;
   workers.push_back(new NonRestrictedDispatchServer);
   workers.push_back(server);
   workers.push_back(
       new RestrictedDispatchClient(&sent_ping_event, server, &success));
   RunTest(workers);
   EXPECT_EQ(3, success);
 }