Add VideoStream interface.

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 <algorithm>
 #include <string>
 #include <vector>
 
 #include "base/message_loop/message_loop.h"
 #include "base/run_loop.h"
 #include "base/strings/string_split.h"
 #include "base/strings/string_util.h"
 #include "remoting/base/auto_thread_task_runner.h"
 #include "remoting/base/constants.h"
+#include "remoting/codec/video_encoder_verbatim.h"
 #include "remoting/host/client_session.h"
 #include "remoting/host/desktop_environment.h"
 #include "remoting/host/fake_desktop_environment.h"
 #include "remoting/host/fake_host_extension.h"
 #include "remoting/host/fake_mouse_cursor_monitor.h"
 #include "remoting/host/host_extension.h"
 #include "remoting/host/host_extension_session.h"
 #include "remoting/host/host_mock_objects.h"
 #include "remoting/protocol/fake_connection_to_client.h"
 #include "remoting/protocol/fake_desktop_capturer.h"
@@ skipping 72 matching lines @@
 
   // Creates the client session.
   void CreateClientSession();
 
  protected:
   // 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();
 
-  // Waits for the first frame to be processed.
-  void WaitFirstFrame();
+  // Fakes video size notification from the VideoStream.
+  void NotifyVideoSize();
 
   // Creates expectations to send an extension message and to disconnect
   // afterwards.
   void SetSendMessageAndDisconnectExpectation(const std::string& message_type);
 
   // Message loop that will process all ClientSession tasks.
   base::MessageLoop message_loop_;
 
   // AutoThreadTaskRunner on which |client_session_| will be run.
   scoped_refptr<AutoThreadTaskRunner> task_runner_;
@@ skipping 11 matching lines @@
 
   // ClientSession::EventHandler mock for use in tests.
   MockClientSessionEventHandler session_event_handler_;
 
   // Storage for values to be returned by the protocol::Session mock.
   scoped_ptr<SessionConfig> session_config_;
   const std::string client_jid_;
 
   // Stubs returned to |client_session_| components by |connection_|.
   MockClientStub client_stub_;
