[Chromoting] Refactoring DesktopEnvironment and moving screen/audio recorders to ClientSession.

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"
 #include "remoting/host/chromoting_host_context.h"
 #include "remoting/host/chromoting_host.h"
+#include "remoting/host/desktop_environment.h"
+#include "remoting/host/desktop_environment_factory.h"
+#include "remoting/host/event_executor_fake.h"
 #include "remoting/host/host_mock_objects.h"
 #include "remoting/host/it2me_host_user_interface.h"
 #include "remoting/host/video_frame_capturer_fake.h"
 #include "remoting/proto/video.pb.h"
 #include "remoting/protocol/errors.h"
 #include "remoting/protocol/protocol_mock_objects.h"
 #include "remoting/protocol/session_config.h"
 #include "testing/gmock_mutant.h"
 #include "testing/gmock/include/gmock/gmock.h"
 #include "testing/gtest/include/gtest/gtest.h"
@@ skipping 33 matching lines @@
 // done callbacks.
 ACTION(RunDoneTask) {
   arg1.Run();
 }
 
 void DoNothing() {
 }
 
 }  // namespace
 
+class MockDesktopEnvironmentFactory : public DesktopEnvironmentFactory {
+ public:
+  MockDesktopEnvironmentFactory();
+  virtual ~MockDesktopEnvironmentFactory();
+
+  virtual scoped_ptr<DesktopEnvironment> Create(
+      ChromotingHostContext* context) OVERRIDE;
+
+ private:
+  DISALLOW_COPY_AND_ASSIGN(MockDesktopEnvironmentFactory);
+};
+
+MockDesktopEnvironmentFactory::MockDesktopEnvironmentFactory() {
+}
+
+MockDesktopEnvironmentFactory::~MockDesktopEnvironmentFactory() {
+}
+
+scoped_ptr<DesktopEnvironment> MockDesktopEnvironmentFactory::Create(
+    ChromotingHostContext* context) {
+  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:
   ChromotingHostTest() {
   }
 
   virtual void SetUp() OVERRIDE {
-    message_loop_proxy_ = base::MessageLoopProxy::current();
+    ui_task_runner_ = new AutoThreadTaskRunner(
+        message_loop_.message_loop_proxy(),
+        base::Bind(&ChromotingHostTest::QuitMainMessageLoop,
+                   base::Unretained(this)));
 
     EXPECT_CALL(context_, ui_task_runner())
         .Times(AnyNumber())
-        .WillRepeatedly(Return(message_loop_proxy_.get()));
+        .WillRepeatedly(Return(ui_task_runner_.get()));
     EXPECT_CALL(context_, capture_task_runner())
         .Times(AnyNumber())
-        .WillRepeatedly(Return(message_loop_proxy_.get()));
+        .WillRepeatedly(Return(ui_task_runner_.get()));
     EXPECT_CALL(context_, encode_task_runner())
         .Times(AnyNumber())
-        .WillRepeatedly(Return(message_loop_proxy_.get()));
+        .WillRepeatedly(Return(ui_task_runner_.get()));
     EXPECT_CALL(context_, network_task_runner())
         .Times(AnyNumber())
-        .WillRepeatedly(Return(message_loop_proxy_.get()));
+        .WillRepeatedly(Return(ui_task_runner_.get()));
 
-    scoped_ptr<VideoFrameCapturer> capturer(new VideoFrameCapturerFake());
-    scoped_ptr<AudioCapturer> audio_capturer(NULL);
-    event_executor_ = new MockEventExecutor();
-    desktop_environment_ = DesktopEnvironment::CreateFake(
-        &context_,
-        capturer.Pass(),
-        scoped_ptr<EventExecutor>(event_executor_),
-        audio_capturer.Pass());
+    desktop_environment_factory_.reset(new MockDesktopEnvironmentFactory());
     session_manager_ = new protocol::MockSessionManager();
 
     host_ = new ChromotingHost(
-        &context_, &signal_strategy_, desktop_environment_.get(),
+        &context_, &signal_strategy_, desktop_environment_factory_.get(),
         scoped_ptr<protocol::SessionManager>(session_manager_));
     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()),
@@ skipping 30 matching lines @@
     EXPECT_CALL(*session_unowned1_, SetEventHandler(_))
         .Times(AnyNumber())
         .WillRepeatedly(Invoke(this, &ChromotingHostTest::SetEventHandler));
     EXPECT_CALL(*session_unowned2_, SetEventHandler(_))
         .Times(AnyNumber());
     EXPECT_CALL(*session1_, config())
         .WillRepeatedly(ReturnRef(session_config1_));
     EXPECT_CALL(*session2_, config())
         .WillRepeatedly(ReturnRef(session_config2_));
 
-    owned_connection1_.reset(new MockConnectionToClient(
-        session1_, &host_stub1_, desktop_environment_->event_executor()));
+    owned_connection1_.reset(new MockConnectionToClient(session1_,
+                                                        &host_stub1_));
     connection1_ = owned_connection1_.get();
-    owned_connection2_.reset(new MockConnectionToClient(
-        session2_, &host_stub2_, desktop_environment_->event_executor()));
+    owned_connection2_.reset(new MockConnectionToClient(session2_,
+                                                        &host_stub2_));
     connection2_ = owned_connection2_.get();
 
     ON_CALL(video_stub1_, ProcessVideoPacketPtr(_, _))
         .WillByDefault(DeleteArg<0>());
     ON_CALL(video_stub2_, ProcessVideoPacketPtr(_, _))
         .WillByDefault(DeleteArg<0>());
     ON_CALL(*connection1_, video_stub())
         .WillByDefault(Return(&video_stub1_));
     ON_CALL(*connection1_, client_stub())
         .WillByDefault(Return(&client_stub1_));
@@ skipping 24 matching lines @@
         protocol::CandidateSessionConfig::CreateDefault();
   }
 
   // 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_);
