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 "base/message_loop/message_loop.h" 6 #include "remoting/base/auto_thread_task_runner.h" 7 #include "remoting/base/constants.h" 8 #include "remoting/host/audio_capturer.h" 9 #include "remoting/host/client_session.h" 10 #include "remoting/host/desktop_environment.h" 11 #include "remoting/host/host_mock_objects.h" 12 #include "remoting/host/screen_capturer_fake.h" 13 #include "remoting/protocol/protocol_mock_objects.h" 14 #include "testing/gtest/include/gtest/gtest.h" 15 #include "third_party/webrtc/modules/desktop_capture/desktop_region.h" 16 #include "third_party/webrtc/modules/desktop_capture/screen_capturer_mock_objects.h" 17 18 namespace remoting { 19 20 using protocol::MockConnectionToClient; 21 using protocol::MockClientStub; 22 using protocol::MockHostStub; 23 using protocol::MockInputStub; 24 using protocol::MockSession; 25 using protocol::MockVideoStub; 26 using protocol::SessionConfig; 27 28 using testing::_; 29 using testing::AnyNumber; 30 using testing::AtMost; 31 using testing::DeleteArg; 32 using testing::DoAll; 33 using testing::Expectation; 34 using testing::Return; 35 using testing::ReturnRef; 36 using testing::Sequence; 37 38 namespace { 39 40 ACTION_P2(InjectClipboardEvent, connection, event) { 41 connection->clipboard_stub()->InjectClipboardEvent(event); 42 } 43 44 ACTION_P2(InjectKeyEvent, connection, event) { 45 connection->input_stub()->InjectKeyEvent(event); 46 } 47 48 ACTION_P2(InjectMouseEvent, connection, event) { 49 connection->input_stub()->InjectMouseEvent(event); 50 } 51 52 ACTION_P2(LocalMouseMoved, client_session, event) { 53 client_session->OnLocalMouseMoved(SkIPoint::Make(event.x(), event.y())); 54 } 55 56 } // namespace 57 58 class ClientSessionTest : public testing::Test { 59 public: 60 ClientSessionTest() : client_jid_("user@domain/rest-of-jid") {} 61 62 virtual void SetUp() OVERRIDE; 63 virtual void TearDown() OVERRIDE; 64 65 // Disconnects the client session. 66 void DisconnectClientSession(); 67 68 // Stops and releases the ClientSession, allowing the MessageLoop to quit. 69 void StopClientSession(); 70 71 protected: 72 // Creates a DesktopEnvironment with a fake webrtc::ScreenCapturer, to mock 73 // DesktopEnvironmentFactory::Create(). 74 DesktopEnvironment* CreateDesktopEnvironment(); 75 76 // Returns |input_injector_| created and initialized by SetUp(), to mock 77 // DesktopEnvironment::CreateInputInjector(). 78 InputInjector* CreateInputInjector(); 79 80 // Creates a fake webrtc::ScreenCapturer, to mock 81 // DesktopEnvironment::CreateVideoCapturer(). 82 webrtc::ScreenCapturer* CreateVideoCapturer(); 83 84 // Notifies the client session that the client connection has been 85 // authenticated and channels have been connected. This effectively enables 86 // the input pipe line and starts video capturing. 87 void ConnectClientSession(); 88 89 // Invoked when the last reference to the AutoThreadTaskRunner has been 90 // released and quits the message loop to finish the test. 91 void QuitMainMessageLoop(); 92 93 // Message loop passed to |client_session_| to perform all functions on. 94 base::MessageLoop message_loop_; 95 96 // ClientSession instance under test. 97 scoped_ptr<ClientSession> client_session_; 98 99 // ClientSession::EventHandler mock for use in tests. 100 MockClientSessionEventHandler session_event_handler_; 101 102 // Storage for values to be returned by the protocol::Session mock. 103 SessionConfig session_config_; 104 const std::string client_jid_; 105 106 // Stubs returned to |client_session_| components by |connection_|. 107 MockClientStub client_stub_; 108 MockVideoStub video_stub_; 109 110 // DesktopEnvironment owns |input_injector_|, but input injection tests need 111 // to express expectations on it. 112 scoped_ptr<MockInputInjector> input_injector_; 113 114 // ClientSession owns |connection_| but tests need it to inject fake events. 115 MockConnectionToClient* connection_; 116 117 scoped_ptr<MockDesktopEnvironmentFactory> desktop_environment_factory_; 118 }; 119 120 void ClientSessionTest::SetUp() { 121 // Arrange to run |message_loop_| until no components depend on it. 122 scoped_refptr<AutoThreadTaskRunner> ui_task_runner = new AutoThreadTaskRunner( 123 message_loop_.message_loop_proxy(), 124 base::Bind(&ClientSessionTest::QuitMainMessageLoop, 125 base::Unretained(this))); 126 127 desktop_environment_factory_.reset(new MockDesktopEnvironmentFactory()); 128 EXPECT_CALL(*desktop_environment_factory_, CreatePtr()) 129 .Times(AnyNumber()) 130 .WillRepeatedly(Invoke(this, 131 &ClientSessionTest::CreateDesktopEnvironment)); 132 EXPECT_CALL(*desktop_environment_factory_, SupportsAudioCapture()) 133 .Times(AnyNumber()) 134 .WillRepeatedly(Return(false)); 135 136 input_injector_.reset(new MockInputInjector()); 137 138 session_config_ = SessionConfig::ForTest(); 139 140 // Mock protocol::Session APIs called directly by ClientSession. 141 protocol::MockSession* session = new MockSession(); 142 EXPECT_CALL(*session, config()).WillRepeatedly(ReturnRef(session_config_)); 143 EXPECT_CALL(*session, jid()).WillRepeatedly(ReturnRef(client_jid_)); 144 EXPECT_CALL(*session, SetEventHandler(_)); 145 146 // Mock protocol::ConnectionToClient APIs called directly by ClientSession. 147 // HostStub is not touched by ClientSession, so we can safely pass NULL. 148 scoped_ptr<MockConnectionToClient> connection( 149 new MockConnectionToClient(session, NULL)); 150 EXPECT_CALL(*connection, session()).WillRepeatedly(Return(session)); 151 EXPECT_CALL(*connection, client_stub()) 152 .WillRepeatedly(Return(&client_stub_)); 153 EXPECT_CALL(*connection, video_stub()).WillRepeatedly(Return(&video_stub_)); 154 EXPECT_CALL(*connection, Disconnect()); 155 connection_ = connection.get(); 156 157 client_session_.reset(new ClientSession( 158 &session_event_handler_, 159 ui_task_runner, // Audio thread. 160 ui_task_runner, // Input thread. 161 ui_task_runner, // Capture thread. 162 ui_task_runner, // Encode thread. 163 ui_task_runner, // Network thread. 164 ui_task_runner, // UI thread. 165 connection.PassAs<protocol::ConnectionToClient>(), 166 desktop_environment_factory_.get(), 167 base::TimeDelta(), 168 NULL)); 169 } 170 171 void ClientSessionTest::TearDown() { 172 // Verify that the client session has been stopped. 173 EXPECT_TRUE(!client_session_); 174 } 175 176 void ClientSessionTest::DisconnectClientSession() { 177 client_session_->DisconnectSession(); 178 // MockSession won't trigger OnConnectionClosed, so fake it. 179 client_session_->OnConnectionClosed(client_session_->connection(), 180 protocol::OK); 181 } 182 183 void ClientSessionTest::StopClientSession() { 184 client_session_.reset(); 185 186 desktop_environment_factory_.reset(); 187 } 188 189 DesktopEnvironment* ClientSessionTest::CreateDesktopEnvironment() { 190 MockDesktopEnvironment* desktop_environment = new MockDesktopEnvironment(); 191 EXPECT_CALL(*desktop_environment, CreateAudioCapturerPtr()) 192 .Times(0); 193 EXPECT_CALL(*desktop_environment, CreateInputInjectorPtr()) 194 .WillOnce(Invoke(this, &ClientSessionTest::CreateInputInjector)); 195 EXPECT_CALL(*desktop_environment, CreateScreenControlsPtr()) 196 .Times(AtMost(1)); 197 EXPECT_CALL(*desktop_environment, CreateVideoCapturerPtr()) 198 .WillOnce(Invoke(this, &ClientSessionTest::CreateVideoCapturer)); 199 EXPECT_CALL(*desktop_environment, GetCapabilities()) 200 .Times(AtMost(1)); 201 EXPECT_CALL(*desktop_environment, SetCapabilities(_)) 202 .Times(AtMost(1)); 203 204 return desktop_environment; 205 } 206 207 InputInjector* ClientSessionTest::CreateInputInjector() { 208 EXPECT_TRUE(input_injector_); 209 return input_injector_.release(); 210 } 211 212 webrtc::ScreenCapturer* ClientSessionTest::CreateVideoCapturer() { 213 return new ScreenCapturerFake(); 214 } 215 216 void ClientSessionTest::ConnectClientSession() { 217 client_session_->OnConnectionAuthenticated(client_session_->connection()); 218 client_session_->OnConnectionChannelsConnected(client_session_->connection()); 219 } 220 221 void ClientSessionTest::QuitMainMessageLoop() { 222 message_loop_.PostTask(FROM_HERE, base::MessageLoop::QuitClosure()); 223 } 224 225 MATCHER_P2(EqualsClipboardEvent, m, d, "") { 226 return (strcmp(arg.mime_type().c_str(), m) == 0 && 227 memcmp(arg.data().data(), d, arg.data().size()) == 0); 228 } 229 230 TEST_F(ClientSessionTest, ClipboardStubFilter) { 231 protocol::ClipboardEvent clipboard_event1; 232 clipboard_event1.set_mime_type(kMimeTypeTextUtf8); 233 clipboard_event1.set_data("a"); 234 235 protocol::ClipboardEvent clipboard_event2; 236 clipboard_event2.set_mime_type(kMimeTypeTextUtf8); 237 clipboard_event2.set_data("b"); 238 239 protocol::ClipboardEvent clipboard_event3; 240 clipboard_event3.set_mime_type(kMimeTypeTextUtf8); 241 clipboard_event3.set_data("c"); 242 243 Expectation authenticated = 244 EXPECT_CALL(session_event_handler_, OnSessionAuthenticated(_)) 245 .WillOnce(Return(true)); 246 EXPECT_CALL(*input_injector_, StartPtr(_)) 247 .After(authenticated); 248 EXPECT_CALL(session_event_handler_, OnSessionChannelsConnected(_)) 249 .After(authenticated); 250 251 // Wait for the first video packet to be captured to make sure that 252 // the injected input will go though. Otherwise mouse events will be blocked 253 // by the mouse clamping filter. 254 Sequence s; 255 EXPECT_CALL(video_stub_, ProcessVideoPacketPtr(_, _)) 256 .InSequence(s) 257 .After(authenticated) 258 .WillOnce(DoAll( 259 // This event should get through to the clipboard stub. 260 InjectClipboardEvent(connection_, clipboard_event2), 261 InvokeWithoutArgs(this, &ClientSessionTest::DisconnectClientSession), 262 // This event should not get through to the clipboard stub, 263 // because the client has disconnected. 264 InjectClipboardEvent(connection_, clipboard_event3), 265 InvokeWithoutArgs(this, &ClientSessionTest::StopClientSession))); 266 EXPECT_CALL(*input_injector_, InjectClipboardEvent(EqualsClipboardEvent( 267 kMimeTypeTextUtf8, "b"))) 268 .InSequence(s); 269 EXPECT_CALL(session_event_handler_, OnSessionClosed(_)) 270 .InSequence(s); 271 272 // This event should not get through to the clipboard stub, 273 // because the client isn't authenticated yet. 274 connection_->clipboard_stub()->InjectClipboardEvent(clipboard_event1); 275 276 ConnectClientSession(); 277 message_loop_.Run(); 278 } 279 280 namespace { 281 282 MATCHER_P2(EqualsUsbEvent, usb_keycode, pressed, "") { 283 return arg.usb_keycode() == (unsigned int)usb_keycode && 284 arg.pressed() == pressed; 285 } 286 287 MATCHER_P2(EqualsMouseEvent, x, y, "") { 288 return arg.x() == x && arg.y() == y; 289 } 290 291 MATCHER_P2(EqualsMouseButtonEvent, button, down, "") { 292 return arg.button() == button && arg.button_down() == down; 293 } 294 295 } 296 297 TEST_F(ClientSessionTest, InputStubFilter) { 298 protocol::KeyEvent key_event1; 299 key_event1.set_pressed(true); 300 key_event1.set_usb_keycode(1); 301 302 protocol::KeyEvent key_event2_down; 303 key_event2_down.set_pressed(true); 304 key_event2_down.set_usb_keycode(2); 305 306 protocol::KeyEvent key_event2_up; 307 key_event2_up.set_pressed(false); 308 key_event2_up.set_usb_keycode(2); 309 310 protocol::KeyEvent key_event3; 311 key_event3.set_pressed(true); 312 key_event3.set_usb_keycode(3); 313 314 protocol::MouseEvent mouse_event1; 315 mouse_event1.set_x(100); 316 mouse_event1.set_y(101); 317 318 protocol::MouseEvent mouse_event2; 319 mouse_event2.set_x(200); 320 mouse_event2.set_y(201); 321 322 protocol::MouseEvent mouse_event3; 323 mouse_event3.set_x(300); 324 mouse_event3.set_y(301); 325 326 Expectation authenticated = 327 EXPECT_CALL(session_event_handler_, OnSessionAuthenticated(_)) 328 .WillOnce(Return(true)); 329 EXPECT_CALL(*input_injector_, StartPtr(_)) 330 .After(authenticated); 331 EXPECT_CALL(session_event_handler_, OnSessionChannelsConnected(_)) 332 .After(authenticated); 333 334 // Wait for the first video packet to be captured to make sure that 335 // the injected input will go though. Otherwise mouse events will be blocked 336 // by the mouse clamping filter. 337 Sequence s; 338 EXPECT_CALL(video_stub_, ProcessVideoPacketPtr(_, _)) 339 .InSequence(s) 340 .After(authenticated) 341 .WillOnce(DoAll( 342 // These events should get through to the input stub. 343 InjectKeyEvent(connection_, key_event2_down), 344 InjectKeyEvent(connection_, key_event2_up), 345 InjectMouseEvent(connection_, mouse_event2), 346 InvokeWithoutArgs(this, &ClientSessionTest::DisconnectClientSession), 347 // These events should not get through to the input stub, 348 // because the client has disconnected. 349 InjectKeyEvent(connection_, key_event3), 350 InjectMouseEvent(connection_, mouse_event3), 351 InvokeWithoutArgs(this, &ClientSessionTest::StopClientSession))); 352 EXPECT_CALL(*input_injector_, InjectKeyEvent(EqualsUsbEvent(2, true))) 353 .InSequence(s); 354 EXPECT_CALL(*input_injector_, InjectKeyEvent(EqualsUsbEvent(2, false))) 355 .InSequence(s); 356 EXPECT_CALL(*input_injector_, InjectMouseEvent(EqualsMouseEvent(200, 201))) 357 .InSequence(s); 358 EXPECT_CALL(session_event_handler_, OnSessionClosed(_)) 359 .InSequence(s); 360 361 // These events should not get through to the input stub, 362 // because the client isn't authenticated yet. 363 connection_->input_stub()->InjectKeyEvent(key_event1); 364 connection_->input_stub()->InjectMouseEvent(mouse_event1); 365 366 ConnectClientSession(); 367 message_loop_.Run(); 368 } 369 370 TEST_F(ClientSessionTest, LocalInputTest) { 371 protocol::MouseEvent mouse_event1; 372 mouse_event1.set_x(100); 373 mouse_event1.set_y(101); 374 protocol::MouseEvent mouse_event2; 375 mouse_event2.set_x(200); 376 mouse_event2.set_y(201); 377 protocol::MouseEvent mouse_event3; 378 mouse_event3.set_x(300); 379 mouse_event3.set_y(301); 380 381 Expectation authenticated = 382 EXPECT_CALL(session_event_handler_, OnSessionAuthenticated(_)) 383 .WillOnce(Return(true)); 384 EXPECT_CALL(*input_injector_, StartPtr(_)) 385 .After(authenticated); 386 EXPECT_CALL(session_event_handler_, OnSessionChannelsConnected(_)) 387 .After(authenticated); 388 389 // Wait for the first video packet to be captured to make sure that 390 // the injected input will go though. Otherwise mouse events will be blocked 391 // by the mouse clamping filter. 392 Sequence s; 393 EXPECT_CALL(video_stub_, ProcessVideoPacketPtr(_, _)) 394 .InSequence(s) 395 .After(authenticated) 396 .WillOnce(DoAll( 397 // This event should get through to the input stub. 398 InjectMouseEvent(connection_, mouse_event1), 399 #if !defined(OS_WIN) 400 // The OS echoes the injected event back. 401 LocalMouseMoved(client_session_.get(), mouse_event1), 402 #endif // !defined(OS_WIN) 403 // This one should get throught as well. 404 InjectMouseEvent(connection_, mouse_event2), 405 // Now this is a genuine local event. 406 LocalMouseMoved(client_session_.get(), mouse_event1), 407 // This one should be blocked because of the previous local input 408 // event. 409 InjectMouseEvent(connection_, mouse_event3), 410 // TODO(jamiewalch): Verify that remote inputs are re-enabled 411 // eventually (via dependency injection, not sleep!) 412 InvokeWithoutArgs(this, &ClientSessionTest::DisconnectClientSession), 413 InvokeWithoutArgs(this, &ClientSessionTest::StopClientSession))); 414 EXPECT_CALL(*input_injector_, InjectMouseEvent(EqualsMouseEvent(100, 101))) 415 .InSequence(s); 416 EXPECT_CALL(*input_injector_, InjectMouseEvent(EqualsMouseEvent(200, 201))) 417 .InSequence(s); 418 EXPECT_CALL(session_event_handler_, OnSessionClosed(_)) 419 .InSequence(s); 420 421 ConnectClientSession(); 422 message_loop_.Run(); 423 } 424 425 TEST_F(ClientSessionTest, RestoreEventState) { 426 protocol::KeyEvent key1; 427 key1.set_pressed(true); 428 key1.set_usb_keycode(1); 429 430 protocol::KeyEvent key2; 431 key2.set_pressed(true); 432 key2.set_usb_keycode(2); 433 434 protocol::MouseEvent mousedown; 435 mousedown.set_button(protocol::MouseEvent::BUTTON_LEFT); 436 mousedown.set_button_down(true); 437 438 Expectation authenticated = 439 EXPECT_CALL(session_event_handler_, OnSessionAuthenticated(_)) 440 .WillOnce(Return(true)); 441 EXPECT_CALL(*input_injector_, StartPtr(_)) 442 .After(authenticated); 443 EXPECT_CALL(session_event_handler_, OnSessionChannelsConnected(_)) 444 .After(authenticated); 445 446 // Wait for the first video packet to be captured to make sure that 447 // the injected input will go though. Otherwise mouse events will be blocked 448 // by the mouse clamping filter. 449 Sequence s; 450 EXPECT_CALL(video_stub_, ProcessVideoPacketPtr(_, _)) 451 .InSequence(s) 452 .After(authenticated) 453 .WillOnce(DoAll( 454 InjectKeyEvent(connection_, key1), 455 InjectKeyEvent(connection_, key2), 456 InjectMouseEvent(connection_, mousedown), 457 InvokeWithoutArgs(this, &ClientSessionTest::DisconnectClientSession), 458 InvokeWithoutArgs(this, &ClientSessionTest::StopClientSession))); 459 EXPECT_CALL(*input_injector_, InjectKeyEvent(EqualsUsbEvent(1, true))) 460 .InSequence(s); 461 EXPECT_CALL(*input_injector_, InjectKeyEvent(EqualsUsbEvent(2, true))) 462 .InSequence(s); 463 EXPECT_CALL(*input_injector_, InjectMouseEvent(EqualsMouseButtonEvent( 464 protocol::MouseEvent::BUTTON_LEFT, true))) 465 .InSequence(s); 466 EXPECT_CALL(*input_injector_, InjectKeyEvent(EqualsUsbEvent(1, false))) 467 .InSequence(s); 468 EXPECT_CALL(*input_injector_, InjectKeyEvent(EqualsUsbEvent(2, false))) 469 .InSequence(s); 470 EXPECT_CALL(*input_injector_, InjectMouseEvent(EqualsMouseButtonEvent( 471 protocol::MouseEvent::BUTTON_LEFT, false))) 472 .InSequence(s); 473 EXPECT_CALL(session_event_handler_, OnSessionClosed(_)) 474 .InSequence(s); 475 476 ConnectClientSession(); 477 message_loop_.Run(); 478 } 479 480 TEST_F(ClientSessionTest, ClampMouseEvents) { 481 Expectation authenticated = 482 EXPECT_CALL(session_event_handler_, OnSessionAuthenticated(_)) 483 .WillOnce(Return(true)); 484 EXPECT_CALL(*input_injector_, StartPtr(_)) 485 .After(authenticated); 486 EXPECT_CALL(session_event_handler_, OnSessionChannelsConnected(_)) 487 .After(authenticated); 488 EXPECT_CALL(session_event_handler_, OnSessionClosed(_)) 489 .After(authenticated); 490 491 Expectation connected = authenticated; 492 493 int input_x[3] = { -999, 100, 999 }; 494 int expected_x[3] = { 0, 100, ScreenCapturerFake::kWidth - 1 }; 495 int input_y[3] = { -999, 50, 999 }; 496 int expected_y[3] = { 0, 50, ScreenCapturerFake::kHeight - 1 }; 497 498 protocol::MouseEvent expected_event; 499 for (int j = 0; j < 3; j++) { 500 for (int i = 0; i < 3; i++) { 501 protocol::MouseEvent injected_event; 502 injected_event.set_x(input_x[i]); 503 injected_event.set_y(input_y[j]); 504 505 if (i == 0 && j == 0) { 506 // Inject the 1st event once a video packet has been received. 507 connected = 508 EXPECT_CALL(video_stub_, ProcessVideoPacketPtr(_, _)) 509 .After(connected) 510 .WillOnce(InjectMouseEvent(connection_, injected_event)); 511 } else { 512 // Every next event is injected once the previous event has been 513 // received. 514 connected = 515 EXPECT_CALL(*input_injector_, 516 InjectMouseEvent(EqualsMouseEvent(expected_event.x(), 517 expected_event.y()))) 518 .After(connected) 519 .WillOnce(InjectMouseEvent(connection_, injected_event)); 520 } 521 522 expected_event.set_x(expected_x[i]); 523 expected_event.set_y(expected_y[j]); 524 } 525 } 526 527 // Shutdown the connection once the last event has been received. 528 EXPECT_CALL(*input_injector_, 529 InjectMouseEvent(EqualsMouseEvent(expected_event.x(), 530 expected_event.y()))) 531 .After(connected) 532 .WillOnce(DoAll( 533 InvokeWithoutArgs(this, &ClientSessionTest::DisconnectClientSession), 534 InvokeWithoutArgs(this, &ClientSessionTest::StopClientSession))); 535 536 ConnectClientSession(); 537 message_loop_.Run(); 538 } 539 540 } // namespace remoting 541