-  MockVideoStub video_stub_;
 
   // ClientSession owns |connection_| but tests need it to inject fake events.
   protocol::FakeConnectionToClient* connection_;
 
   scoped_ptr<FakeDesktopEnvironmentFactory> desktop_environment_factory_;
 };
 
 void ClientSessionTest::SetUp() {
   // Arrange to run |message_loop_| until no components depend on it.
   task_runner_ = new AutoThreadTaskRunner(
@@ skipping 20 matching lines @@
   // Mock protocol::Session APIs called directly by ClientSession.
   scoped_ptr<protocol::MockSession> session(new MockSession());
   EXPECT_CALL(*session, config()).WillRepeatedly(ReturnRef(*session_config_));
   EXPECT_CALL(*session, jid()).WillRepeatedly(ReturnRef(client_jid_));
 
   // Mock protocol::ConnectionToClient APIs called directly by ClientSession.
   // HostStub is not touched by ClientSession, so we can safely pass nullptr.
   scoped_ptr<protocol::FakeConnectionToClient> connection(
       new protocol::FakeConnectionToClient(session.Pass()));
   connection->set_client_stub(&client_stub_);
-  connection->set_video_stub(&video_stub_);
   connection_ = connection.get();
 
   client_session_.reset(new ClientSession(
       &session_event_handler_,
       task_runner_,  // Audio thread.
       task_runner_,  // Input thread.
       task_runner_,  // Capture thread.
       task_runner_,  // Encode thread.
       task_runner_,  // Network thread.
       task_runner_,  // UI thread.
@@ skipping 13 matching lines @@
   EXPECT_FALSE(connection_->input_stub());
 
   client_session_->OnConnectionAuthenticated(client_session_->connection());
 
   EXPECT_TRUE(connection_->clipboard_stub());
   EXPECT_TRUE(connection_->input_stub());
 
   client_session_->OnConnectionChannelsConnected(client_session_->connection());
 }
 
-void ClientSessionTest::WaitFirstFrame() {
-  // Wait for the first video packet to be captured to make sure that
-  // the injected input will go though. Otherwise mouse events will be blocked
-  // by the mouse clamping filter.
-  base::RunLoop run_loop;
-  EXPECT_CALL(video_stub_, ProcessVideoPacketPtr(_, _))
-      .Times(AtLeast(1))
-      .WillOnce(testing::InvokeWithoutArgs(&run_loop, &base::RunLoop::Quit));
-  run_loop.Run();
+void ClientSessionTest::NotifyVideoSize() {
+  connection_->last_video_stream()->size_callback().Run(
+      webrtc::DesktopSize(protocol::FakeDesktopCapturer::kWidth,
+                          protocol::FakeDesktopCapturer::kHeight));
 }
 
 TEST_F(ClientSessionTest, DisableInputs) {
   CreateClientSession();
   ConnectClientSession();
-  WaitFirstFrame();
+  NotifyVideoSize();
 
   FakeInputInjector* input_injector =
       desktop_environment_factory_->last_desktop_environment()
           ->last_input_injector()
           .get();
   std::vector<protocol::KeyEvent> key_events;
   input_injector->set_key_events(&key_events);
   std::vector<protocol::MouseEvent> mouse_events;
   input_injector->set_mouse_events(&mouse_events);
   std::vector<protocol::ClipboardEvent> clipboard_events;
@@ skipping 35 matching lines @@
   EXPECT_EQ(2U, clipboard_events.size());
   EXPECT_THAT(clipboard_events[0],
               EqualsClipboardEvent(kMimeTypeTextUtf8, "a"));
   EXPECT_THAT(clipboard_events[1],
               EqualsClipboardEvent(kMimeTypeTextUtf8, "c"));
 }
 
 TEST_F(ClientSessionTest, LocalInputTest) {
   CreateClientSession();
   ConnectClientSession();
-  WaitFirstFrame();
+  NotifyVideoSize();
+
 
   std::vector<protocol::MouseEvent> mouse_events;
   desktop_environment_factory_->last_desktop_environment()
       ->last_input_injector()
       ->set_mouse_events(&mouse_events);
 
   connection_->input_stub()->InjectMouseEvent(MakeMouseMoveEvent(100, 101));
 
 #if !defined(OS_WIN)
   // The OS echoes the injected event back.
@@ skipping 14 matching lines @@
   EXPECT_THAT(mouse_events[0], EqualsMouseMoveEvent(100, 101));
   EXPECT_THAT(mouse_events[1], EqualsMouseMoveEvent(200, 201));
 
   // TODO(jamiewalch): Verify that remote inputs are re-enabled
   // eventually (via dependency injection, not sleep!)
 }
 
 TEST_F(ClientSessionTest, RestoreEventState) {
   CreateClientSession();
   ConnectClientSession();
-  WaitFirstFrame();
+  NotifyVideoSize();
 
   FakeInputInjector* input_injector =
       desktop_environment_factory_->last_desktop_environment()
           ->last_input_injector()
           .get();
   std::vector<protocol::KeyEvent> key_events;
   input_injector->set_key_events(&key_events);
   std::vector<protocol::MouseEvent> mouse_events;
   input_injector->set_mouse_events(&mouse_events);
 
@@ skipping 17 matching lines @@
   EXPECT_EQ(4U, key_events.size());
   EXPECT_THAT(key_events[0], EqualsKeyEvent(1, true));
   EXPECT_THAT(key_events[1], EqualsKeyEvent(2, true));
   EXPECT_THAT(key_events[2], EqualsKeyEvent(1, false));
   EXPECT_THAT(key_events[3], EqualsKeyEvent(2, false));
 }
 
 TEST_F(ClientSessionTest, ClampMouseEvents) {
   CreateClientSession();
   ConnectClientSession();
-  WaitFirstFrame();
+  NotifyVideoSize();
 
   std::vector<protocol::MouseEvent> mouse_events;
   desktop_environment_factory_->last_desktop_environment()
       ->last_input_injector()
       ->set_mouse_events(&mouse_events);
 
   int input_x[3] = {-999, 100, 999};
   int expected_x[3] = {0, 100, protocol::FakeDesktopCapturer::kWidth - 1};
   int input_y[3] = {-999, 50, 999};
   int expected_y[3] = {0, 50, protocol::FakeDesktopCapturer::kHeight - 1};
 
   protocol::MouseEvent expected_event;
   for (int j = 0; j < 3; j++) {
     for (int i = 0; i < 3; i++) {
       mouse_events.clear();
       connection_->input_stub()->InjectMouseEvent(
           MakeMouseMoveEvent(input_x[i], input_y[j]));
 
       EXPECT_EQ(1U, mouse_events.size());
       EXPECT_THAT(mouse_events[0],
                   EqualsMouseMoveEvent(expected_x[i], expected_y[j]));
     }
   }
 }
 
 TEST_F(ClientSessionTest, NoGnubbyAuth) {
   CreateClientSession();
   ConnectClientSession();
-  WaitFirstFrame();
+  NotifyVideoSize();
 
   protocol::ExtensionMessage message;
   message.set_type("gnubby-auth");
   message.set_data("test");
 
   // Host should ignore gnubby messages when gnubby is disabled.
   client_session_->DeliverClientMessage(message);
 }
 
 TEST_F(ClientSessionTest, EnableGnubbyAuth) {
   CreateClientSession();
   ConnectClientSession();
-  WaitFirstFrame();
+  NotifyVideoSize();
 
   // Lifetime controlled by object under test.
   MockGnubbyAuthHandler* gnubby_auth_handler = new MockGnubbyAuthHandler();
   client_session_->SetGnubbyAuthHandlerForTesting(gnubby_auth_handler);
 
   // Host should ignore gnubby messages when gnubby is disabled.
   protocol::ExtensionMessage message;
   message.set_type("gnubby-auth");
   message.set_data("test");
 
   EXPECT_CALL(*gnubby_auth_handler, DeliverClientMessage(_)).Times(1);
   client_session_->DeliverClientMessage(message);
 }
 
 // Verifies that the client's video pipeline can be reset mid-session.
 TEST_F(ClientSessionTest, ResetVideoPipeline) {
   CreateClientSession();
   ConnectClientSession();
-  WaitFirstFrame();
+  NotifyVideoSize();
 
   client_session_->ResetVideoPipeline();
 }
 
 // Verifies that clients can have extensions registered, resulting in the
 // correct capabilities being reported, and messages delivered correctly.
 // The extension system is tested more extensively in the
 // HostExtensionSessionManager unit-tests.
 TEST_F(ClientSessionTest, Extensions) {
   // Configure fake extensions for testing.
@@ skipping 13 matching lines @@
   CreateClientSession();
   ConnectClientSession();
 
   testing::Mock::VerifyAndClearExpectations(&client_stub_);
 
   // Mimic the client reporting an overlapping set of capabilities.
   protocol::Capabilities capabilities_message;
   capabilities_message.set_capabilities("cap1 cap4 default");
   client_session_->SetCapabilities(capabilities_message);
 
+  // Simulate OnCreateVideoEncoder() which is normally called by the
+  // ConnectionToClient when creating the video stream.
+  scoped_ptr<VideoEncoder> encoder(new VideoEncoderVerbatim());
+  connection_->event_handler()->OnCreateVideoEncoder(&encoder);
+
   // Verify that the correct extension messages are delivered, and dropped.
   protocol::ExtensionMessage message1;
   message1.set_type("ext1");
   message1.set_data("data");
   client_session_->DeliverClientMessage(message1);
   protocol::ExtensionMessage message3;
   message3.set_type("ext3");
   message3.set_data("data");
   client_session_->DeliverClientMessage(message3);
   protocol::ExtensionMessage message4;
@@ skipping 52 matching lines @@
 
   client_session_->DisconnectSession(protocol::OK);
   client_session_.reset();
 
   // ext1 was instantiated and wrapped the video capturer.
   EXPECT_TRUE(extension.was_instantiated());
   EXPECT_TRUE(extension.has_wrapped_video_capturer());
 }
 
 }  // namespace remoting