Use SingleThreadTaskRunner instead of MessageLoopProxy in remoting/host.

remoting/host/chromoting_host_unittest.cc

 // Copyright (c) 2012 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 "base/bind.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/message_loop_proxy.h"
 #include "remoting/jingle_glue/mock_objects.h"
 #include "remoting/host/capturer_fake.h"
 #include "remoting/host/chromoting_host.h"
@@ skipping 50 matching lines @@
 
 }  // namespace
 
 class ChromotingHostTest : public testing::Test {
  public:
   ChromotingHostTest() {
   }
 
   virtual void SetUp() OVERRIDE {
     message_loop_proxy_ = base::MessageLoopProxy::current();
-    ON_CALL(context_, main_message_loop())
-        .WillByDefault(Return(&message_loop_));
-    ON_CALL(context_, encode_message_loop())
-        .WillByDefault(Return(&message_loop_));
-    ON_CALL(context_, network_message_loop())
-        .WillByDefault(Return(message_loop_proxy_.get()));
-    ON_CALL(context_, ui_message_loop())
-        .WillByDefault(Return(message_loop_proxy_.get()));
-    EXPECT_CALL(context_, main_message_loop())
-        .Times(AnyNumber());
-    EXPECT_CALL(context_, encode_message_loop())
-        .Times(AnyNumber());
-    EXPECT_CALL(context_, network_message_loop())
-        .Times(AnyNumber());
-    EXPECT_CALL(context_, ui_message_loop())
-        .Times(AnyNumber());
+
+    EXPECT_CALL(context_, ui_task_runner())
+        .Times(AnyNumber())
+        .WillRepeatedly(Return(message_loop_proxy_.get()));
+    EXPECT_CALL(context_, capture_task_runner())
+        .Times(AnyNumber())
+        .WillRepeatedly(Return(message_loop_proxy_.get()));
+    EXPECT_CALL(context_, encode_task_runner())
+        .Times(AnyNumber())
+        .WillRepeatedly(Return(message_loop_proxy_.get()));
+    EXPECT_CALL(context_, network_task_runner())
+        .Times(AnyNumber())
+        .WillRepeatedly(Return(message_loop_proxy_.get()));
 
     scoped_ptr<Capturer> capturer(new CapturerFake());
     event_executor_ = new MockEventExecutor();
     desktop_environment_ = DesktopEnvironment::CreateFake(
         &context_,
         capturer.Pass(),
         scoped_ptr<EventExecutor>(event_executor_));
     session_manager_ = new protocol::MockSessionManager();
 
     host_ = new ChromotingHost(
@@ skipping 103 matching lines @@
                                 bool reject) {
     scoped_ptr<protocol::ConnectionToClient> connection =
         ((connection_index == 0) ? owned_connection_ : owned_connection2_).
         PassAs<protocol::ConnectionToClient>();
     protocol::ConnectionToClient* connection_ptr = connection.get();
     ClientSession* client = new ClientSession(
         host_.get(), connection.Pass(), desktop_environment_->event_executor(),
         desktop_environment_->capturer(), base::TimeDelta());
     connection_ptr->set_host_stub(client);
 
-    context_.network_message_loop()->PostTask(
+    context_.network_task_runner()->PostTask(
         FROM_HERE, base::Bind(&ChromotingHostTest::AddClientToHost,
                               host_, client));
 
     if (authenticate) {
-      context_.network_message_loop()->PostTask(
+      context_.network_task_runner()->PostTask(
           FROM_HERE, base::Bind(&ClientSession::OnConnectionAuthenticated,
                                 base::Unretained(client), connection_ptr));
       if (!reject) {
-        context_.network_message_loop()->PostTask(
+        context_.network_task_runner()->PostTask(
             FROM_HERE,
             base::Bind(&ClientSession::OnConnectionChannelsConnected,
                        base::Unretained(client), connection_ptr));
       }
     } else {
-      context_.network_message_loop()->PostTask(
+      context_.network_task_runner()->PostTask(
           FROM_HERE, base::Bind(&ClientSession::OnConnectionClosed,
                                 base::Unretained(client), connection_ptr,
                                 protocol::AUTHENTICATION_FAILED));
     }
 
     if (connection_index == 0) {
       client_ = client;
     } else {
       client2_ = client;
     }
@@ skipping 405 matching lines @@
   host_->OnIncomingSession(session_unowned_.release(), &response);
   EXPECT_EQ(protocol::SessionManager::ACCEPT, response);
 
   host_->OnIncomingSession(session2_unowned_.get(), &response);
   EXPECT_EQ(protocol::SessionManager::OVERLOAD, response);
 
   host_->Shutdown(base::Bind(&NullTask));
 }
 
 }  // namespace remoting