remoting/host/client_session_unittest.cc

   1 // Copyright (c) 2012 The Chromium Authors. All rights reserved.
   2 // Use of this source code is governed by a BSD-style license that can be
   3 // found in the LICENSE file.
   4
   5 #include <algorithm>
   6 #include <string>
   7 #include <vector>
   8
   9 #include "base/message_loop/message_loop.h"
  10 #include "base/run_loop.h"
  11 #include "base/strings/string_util.h"
  12 #include "base/test/test_simple_task_runner.h"
  13 #include "remoting/base/auto_thread_task_runner.h"
  14 #include "remoting/base/constants.h"
  15 #include "remoting/host/audio_capturer.h"
  16 #include "remoting/host/client_session.h"
  17 #include "remoting/host/desktop_environment.h"
  18 #include "remoting/host/fake_desktop_capturer.h"
  19 #include "remoting/host/fake_host_extension.h"
  20 #include "remoting/host/fake_mouse_cursor_monitor.h"
  21 #include "remoting/host/host_extension.h"
  22 #include "remoting/host/host_extension_session.h"
  23 #include "remoting/host/host_mock_objects.h"
  24 #include "remoting/protocol/protocol_mock_objects.h"
  25 #include "testing/gmock/include/gmock/gmock-matchers.h"
  26 #include "testing/gmock_mutant.h"
  27 #include "testing/gtest/include/gtest/gtest.h"
  28 #include "third_party/webrtc/modules/desktop_capture/desktop_geometry.h"
  29 #include "third_party/webrtc/modules/desktop_capture/desktop_region.h"
  30 #include "third_party/webrtc/modules/desktop_capture/screen_capturer_mock_objects.h"
  31
  32 namespace remoting {
  33
  34 using protocol::MockConnectionToClient;
  35 using protocol::MockClientStub;
  36 using protocol::MockHostStub;
  37 using protocol::MockInputStub;
  38 using protocol::MockSession;
  39 using protocol::MockVideoStub;
  40 using protocol::SessionConfig;
  41
  42 using testing::_;
  43 using testing::AnyNumber;
  44 using testing::AtMost;
  45 using testing::CreateFunctor;
  46 using testing::DeleteArg;
  47 using testing::DoAll;
  48 using testing::Expectation;
  49 using testing::Invoke;
  50 using testing::Return;
  51 using testing::ReturnRef;
  52 using testing::Sequence;
  53 using testing::StrEq;
  54 using testing::StrictMock;
  55
  56 namespace {
  57
  58 const char kDefaultTestCapability[] = "default";
  59
  60 ACTION_P2(InjectClipboardEvent, connection, event) {
  61   connection->clipboard_stub()->InjectClipboardEvent(event);
  62 }
  63
  64 ACTION_P2(InjectKeyEvent, connection, event) {
  65   connection->input_stub()->InjectKeyEvent(event);
  66 }
  67
  68 ACTION_P2(InjectMouseEvent, connection, event) {
  69   connection->input_stub()->InjectMouseEvent(event);
  70 }
  71
  72 ACTION_P2(LocalMouseMoved, client_session, event) {
  73   client_session->OnLocalMouseMoved(
  74       webrtc::DesktopVector(event.x(), event.y()));
  75 }
  76
  77 ACTION_P2(SetGnubbyAuthHandlerForTesting, client_session, gnubby_auth_handler) {
  78   client_session->SetGnubbyAuthHandlerForTesting(gnubby_auth_handler);
  79 }
  80
  81 ACTION_P2(DeliverClientMessage, client_session, message) {
  82   client_session->DeliverClientMessage(message);
  83 }
  84
  85 ACTION_P2(SetCapabilities, client_session, capabilities) {
  86   protocol::Capabilities capabilities_message;
  87   capabilities_message.set_capabilities(capabilities);
  88   client_session->SetCapabilities(capabilities_message);
  89 }
  90
  91 MATCHER_P2(EqualsUsbEvent, usb_keycode, pressed, "") {
  92   return arg.usb_keycode() == (unsigned int)usb_keycode &&
  93          arg.pressed() == pressed;
  94 }
  95
  96 MATCHER_P2(EqualsMouseEvent, x, y, "") {
  97   return arg.x() == x && arg.y() == y;
  98 }
  99
 100 MATCHER_P2(EqualsMouseButtonEvent, button, down, "") {
 101   return arg.button() == button && arg.button_down() == down;
 102 }
 103
 104 // Matches a |protocol::Capabilities| argument against a list of capabilities
 105 // formatted as a space-separated string.
 106 MATCHER_P(EqCapabilities, expected_capabilities, "") {
 107   if (!arg.has_capabilities())
 108     return false;
 109
 110   std::vector<std::string> words_args;
 111   std::vector<std::string> words_expected;
 112   Tokenize(arg.capabilities(), " ", &words_args);
 113   Tokenize(expected_capabilities, " ", &words_expected);
 114   std::sort(words_args.begin(), words_args.end());
 115   std::sort(words_expected.begin(), words_expected.end());
 116   return words_args == words_expected;
 117 }
 118
 119 }  // namespace
 120
 121 class ClientSessionTest : public testing::Test {
 122  public:
 123   ClientSessionTest() : client_jid_("user@domain/rest-of-jid") {}
 124
 125   void SetUp() override;
 126   void TearDown() override;
 127
 128   // Creates the client session.
 129   void CreateClientSession();
 130
 131   // Disconnects the client session.
 132   void DisconnectClientSession();
 133
 134   // Stops and releases the ClientSession, allowing the MessageLoop to quit.
 135   void StopClientSession();
 136
 137  protected:
 138   // Creates a DesktopEnvironment with a fake webrtc::DesktopCapturer, to mock
 139   // DesktopEnvironmentFactory::Create().
 140   DesktopEnvironment* CreateDesktopEnvironment();
 141
 142   // Returns |input_injector_| created and initialized by SetUp(), to mock
 143   // DesktopEnvironment::CreateInputInjector().
 144   InputInjector* CreateInputInjector();
 145
 146   // Creates a fake webrtc::DesktopCapturer, to mock
 147   // DesktopEnvironment::CreateVideoCapturer().
 148   webrtc::DesktopCapturer* CreateVideoCapturer();
 149
 150   // Creates a MockMouseCursorMonitor, to mock
 151   // DesktopEnvironment::CreateMouseCursorMonitor
 152   webrtc::MouseCursorMonitor* CreateMouseCursorMonitor();
 153
 154   // Notifies the client session that the client connection has been
 155   // authenticated and channels have been connected. This effectively enables
 156   // the input pipe line and starts video capturing.
 157   void ConnectClientSession();
 158
 159   // Creates expectation that simulates client supporting same capabilities as
 160   // host.
 161   void SetMatchCapabilitiesExpectation();
 162
 163   // Creates expectations to send an extension message and to disconnect
 164   // afterwards.
 165   void SetSendMessageAndDisconnectExpectation(const std::string& message_type);
 166
 167   // Message loop that will process all ClientSession tasks.
 168   base::MessageLoop message_loop_;
 169
 170   // AutoThreadTaskRunner on which |client_session_| will be run.
 171   scoped_refptr<AutoThreadTaskRunner> task_runner_;
 172
 173   // Used to run |message_loop_| after each test, until no objects remain that
 174   // require it.
 175   base::RunLoop run_loop_;
 176
 177   // HostExtensions to pass when creating the ClientSession. Caller retains
 178   // ownership of the HostExtensions themselves.
 179   std::vector<HostExtension*> extensions_;
 180
 181   // ClientSession instance under test.
 182   scoped_ptr<ClientSession> client_session_;
 183
 184   // ClientSession::EventHandler mock for use in tests.
 185   MockClientSessionEventHandler session_event_handler_;
 186
 187   // Storage for values to be returned by the protocol::Session mock.
 188   SessionConfig session_config_;
 189   const std::string client_jid_;
 190
 191   // Stubs returned to |client_session_| components by |connection_|.
 192   MockClientStub client_stub_;
 193   MockVideoStub video_stub_;
 194
 195   // DesktopEnvironment owns |input_injector_|, but input injection tests need
 196   // to express expectations on it.
 197   scoped_ptr<MockInputInjector> input_injector_;
 198
 199   // ClientSession owns |connection_| but tests need it to inject fake events.
 200   MockConnectionToClient* connection_;
 201
 202   scoped_ptr<MockDesktopEnvironmentFactory> desktop_environment_factory_;
 203 };
 204
 205 void ClientSessionTest::SetUp() {
 206   // Arrange to run |message_loop_| until no components depend on it.
 207   task_runner_ = new AutoThreadTaskRunner(
 208       message_loop_.message_loop_proxy(), run_loop_.QuitClosure());
 209
 210   desktop_environment_factory_.reset(new MockDesktopEnvironmentFactory());
 211   EXPECT_CALL(*desktop_environment_factory_, CreatePtr())
 212       .Times(AnyNumber())
 213       .WillRepeatedly(Invoke(this,
 214                              &ClientSessionTest::CreateDesktopEnvironment));
 215   EXPECT_CALL(*desktop_environment_factory_, SupportsAudioCapture())
 216       .Times(AnyNumber())
 217       .WillRepeatedly(Return(false));
 218
 219   input_injector_.reset(new MockInputInjector());
 220
 221   session_config_ = SessionConfig::ForTest();
 222 }
 223
 224 void ClientSessionTest::TearDown() {
 225   // Clear out |task_runner_| reference so the loop can quit, and run it until
 226   // it does.
 227   task_runner_ = nullptr;
 228   run_loop_.Run();
 229 }
 230
 231 void ClientSessionTest::CreateClientSession() {
 232   // Mock protocol::Session APIs called directly by ClientSession.
 233   protocol::MockSession* session = new MockSession();
 234   EXPECT_CALL(*session, config()).WillRepeatedly(ReturnRef(session_config_));
 235   EXPECT_CALL(*session, jid()).WillRepeatedly(ReturnRef(client_jid_));
 236   EXPECT_CALL(*session, SetEventHandler(_));
 237
 238   // Mock protocol::ConnectionToClient APIs called directly by ClientSession.
 239   // HostStub is not touched by ClientSession, so we can safely pass nullptr.
 240   scoped_ptr<MockConnectionToClient> connection(
 241       new MockConnectionToClient(session, nullptr));
 242   EXPECT_CALL(*connection, session()).WillRepeatedly(Return(session));
 243   EXPECT_CALL(*connection, client_stub())
 244       .WillRepeatedly(Return(&client_stub_));
 245   EXPECT_CALL(*connection, video_stub()).WillRepeatedly(Return(&video_stub_));
 246   EXPECT_CALL(*connection, Disconnect());
 247   connection_ = connection.get();
 248
 249   client_session_.reset(new ClientSession(
 250       &session_event_handler_,
 251       task_runner_, // Audio thread.
 252       task_runner_, // Input thread.
 253       task_runner_, // Capture thread.
 254       task_runner_, // Encode thread.
 255       task_runner_, // Network thread.
 256       task_runner_, // UI thread.
 257       connection.Pass(),
 258       desktop_environment_factory_.get(),
 259       base::TimeDelta(),
 260       nullptr,
 261       extensions_));
 262 }
 263
 264 void ClientSessionTest::DisconnectClientSession() {
 265   client_session_->DisconnectSession();
 266   // MockSession won't trigger OnConnectionClosed, so fake it.
 267   client_session_->OnConnectionClosed(client_session_->connection(),
 268                                       protocol::OK);
 269 }
 270
 271 void ClientSessionTest::StopClientSession() {
 272   client_session_.reset();
 273
 274   desktop_environment_factory_.reset();
 275 }
 276
 277 DesktopEnvironment* ClientSessionTest::CreateDesktopEnvironment() {
 278   MockDesktopEnvironment* desktop_environment = new MockDesktopEnvironment();
 279   EXPECT_CALL(*desktop_environment, CreateAudioCapturerPtr())
 280       .Times(0);
 281   EXPECT_CALL(*desktop_environment, CreateInputInjectorPtr())
 282       .WillOnce(Invoke(this, &ClientSessionTest::CreateInputInjector));
 283   EXPECT_CALL(*desktop_environment, CreateScreenControlsPtr())
 284       .Times(AtMost(1));
 285   EXPECT_CALL(*desktop_environment, CreateVideoCapturerPtr())
 286       .WillRepeatedly(Invoke(this, &ClientSessionTest::CreateVideoCapturer));
 287   EXPECT_CALL(*desktop_environment, CreateMouseCursorMonitorPtr())
 288       .WillRepeatedly(
 289           Invoke(this, &ClientSessionTest::CreateMouseCursorMonitor));
 290   EXPECT_CALL(*desktop_environment, GetCapabilities())
 291       .Times(AtMost(1))
 292        .WillOnce(Return(kDefaultTestCapability));
 293   EXPECT_CALL(*desktop_environment, SetCapabilities(_))
 294       .Times(AtMost(1));
 295
 296   return desktop_environment;
 297 }
 298
 299 InputInjector* ClientSessionTest::CreateInputInjector() {
 300   EXPECT_TRUE(input_injector_);
 301   return input_injector_.release();
 302 }
 303
 304 webrtc::DesktopCapturer* ClientSessionTest::CreateVideoCapturer() {
 305   return new FakeDesktopCapturer();
 306 }
 307
 308 webrtc::MouseCursorMonitor* ClientSessionTest::CreateMouseCursorMonitor() {
 309   return new FakeMouseCursorMonitor();
 310 }
 311
 312 void ClientSessionTest::ConnectClientSession() {
 313   client_session_->OnConnectionAuthenticated(client_session_->connection());
 314   client_session_->OnConnectionChannelsConnected(client_session_->connection());
 315 }
 316
 317 void ClientSessionTest::SetMatchCapabilitiesExpectation() {
 318   // Set the client to report the same capabilities as the host.
 319   EXPECT_CALL(client_stub_, SetCapabilities(_))
 320       .Times(AtMost(1))
 321       .WillOnce(Invoke(client_session_.get(), &ClientSession::SetCapabilities));
 322 }
 323
 324 void ClientSessionTest::SetSendMessageAndDisconnectExpectation(
 325     const std::string& message_type) {
 326   protocol::ExtensionMessage message;
 327   message.set_type(message_type);
 328   message.set_data("data");
 329
 330   Expectation authenticated =
 331       EXPECT_CALL(session_event_handler_, OnSessionAuthenticated(_))
 332       .WillOnce(Return(true));
 333   EXPECT_CALL(session_event_handler_, OnSessionChannelsConnected(_))
 334       .After(authenticated)
 335       .WillOnce(DoAll(
 336           DeliverClientMessage(client_session_.get(), message),
 337           InvokeWithoutArgs(this, &ClientSessionTest::DisconnectClientSession),
 338           InvokeWithoutArgs(this, &ClientSessionTest::StopClientSession)));
 339 }
 340
 341 MATCHER_P2(EqualsClipboardEvent, m, d, "") {
 342   return (strcmp(arg.mime_type().c_str(), m) == 0 &&
 343       memcmp(arg.data().data(), d, arg.data().size()) == 0);
 344 }
 345
 346 TEST_F(ClientSessionTest, ClipboardStubFilter) {
 347   CreateClientSession();
 348
 349   protocol::ClipboardEvent clipboard_event1;
 350   clipboard_event1.set_mime_type(kMimeTypeTextUtf8);
 351   clipboard_event1.set_data("a");
 352
 353   protocol::ClipboardEvent clipboard_event2;
 354   clipboard_event2.set_mime_type(kMimeTypeTextUtf8);
 355   clipboard_event2.set_data("b");
 356
 357   protocol::ClipboardEvent clipboard_event3;
 358   clipboard_event3.set_mime_type(kMimeTypeTextUtf8);
 359   clipboard_event3.set_data("c");
 360
 361   Expectation authenticated =
 362       EXPECT_CALL(session_event_handler_, OnSessionAuthenticated(_))
 363           .WillOnce(Return(true));
 364   EXPECT_CALL(*input_injector_, StartPtr(_))
 365       .After(authenticated);
 366   EXPECT_CALL(session_event_handler_, OnSessionChannelsConnected(_))
 367       .After(authenticated);
 368
 369   // Wait for the first video packet to be captured to make sure that
 370   // the injected input will go though. Otherwise mouse events will be blocked
 371   // by the mouse clamping filter.
 372   Sequence s;
 373   EXPECT_CALL(video_stub_, ProcessVideoPacketPtr(_, _))
 374       .InSequence(s)
 375       .After(authenticated)
 376       .WillOnce(DoAll(
 377           // This event should get through to the clipboard stub.
 378           InjectClipboardEvent(connection_, clipboard_event2),
 379           InvokeWithoutArgs(this, &ClientSessionTest::DisconnectClientSession),
 380           // This event should not get through to the clipboard stub,
 381           // because the client has disconnected.
 382           InjectClipboardEvent(connection_, clipboard_event3),
 383           InvokeWithoutArgs(this, &ClientSessionTest::StopClientSession)));
 384   EXPECT_CALL(*input_injector_, InjectClipboardEvent(EqualsClipboardEvent(
 385       kMimeTypeTextUtf8, "b")))
 386       .InSequence(s);
 387   EXPECT_CALL(session_event_handler_, OnSessionClosed(_))
 388       .InSequence(s);
 389
 390   // This event should not get through to the clipboard stub,
 391   // because the client isn't authenticated yet.
 392   connection_->clipboard_stub()->InjectClipboardEvent(clipboard_event1);
 393
 394   ConnectClientSession();
 395 }
 396
 397 TEST_F(ClientSessionTest, InputStubFilter) {
 398   CreateClientSession();
 399
 400   protocol::KeyEvent key_event1;
 401   key_event1.set_pressed(true);
 402   key_event1.set_usb_keycode(1);
 403
 404   protocol::KeyEvent key_event2_down;
 405   key_event2_down.set_pressed(true);
 406   key_event2_down.set_usb_keycode(2);
 407
 408   protocol::KeyEvent key_event2_up;
 409   key_event2_up.set_pressed(false);
 410   key_event2_up.set_usb_keycode(2);
 411
 412   protocol::KeyEvent key_event3;
 413   key_event3.set_pressed(true);
 414   key_event3.set_usb_keycode(3);
 415
 416   protocol::MouseEvent mouse_event1;
 417   mouse_event1.set_x(100);
 418   mouse_event1.set_y(101);
 419
 420   protocol::MouseEvent mouse_event2;
 421   mouse_event2.set_x(200);
 422   mouse_event2.set_y(201);
 423
 424   protocol::MouseEvent mouse_event3;
 425   mouse_event3.set_x(300);
 426   mouse_event3.set_y(301);
 427
 428   Expectation authenticated =
 429       EXPECT_CALL(session_event_handler_, OnSessionAuthenticated(_))
 430           .WillOnce(Return(true));
 431   EXPECT_CALL(*input_injector_, StartPtr(_))
 432       .After(authenticated);
 433   EXPECT_CALL(session_event_handler_, OnSessionChannelsConnected(_))
 434       .After(authenticated);
 435
 436   // Wait for the first video packet to be captured to make sure that
 437   // the injected input will go though. Otherwise mouse events will be blocked
 438   // by the mouse clamping filter.
 439   Sequence s;
 440   EXPECT_CALL(video_stub_, ProcessVideoPacketPtr(_, _))
 441       .InSequence(s)
 442       .After(authenticated)
 443       .WillOnce(DoAll(
 444           // These events should get through to the input stub.
 445           InjectKeyEvent(connection_, key_event2_down),
 446           InjectKeyEvent(connection_, key_event2_up),
 447           InjectMouseEvent(connection_, mouse_event2),
 448           InvokeWithoutArgs(this, &ClientSessionTest::DisconnectClientSession),
 449           // These events should not get through to the input stub,
 450           // because the client has disconnected.
 451           InjectKeyEvent(connection_, key_event3),
 452           InjectMouseEvent(connection_, mouse_event3),
 453           InvokeWithoutArgs(this, &ClientSessionTest::StopClientSession)));
 454   EXPECT_CALL(*input_injector_, InjectKeyEvent(EqualsUsbEvent(2, true)))
 455       .InSequence(s);
 456   EXPECT_CALL(*input_injector_, InjectKeyEvent(EqualsUsbEvent(2, false)))
 457       .InSequence(s);
 458   EXPECT_CALL(*input_injector_, InjectMouseEvent(EqualsMouseEvent(200, 201)))
 459       .InSequence(s);
 460   EXPECT_CALL(session_event_handler_, OnSessionClosed(_))
 461       .InSequence(s);
 462
 463   // These events should not get through to the input stub,
 464   // because the client isn't authenticated yet.
 465   connection_->input_stub()->InjectKeyEvent(key_event1);
 466   connection_->input_stub()->InjectMouseEvent(mouse_event1);
 467
 468   ConnectClientSession();
 469 }
 470
 471 TEST_F(ClientSessionTest, LocalInputTest) {
 472   CreateClientSession();
 473
 474   protocol::MouseEvent mouse_event1;
 475   mouse_event1.set_x(100);
 476   mouse_event1.set_y(101);
 477   protocol::MouseEvent mouse_event2;
 478   mouse_event2.set_x(200);
 479   mouse_event2.set_y(201);
 480   protocol::MouseEvent mouse_event3;
 481   mouse_event3.set_x(300);
 482   mouse_event3.set_y(301);
 483
 484   Expectation authenticated =
 485       EXPECT_CALL(session_event_handler_, OnSessionAuthenticated(_))
 486           .WillOnce(Return(true));
 487   EXPECT_CALL(*input_injector_, StartPtr(_))
 488       .After(authenticated);
 489   EXPECT_CALL(session_event_handler_, OnSessionChannelsConnected(_))
 490       .After(authenticated);
 491
 492   // Wait for the first video packet to be captured to make sure that
 493   // the injected input will go though. Otherwise mouse events will be blocked
 494   // by the mouse clamping filter.
 495   Sequence s;
 496   EXPECT_CALL(video_stub_, ProcessVideoPacketPtr(_, _))
 497       .InSequence(s)
 498       .After(authenticated)
 499       .WillOnce(DoAll(
 500           // This event should get through to the input stub.
 501           InjectMouseEvent(connection_, mouse_event1),
 502 #if !defined(OS_WIN)
 503           // The OS echoes the injected event back.
 504           LocalMouseMoved(client_session_.get(), mouse_event1),
 505 #endif  // !defined(OS_WIN)
 506           // This one should get throught as well.
 507           InjectMouseEvent(connection_, mouse_event2),
 508           // Now this is a genuine local event.
 509           LocalMouseMoved(client_session_.get(), mouse_event1),
 510           // This one should be blocked because of the previous  local input
 511           // event.
 512           InjectMouseEvent(connection_, mouse_event3),
 513           // TODO(jamiewalch): Verify that remote inputs are re-enabled
 514           // eventually (via dependency injection, not sleep!)
 515           InvokeWithoutArgs(this, &ClientSessionTest::DisconnectClientSession),
 516           InvokeWithoutArgs(this, &ClientSessionTest::StopClientSession)));
 517   EXPECT_CALL(*input_injector_, InjectMouseEvent(EqualsMouseEvent(100, 101)))
 518       .InSequence(s);
 519   EXPECT_CALL(*input_injector_, InjectMouseEvent(EqualsMouseEvent(200, 201)))
 520       .InSequence(s);
 521   EXPECT_CALL(session_event_handler_, OnSessionClosed(_))
 522       .InSequence(s);
 523
 524   ConnectClientSession();
 525 }
 526
 527 TEST_F(ClientSessionTest, RestoreEventState) {
 528   CreateClientSession();
 529
 530   protocol::KeyEvent key1;
 531   key1.set_pressed(true);
 532   key1.set_usb_keycode(1);
 533
 534   protocol::KeyEvent key2;
 535   key2.set_pressed(true);
 536   key2.set_usb_keycode(2);
 537
 538   protocol::MouseEvent mousedown;
 539   mousedown.set_button(protocol::MouseEvent::BUTTON_LEFT);
 540   mousedown.set_button_down(true);
 541
 542   Expectation authenticated =
 543       EXPECT_CALL(session_event_handler_, OnSessionAuthenticated(_))
 544           .WillOnce(Return(true));
 545   EXPECT_CALL(*input_injector_, StartPtr(_))
 546       .After(authenticated);
 547   EXPECT_CALL(session_event_handler_, OnSessionChannelsConnected(_))
 548       .After(authenticated);
 549
 550   // Wait for the first video packet to be captured to make sure that
 551   // the injected input will go though. Otherwise mouse events will be blocked
 552   // by the mouse clamping filter.
 553   Sequence s;
 554   EXPECT_CALL(video_stub_, ProcessVideoPacketPtr(_, _))
 555       .InSequence(s)
 556       .After(authenticated)
 557       .WillOnce(DoAll(
 558           InjectKeyEvent(connection_, key1),
 559           InjectKeyEvent(connection_, key2),
 560           InjectMouseEvent(connection_, mousedown),
 561           InvokeWithoutArgs(this, &ClientSessionTest::DisconnectClientSession),
 562           InvokeWithoutArgs(this, &ClientSessionTest::StopClientSession)));
 563   EXPECT_CALL(*input_injector_, InjectKeyEvent(EqualsUsbEvent(1, true)))
 564       .InSequence(s);
 565   EXPECT_CALL(*input_injector_, InjectKeyEvent(EqualsUsbEvent(2, true)))
 566       .InSequence(s);
 567   EXPECT_CALL(*input_injector_, InjectMouseEvent(EqualsMouseButtonEvent(
 568       protocol::MouseEvent::BUTTON_LEFT, true)))
 569       .InSequence(s);
 570   EXPECT_CALL(*input_injector_, InjectKeyEvent(EqualsUsbEvent(1, false)))
 571       .InSequence(s);
 572   EXPECT_CALL(*input_injector_, InjectKeyEvent(EqualsUsbEvent(2, false)))
 573       .InSequence(s);
 574   EXPECT_CALL(*input_injector_, InjectMouseEvent(EqualsMouseButtonEvent(
 575       protocol::MouseEvent::BUTTON_LEFT, false)))
 576       .InSequence(s);
 577   EXPECT_CALL(session_event_handler_, OnSessionClosed(_))
 578       .InSequence(s);
 579
 580   ConnectClientSession();
 581 }
 582
 583 TEST_F(ClientSessionTest, ClampMouseEvents) {
 584   CreateClientSession();
 585
 586   Expectation authenticated =
 587       EXPECT_CALL(session_event_handler_, OnSessionAuthenticated(_))
 588           .WillOnce(Return(true));
 589   EXPECT_CALL(*input_injector_, StartPtr(_))
 590       .After(authenticated);
 591   EXPECT_CALL(session_event_handler_, OnSessionChannelsConnected(_))
 592       .After(authenticated);
 593   EXPECT_CALL(session_event_handler_, OnSessionClosed(_))
 594       .After(authenticated);
 595
 596   Expectation connected = authenticated;
 597
 598   int input_x[3] = { -999, 100, 999 };
 599   int expected_x[3] = { 0, 100, FakeDesktopCapturer::kWidth - 1 };
 600   int input_y[3] = { -999, 50, 999 };
 601   int expected_y[3] = { 0, 50, FakeDesktopCapturer::kHeight - 1 };
 602
 603   protocol::MouseEvent expected_event;
 604   for (int j = 0; j < 3; j++) {
 605     for (int i = 0; i < 3; i++) {
 606       protocol::MouseEvent injected_event;
 607       injected_event.set_x(input_x[i]);
 608       injected_event.set_y(input_y[j]);
 609
 610       if (i == 0 && j == 0) {
 611         // Inject the 1st event once a video packet has been received.
 612         connected =
 613             EXPECT_CALL(video_stub_, ProcessVideoPacketPtr(_, _))
 614                 .After(connected)
 615                 .WillOnce(InjectMouseEvent(connection_, injected_event));
 616       } else {
 617         // Every next event is injected once the previous event has been
 618         // received.
 619         connected =
 620             EXPECT_CALL(*input_injector_,
 621                         InjectMouseEvent(EqualsMouseEvent(expected_event.x(),
 622                                                           expected_event.y())))
 623                 .After(connected)
 624                 .WillOnce(InjectMouseEvent(connection_, injected_event));
 625       }
 626
 627       expected_event.set_x(expected_x[i]);
 628       expected_event.set_y(expected_y[j]);
 629     }
 630   }
 631
 632   // Shutdown the connection once the last event has been received.
 633   EXPECT_CALL(*input_injector_,
 634               InjectMouseEvent(EqualsMouseEvent(expected_event.x(),
 635                                                 expected_event.y())))
 636       .After(connected)
 637       .WillOnce(DoAll(
 638           InvokeWithoutArgs(this, &ClientSessionTest::DisconnectClientSession),
 639           InvokeWithoutArgs(this, &ClientSessionTest::StopClientSession)));
 640
 641   ConnectClientSession();
 642 }
 643
 644 TEST_F(ClientSessionTest, NoGnubbyAuth) {
 645   CreateClientSession();
 646
 647   protocol::ExtensionMessage message;
 648   message.set_type("gnubby-auth");
 649   message.set_data("test");
 650
 651   Expectation authenticated =
 652       EXPECT_CALL(session_event_handler_, OnSessionAuthenticated(_))
 653           .WillOnce(Return(true));
 654   EXPECT_CALL(*input_injector_, StartPtr(_)).After(authenticated);
 655   EXPECT_CALL(session_event_handler_, OnSessionChannelsConnected(_))
 656       .After(authenticated)
 657       .WillOnce(DoAll(
 658            DeliverClientMessage(client_session_.get(), message),
 659            InvokeWithoutArgs(this, &ClientSessionTest::DisconnectClientSession),
 660            InvokeWithoutArgs(this, &ClientSessionTest::StopClientSession)));
 661   EXPECT_CALL(session_event_handler_, OnSessionClosed(_));
 662
 663   ConnectClientSession();
 664 }
 665
 666 TEST_F(ClientSessionTest, EnableGnubbyAuth) {
 667   CreateClientSession();
 668
 669   // Lifetime controlled by object under test.
 670   MockGnubbyAuthHandler* gnubby_auth_handler = new MockGnubbyAuthHandler();
 671
 672   protocol::ExtensionMessage message;
 673   message.set_type("gnubby-auth");
 674   message.set_data("test");
 675
 676   Expectation authenticated =
 677       EXPECT_CALL(session_event_handler_, OnSessionAuthenticated(_))
 678           .WillOnce(Return(true));
 679   EXPECT_CALL(*input_injector_, StartPtr(_)).After(authenticated);
 680   EXPECT_CALL(session_event_handler_, OnSessionChannelsConnected(_))
 681       .After(authenticated)
 682       .WillOnce(DoAll(
 683            SetGnubbyAuthHandlerForTesting(client_session_.get(),
 684                                           gnubby_auth_handler),
 685            DeliverClientMessage(client_session_.get(), message),
 686            InvokeWithoutArgs(this, &ClientSessionTest::DisconnectClientSession),
 687            InvokeWithoutArgs(this, &ClientSessionTest::StopClientSession)));
 688   EXPECT_CALL(*gnubby_auth_handler, DeliverClientMessage(_));
 689   EXPECT_CALL(session_event_handler_, OnSessionClosed(_));
 690
 691   ConnectClientSession();
 692 }
 693
 694 // Verifies that the client's video pipeline can be reset mid-session.
 695 TEST_F(ClientSessionTest, ResetVideoPipeline) {
 696   CreateClientSession();
 697
 698   EXPECT_CALL(session_event_handler_, OnSessionAuthenticated(_))
 699       .WillOnce(Return(true));
 700
 701   EXPECT_CALL(video_stub_, ProcessVideoPacketPtr(_, _))
 702       .WillOnce(DoAll(
 703           InvokeWithoutArgs(this, &ClientSessionTest::DisconnectClientSession),
 704           InvokeWithoutArgs(this, &ClientSessionTest::StopClientSession)));
 705
 706   ConnectClientSession();
 707
 708   client_session_->ResetVideoPipeline();
 709 }
 710
 711 // Verifies that clients can have extensions registered, resulting in the
 712 // correct capabilities being reported, and messages delivered correctly.
 713 // The extension system is tested more extensively in the
 714 // HostExtensionSessionManager unit-tests.
 715 TEST_F(ClientSessionTest, Extensions) {
 716   // Configure fake extensions for testing.
 717   FakeExtension extension1("ext1", "cap1");
 718   extensions_.push_back(&extension1);
 719   FakeExtension extension2("ext2", "");
 720   extensions_.push_back(&extension2);
 721   FakeExtension extension3("ext3", "cap3");
 722   extensions_.push_back(&extension3);
 723
 724   // Set the second extension to request to modify the video pipeline.
 725   extension2.set_steal_video_capturer(true);
 726
 727   CreateClientSession();
 728
 729   Expectation authenticated =
 730       EXPECT_CALL(session_event_handler_, OnSessionAuthenticated(_))
 731           .WillOnce(Return(true));
 732
 733   // Verify that the ClientSession reports the correct capabilities, and mimic
 734   // the client reporting an overlapping set of capabilities.
 735   EXPECT_CALL(client_stub_,
 736               SetCapabilities(EqCapabilities("cap1 cap3 default")))
 737       .After(authenticated)
 738       .WillOnce(SetCapabilities(client_session_.get(), "cap1 cap4 default"));
 739
 740   // Verify that the correct extension messages are delivered, and dropped.
 741   protocol::ExtensionMessage message1;
 742   message1.set_type("ext1");
 743   message1.set_data("data");
 744   protocol::ExtensionMessage message3;
 745   message3.set_type("ext3");
 746   message3.set_data("data");
 747   protocol::ExtensionMessage message4;
 748   message4.set_type("ext4");
 749   message4.set_data("data");
 750   EXPECT_CALL(session_event_handler_, OnSessionChannelsConnected(_))
 751       .WillOnce(DoAll(
 752           DeliverClientMessage(client_session_.get(), message1),
 753           DeliverClientMessage(client_session_.get(), message3),
 754           DeliverClientMessage(client_session_.get(), message4),
 755           InvokeWithoutArgs(this, &ClientSessionTest::DisconnectClientSession),
 756           InvokeWithoutArgs(this, &ClientSessionTest::StopClientSession)));
 757
 758   // Simulate the ClientSession connect and extension negotiation.
 759   ConnectClientSession();
 760   base::RunLoop().RunUntilIdle();
 761
 762   // ext1 was instantiated and sent a message, and did not wrap anything.
 763   EXPECT_TRUE(extension1.was_instantiated());
 764   EXPECT_TRUE(extension1.has_handled_message());
 765   EXPECT_FALSE(extension1.has_wrapped_video_encoder());
 766
 767   // ext2 was instantiated but not sent a message, and wrapped video encoder.
 768   EXPECT_TRUE(extension2.was_instantiated());
 769   EXPECT_FALSE(extension2.has_handled_message());
 770   EXPECT_TRUE(extension2.has_wrapped_video_encoder());
 771
 772   // ext3 was sent a message but not instantiated.
 773   EXPECT_FALSE(extension3.was_instantiated());
 774 }
 775
 776 // Verifies that an extension can "steal" the video capture, in which case no
 777 // VideoScheduler is instantiated.
 778 TEST_F(ClientSessionTest, StealVideoCapturer) {
 779   FakeExtension extension("ext1", "cap1");
 780   extensions_.push_back(&extension);
 781
 782   CreateClientSession();
 783
 784   SetMatchCapabilitiesExpectation();
 785
 786   EXPECT_CALL(session_event_handler_, OnSessionAuthenticated(_))
 787       .WillOnce(Return(true));
 788
 789   ConnectClientSession();
 790
 791   base::RunLoop().RunUntilIdle();
 792
 793   extension.set_steal_video_capturer(true);
 794   client_session_->ResetVideoPipeline();
 795
 796   base::RunLoop().RunUntilIdle();
 797
 798   // Verify that video control messages received while there is no video
 799   // scheduler active won't crash things.
 800   protocol::VideoControl video_control;
 801   video_control.set_enable(false);
 802   video_control.set_lossless_encode(true);
 803   video_control.set_lossless_color(true);
 804   client_session_->ControlVideo(video_control);
 805
 806   // TODO(wez): Find a way to verify that the ClientSession never captures any
 807   // frames in this case.
 808
 809   DisconnectClientSession();
 810   StopClientSession();
 811
 812   // ext1 was instantiated and wrapped the video capturer.
 813   EXPECT_TRUE(extension.was_instantiated());
 814   EXPECT_TRUE(extension.has_wrapped_video_capturer());
 815 }
 816
 817 }  // namespace remoting