Making DesktopEnvironment a factory class used by ClientSession to create audio/video capturers and…

remoting/host/client_session_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/message_loop.h"
 #include "remoting/base/auto_thread_task_runner.h"
 #include "remoting/base/constants.h"
 #include "remoting/capturer/video_capturer_mock_objects.h"
 #include "remoting/capturer/video_frame_capturer_fake.h"
 #include "remoting/host/audio_capturer.h"
@@ skipping 37 matching lines @@
 }
 
 ACTION_P2(LocalMouseMoved, client_session, event) {
   client_session->LocalMouseMoved(SkIPoint::Make(event.x(), event.y()));
 }
 
 }  // namespace
 
 class ClientSessionTest : public testing::Test {
  public:
-  ClientSessionTest()
-      : client_jid_("user@domain/rest-of-jid"),
-        event_executor_(NULL) {}
+  ClientSessionTest() : client_jid_("user@domain/rest-of-jid") {}
 
   virtual void SetUp() OVERRIDE;
   virtual void TearDown() OVERRIDE;
 
   // Disconnects the client session.
   void DisconnectClientSession();
 
-  // Asynchronously stops the client session. OnClientStopped() will be called
-  // once the client session is fully stopped.
+  // Stops and releases the ClientSession, allowing the MessageLoop to quit.
   void StopClientSession();
 
  protected:
   // Creates a DesktopEnvironment with a fake VideoFrameCapturer, to mock
   // DesktopEnvironmentFactory::Create().
   DesktopEnvironment* CreateDesktopEnvironment();
 
+  // Returns |event_executor_| created and initialized by SetUp(), to mock
+  // DesktopEnvironment::CreateEventExecutor().
+  EventExecutor* CreateEventExecutor(
+      scoped_refptr<base::SingleThreadTaskRunner> input_task_runner,
+      scoped_refptr<base::SingleThreadTaskRunner> ui_task_runner);
+
+  // Creates a fake VideoFrameCapturer, to mock
+  // DesktopEnvironment::CreateVideoCapturer().
+  VideoFrameCapturer* CreateVideoCapturer(
+      scoped_refptr<base::SingleThreadTaskRunner> capture_task_runner,
+      scoped_refptr<base::SingleThreadTaskRunner> encode_task_runner);
+
   // Notifies the client session that the client connection has been
   // authenticated and channels have been connected. This effectively enables
   // the input pipe line and starts video capturing.
   void ConnectClientSession();
 
   // Invoked when the last reference to the AutoThreadTaskRunner has been
   // released and quits the message loop to finish the test.
   void QuitMainMessageLoop();
 
-  // Releases the ClientSession when it has been fully stopped, allowing
-  // the MessageLoop to quit.
-  void OnClientStopped();
-
   // Message loop passed to |client_session_| to perform all functions on.
   MessageLoop message_loop_;
 
   // ClientSession instance under test.
   scoped_refptr<ClientSession> client_session_;
 
   // ClientSession::EventHandler mock for use in tests.
   MockClientSessionEventHandler session_event_handler_;
 
   // Storage for values to be returned by the protocol::Session mock.
   SessionConfig session_config_;
   const std::string client_jid_;
 
   // Stubs returned to |client_session_| components by |connection_|.
   MockClientStub client_stub_;
   MockVideoStub video_stub_;
 
   // DesktopEnvironment owns |event_executor_|, but input injection tests need
   // to express expectations on it.
-  MockEventExecutor* event_executor_;
+  scoped_ptr<MockEventExecutor> event_executor_;
 
   // ClientSession owns |connection_| but tests need it to inject fake events.
   MockConnectionToClient* connection_;
 
   scoped_ptr<MockDesktopEnvironmentFactory> desktop_environment_factory_;
 };
 
 void ClientSessionTest::SetUp() {
   // Arrange to run |message_loop_| until no components depend on it.
   scoped_refptr<AutoThreadTaskRunner> ui_task_runner = new AutoThreadTaskRunner(
       message_loop_.message_loop_proxy(),
       base::Bind(&ClientSessionTest::QuitMainMessageLoop,
                  base::Unretained(this)));
 
   desktop_environment_factory_.reset(new MockDesktopEnvironmentFactory());
   EXPECT_CALL(*desktop_environment_factory_, CreatePtr())
       .Times(AnyNumber())
       .WillRepeatedly(Invoke(this,
                              &ClientSessionTest::CreateDesktopEnvironment));
+  EXPECT_CALL(*desktop_environment_factory_, SupportsAudioCapture())
+      .Times(AnyNumber())
+      .WillRepeatedly(Return(false));
+
+  event_executor_.reset(new MockEventExecutor());
 
   session_config_ = SessionConfig::ForTest();
 
   // Mock protocol::Session APIs called directly by ClientSession.
   protocol::MockSession* session = new MockSession();
   EXPECT_CALL(*session, config()).WillRepeatedly(ReturnRef(session_config_));
   EXPECT_CALL(*session, jid()).WillRepeatedly(ReturnRef(client_jid_));
   EXPECT_CALL(*session, SetEventHandler(_));
 
   // Mock protocol::ConnectionToClient APIs called directly by ClientSession.
   // HostStub is not touched by ClientSession, so we can safely pass NULL.
   scoped_ptr<MockConnectionToClient> connection(
       new MockConnectionToClient(session, NULL));
   EXPECT_CALL(*connection, session()).WillRepeatedly(Return(session));
   EXPECT_CALL(*connection, client_stub())
       .WillRepeatedly(Return(&client_stub_));
   EXPECT_CALL(*connection, video_stub()).WillRepeatedly(Return(&video_stub_));
   EXPECT_CALL(*connection, Disconnect());
   connection_ = connection.get();
 
   client_session_ = new ClientSession(
       &session_event_handler_,
       ui_task_runner, // Audio thread.
+      ui_task_runner, // Input thread.
       ui_task_runner, // Capture thread.
       ui_task_runner, // Encode thread.
       ui_task_runner, // Network thread.
+      ui_task_runner, // UI thread.
       connection.PassAs<protocol::ConnectionToClient>(),
       desktop_environment_factory_.get(),
       base::TimeDelta());
 }
 
 void ClientSessionTest::TearDown() {
   // Verify that the client session has been stopped.
   EXPECT_TRUE(client_session_.get() == NULL);
 }
 
 void ClientSessionTest::DisconnectClientSession() {
   client_session_->Disconnect();
   // MockSession won't trigger OnConnectionClosed, so fake it.
   client_session_->OnConnectionClosed(client_session_->connection(),
                                       protocol::OK);
 }
 
 void ClientSessionTest::StopClientSession() {
   // MockClientSessionEventHandler won't trigger Stop, so fake it.
-  client_session_->Stop(base::Bind(
-      &ClientSessionTest::OnClientStopped, base::Unretained(this)));
+  client_session_->Stop();
+  client_session_ = NULL;
+
+  desktop_environment_factory_.reset();
 }
 
 DesktopEnvironment* ClientSessionTest::CreateDesktopEnvironment() {
-  scoped_ptr<VideoFrameCapturer> video_capturer(new VideoFrameCapturerFake());
+  MockDesktopEnvironment* desktop_environment = new MockDesktopEnvironment();
+  EXPECT_CALL(*desktop_environment, CreateAudioCapturerPtr(_))
+      .Times(0);
+  EXPECT_CALL(*desktop_environment, CreateEventExecutorPtr(_, _))
+      .WillOnce(Invoke(this, &ClientSessionTest::CreateEventExecutor));
+  EXPECT_CALL(*desktop_environment, CreateVideoCapturerPtr(_, _))
+      .WillOnce(Invoke(this, &ClientSessionTest::CreateVideoCapturer));
 
-  EXPECT_TRUE(!event_executor_);
-  event_executor_ = new MockEventExecutor();
-  return new DesktopEnvironment(scoped_ptr<AudioCapturer>(NULL),
-                                scoped_ptr<EventExecutor>(event_executor_),
-                                video_capturer.Pass());
+  return desktop_environment;
+}
+
+EventExecutor* ClientSessionTest::CreateEventExecutor(
+    scoped_refptr<base::SingleThreadTaskRunner> input_task_runner,
+    scoped_refptr<base::SingleThreadTaskRunner> ui_task_runner) {
+  EXPECT_TRUE(event_executor_);
+  return event_executor_.release();
+}
+
+VideoFrameCapturer* ClientSessionTest::CreateVideoCapturer(
+    scoped_refptr<base::SingleThreadTaskRunner> capture_task_runner,
+    scoped_refptr<base::SingleThreadTaskRunner> encode_task_runner) {
+  return new VideoFrameCapturerFake();
 }
 
 void ClientSessionTest::ConnectClientSession() {
   client_session_->OnConnectionAuthenticated(client_session_->connection());
   client_session_->OnConnectionChannelsConnected(client_session_->connection());
 }
 
 void ClientSessionTest::QuitMainMessageLoop() {
   message_loop_.PostTask(FROM_HERE, MessageLoop::QuitClosure());
 }
 