+    connection_ptr->set_input_stub(desktop_environment->event_executor());
+
     ClientSession* client = new ClientSession(
         host_.get(),
+        context_.capture_task_runner(),
+        context_.encode_task_runner(),
+        context_.network_task_runner(),
         connection.Pass(),
-        desktop_environment_->event_executor(),
-        desktop_environment_->event_executor(),
-        desktop_environment_->capturer(),
+        host_->desktop_environment_factory_->Create(&context_),
         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 45 matching lines @@
 
   void NotifyConnectionClosed() {
     if (session_event_handler_) {
       session_event_handler_->OnSessionStateChange(protocol::Session::CLOSED);
     }
   }
 
   static void AddClientToHost(scoped_refptr<ChromotingHost> host,
                               ClientSession* session) {
     host->clients_.push_back(session);
+    host->clients_count_++;
   }
 
   void ShutdownHost() {
-    message_loop_.PostTask(
-        FROM_HERE, base::Bind(&ChromotingHost::Shutdown, host_,
-                              base::Bind(&PostQuitTask, &message_loop_)));
+    ui_task_runner_->PostTask(
+        FROM_HERE,
+        base::Bind(&ChromotingHost::Shutdown, host_,
+                   base::Bind(&ChromotingHostTest::ReleaseUiTaskRunner,
+                              base::Unretained(this))));
+  }
+
+  void ReleaseUiTaskRunner() {
+    it2me_host_user_interface_.reset();
+    ui_task_runner_ = NULL;
   }
 
   void QuitMainMessageLoop() {
     PostQuitTask(&message_loop_);
   }
 
   // Expect the host to start.
   void ExpectHostStart() {
     EXPECT_CALL(*disconnect_window_, Hide());
     EXPECT_CALL(*continue_window_, Hide());
@@ skipping 13 matching lines @@
   // Do |action| when that happens.
   template <class A>
   Expectation ExpectClientConnected(int connection_index, A action) {
     const std::string& session_jid = get_session_jid(connection_index);
     MockVideoStub& video_stub = get_video_stub(connection_index);
 
     Expectation client_authenticated =
         EXPECT_CALL(host_status_observer_, OnClientAuthenticated(session_jid));
     EXPECT_CALL(host_status_observer_, OnClientConnected(session_jid))
         .After(client_authenticated);
-    Expectation session_started =
-        EXPECT_CALL(*event_executor_, OnSessionStartedPtr(_))
-        .After(client_authenticated);
     Expectation video_packet_sent =
         EXPECT_CALL(video_stub, ProcessVideoPacketPtr(_, _))
-        .After(session_started)
+        .After(client_authenticated)
         .WillOnce(DoAll(
             action,
             RunDoneTask()))
         .RetiresOnSaturation();
     EXPECT_CALL(video_stub, ProcessVideoPacketPtr(_, _))
         .Times(AnyNumber())
         .After(video_packet_sent)
         .WillRepeatedly(RunDoneTask());
     return video_packet_sent;
   }
@@ skipping 25 matching lines @@
   // Expect the side-effects of a client disconnection, after a given
   // expectation. The given action will be done after the event executor is
   // notifed that the session has finished.
   template <class A>
   void ExpectClientDisconnectEffects(int connection_index,
                                      bool expect_host_status_change,
                                      Expectation after,
                                      A action) {
     const std::string& session_jid = get_session_jid(connection_index);
 
-    EXPECT_CALL(*event_executor_, OnSessionFinished())
-        .After(after)
-        .WillOnce(action);
     if (expect_host_status_change) {
       EXPECT_CALL(host_status_observer_, OnClientDisconnected(session_jid))
           .After(after)
+          .WillOnce(action)
           .RetiresOnSaturation();
     }
   }
 
  protected:
   MessageLoop message_loop_;
-  scoped_refptr<base::MessageLoopProxy> message_loop_proxy_;
+  scoped_refptr<AutoThreadTaskRunner> ui_task_runner_;
   MockChromotingHostContext context_;
   MockConnectionToClientEventHandler handler_;
   MockSignalStrategy signal_strategy_;
-  MockEventExecutor* event_executor_;
-  scoped_ptr<DesktopEnvironment> desktop_environment_;
+  scoped_ptr<DesktopEnvironmentFactory> desktop_environment_factory_;
   scoped_ptr<It2MeHostUserInterface> it2me_host_user_interface_;
   scoped_refptr<ChromotingHost> host_;
   MockHostStatusObserver host_status_observer_;
   protocol::MockSessionManager* session_manager_;
   std::string xmpp_login_;
   MockConnectionToClient* connection1_;
   scoped_ptr<MockConnectionToClient> owned_connection1_;
   ClientSession* client1_;
   std::string session_jid1_;
   MockSession* session1_;  // Owned by |connection_|.
@@ skipping 40 matching lines @@
   MockVideoStub& get_video_stub(int connection_index) {
     return (connection_index == 0) ? video_stub1_ : video_stub2_;
   }
 };
 
 TEST_F(ChromotingHostTest, StartAndShutdown) {
   Expectation start = ExpectHostAndSessionManagerStart();
   EXPECT_CALL(host_status_observer_, OnShutdown()).After(start);
 
   host_->Start(xmpp_login_);
-  message_loop_.PostTask(
-      FROM_HERE, base::Bind(
-          &ChromotingHost::Shutdown, host_.get(),
-          base::Bind(&PostQuitTask, &message_loop_)));
+  ShutdownHost();
   message_loop_.Run();
 }
 
 TEST_F(ChromotingHostTest, Connect) {
   ExpectHostAndSessionManagerStart();
 
   // Shut down the host when the first video packet is received.
   Expectation video_packet_sent = ExpectClientConnected(
       0, InvokeWithoutArgs(this, &ChromotingHostTest::ShutdownHost));
   Expectation client_disconnected = ExpectClientDisconnected(
@@ skipping 182 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