Fix ChromotingHost and DesktopEnvironmentFactory references to TaskRunners.

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/base/auto_thread_task_runner.h"
 #include "remoting/jingle_glue/mock_objects.h"
 #include "remoting/host/audio_capturer.h"
@@ skipping 53 matching lines @@
 void DoNothing() {
 }
 
 }  // namespace
 
 class MockDesktopEnvironmentFactory : public DesktopEnvironmentFactory {
  public:
   MockDesktopEnvironmentFactory();
   virtual ~MockDesktopEnvironmentFactory();
 
-  virtual scoped_ptr<DesktopEnvironment> Create(
-      ChromotingHostContext* context) OVERRIDE;
+  virtual scoped_ptr<DesktopEnvironment> Create() OVERRIDE;
 
  private:
   DISALLOW_COPY_AND_ASSIGN(MockDesktopEnvironmentFactory);
 };
 
-MockDesktopEnvironmentFactory::MockDesktopEnvironmentFactory() {
+MockDesktopEnvironmentFactory::MockDesktopEnvironmentFactory()
+    : DesktopEnvironmentFactory(NULL, NULL) {
 }
 
 MockDesktopEnvironmentFactory::~MockDesktopEnvironmentFactory() {
 }
 
-scoped_ptr<DesktopEnvironment> MockDesktopEnvironmentFactory::Create(
-    ChromotingHostContext* context) {
+scoped_ptr<DesktopEnvironment> MockDesktopEnvironmentFactory::Create() {
   scoped_ptr<EventExecutor> event_executor(new EventExecutorFake());
   scoped_ptr<VideoFrameCapturer> video_capturer(new VideoFrameCapturerFake());
   return scoped_ptr<DesktopEnvironment>(new DesktopEnvironment(
       scoped_ptr<AudioCapturer>(NULL),
       event_executor.Pass(),
       video_capturer.Pass()));
 }
 
 class ChromotingHostTest : public testing::Test {
  public:
@@ skipping 16 matching lines @@
         .Times(AnyNumber())
         .WillRepeatedly(Return(ui_task_runner_.get()));
     EXPECT_CALL(context_, network_task_runner())
         .Times(AnyNumber())
         .WillRepeatedly(Return(ui_task_runner_.get()));
 
     desktop_environment_factory_.reset(new MockDesktopEnvironmentFactory());
     session_manager_ = new protocol::MockSessionManager();
 
     host_ = new ChromotingHost(
-        &context_, &signal_strategy_, desktop_environment_factory_.get(),
-        scoped_ptr<protocol::SessionManager>(session_manager_));
+        &signal_strategy_,
+        desktop_environment_factory_.get(),
+        scoped_ptr<protocol::SessionManager>(session_manager_),
+        context_.capture_task_runner(),
+        context_.encode_task_runner(),
+        context_.network_task_runner());
     host_->AddStatusObserver(&host_status_observer_);
 
     disconnect_window_ = new MockDisconnectWindow();
     continue_window_ = new MockContinueWindow();
     local_input_monitor_ = new MockLocalInputMonitor();
     it2me_host_user_interface_.reset(new It2MeHostUserInterface(&context_));
     it2me_host_user_interface_->StartForTest(
         host_,
         base::Bind(&ChromotingHost::Shutdown, host_, base::Closure()),
         scoped_ptr<DisconnectWindow>(disconnect_window_),
@@ skipping 79 matching lines @@
   }
 
   // Helper method to pretend a client is connected to ChromotingHost.
   void SimulateClientConnection(int connection_index, bool authenticate,
                                 bool reject) {
     scoped_ptr<protocol::ConnectionToClient> connection =
         ((connection_index == 0) ? owned_connection1_ : owned_connection2_).
         PassAs<protocol::ConnectionToClient>();
     protocol::ConnectionToClient* connection_ptr = connection.get();
     scoped_ptr<DesktopEnvironment> desktop_environment =
-        host_->desktop_environment_factory_->Create(&context_);
+        host_->desktop_environment_factory_->Create();
     connection_ptr->set_input_stub(desktop_environment->event_executor());
 
     scoped_refptr<ClientSession> client = new ClientSession(
         host_.get(),
         context_.capture_task_runner(),
         context_.encode_task_runner(),
         context_.network_task_runner(),
         connection.Pass(),
-        host_->desktop_environment_factory_->Create(&context_),
+        desktop_environment.Pass(),
         base::TimeDelta());
     connection_ptr->set_host_stub(client);
 
     context_.network_task_runner()->PostTask(
         FROM_HERE, base::Bind(&ChromotingHostTest::AddClientToHost,
                               host_, client));
 
     if (authenticate) {
       context_.network_task_runner()->PostTask(
           FROM_HERE, base::Bind(&ClientSession::OnConnectionAuthenticated,
@@ skipping 424 matching lines @@
   ExpectClientDisconnected(0, true, video_packet_sent,
       InvokeWithoutArgs(this, &ChromotingHostTest::ShutdownHost));
   EXPECT_CALL(host_status_observer_, OnShutdown());
 
   host_->Start(xmpp_login_);
   SimulateClientConnection(0, true, false);
   message_loop_.Run();
 }
 
 }  // namespace remoting