-void ClientSessionTest::OnClientStopped() {
-  client_session_ = NULL;
-}
-
 MATCHER_P2(EqualsClipboardEvent, m, d, "") {
   return (strcmp(arg.mime_type().c_str(), m) == 0 &&
       memcmp(arg.data().data(), d, arg.data().size()) == 0);
 }
 
 TEST_F(ClientSessionTest, ClipboardStubFilter) {
   protocol::ClipboardEvent clipboard_event1;
   clipboard_event1.set_mime_type(kMimeTypeTextUtf8);
   clipboard_event1.set_data("a");
 
@@ skipping 198 matching lines @@
   EXPECT_CALL(*event_executor_, StartPtr(_));
   Expectation connected =
       EXPECT_CALL(session_event_handler_, OnSessionChannelsConnected(_));
   EXPECT_CALL(session_event_handler_, OnSessionClosed(_));
 
   int input_x[3] = { -999, 100, 999 };
   int expected_x[3] = { 0, 100, VideoFrameCapturerFake::kWidth - 1 };
   int input_y[3] = { -999, 50, 999 };
   int expected_y[3] = { 0, 50, VideoFrameCapturerFake::kHeight - 1 };
 
-  // Inject the 1st event once a video packet has been received.
-  protocol::MouseEvent injected_event;
-  injected_event.set_x(input_x[0]);
-  injected_event.set_y(input_y[0]);
-  connected =
-      EXPECT_CALL(video_stub_, ProcessVideoPacketPtr(_, _))
-          .After(connected)
-          .WillOnce(InjectMouseEvent(connection_, injected_event));
-
   protocol::MouseEvent expected_event;
   for (int j = 0; j < 3; j++) {
     for (int i = 0; i < 3; i++) {
-      // Skip the first iteration since the 1st event has been injected already.
-      if (i > 0 || j > 0) {
-        injected_event.set_x(input_x[i]);
-        injected_event.set_y(input_y[j]);
+      protocol::MouseEvent injected_event;
+      injected_event.set_x(input_x[i]);
+      injected_event.set_y(input_y[j]);
+
+      if (i == 0 && j == 0) {
+        // Inject the 1st event once a video packet has been received.
+        connected =
+            EXPECT_CALL(video_stub_, ProcessVideoPacketPtr(_, _))
+                .After(connected)
+                .WillOnce(InjectMouseEvent(connection_, injected_event));
+      } else {
+        // Every next event is injected once the previous event has been
+        // received.
         connected =
             EXPECT_CALL(*event_executor_,
                         InjectMouseEvent(EqualsMouseEvent(expected_event.x(),
                                                           expected_event.y())))
                 .After(connected)
                 .WillOnce(InjectMouseEvent(connection_, injected_event));
       }
 
       expected_event.set_x(expected_x[i]);
       expected_event.set_y(expected_y[j]);
     }
   }
 
   // Shutdown the connection once the last event has been received.
   EXPECT_CALL(*event_executor_,
               InjectMouseEvent(EqualsMouseEvent(expected_event.x(),
                                                 expected_event.y())))
       .After(connected)
       .WillOnce(DoAll(
           InvokeWithoutArgs(this, &ClientSessionTest::DisconnectClientSession),
           InvokeWithoutArgs(this, &ClientSessionTest::StopClientSession)));
 
   ConnectClientSession();
   message_loop_.Run();
 }
 
 }  // namespace remoting