Rename EventExecutor to InputInjector.

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 "media/video/capture/screen/screen_capturer_fake.h"
 #include "media/video/capture/screen/screen_capturer_mock_objects.h"
 #include "remoting/base/auto_thread_task_runner.h"
 #include "remoting/base/constants.h"
 #include "remoting/host/audio_capturer.h"
@@ skipping 53 matching lines @@
   void DisconnectClientSession();
 
   // Stops and releases the ClientSession, allowing the MessageLoop to quit.
   void StopClientSession();
 
  protected:
   // Creates a DesktopEnvironment with a fake media::ScreenCapturer, to mock
   // DesktopEnvironmentFactory::Create().
   DesktopEnvironment* CreateDesktopEnvironment();
 
-  // Returns |event_executor_| created and initialized by SetUp(), to mock
-  // DesktopEnvironment::CreateEventExecutor().
-  EventExecutor* CreateEventExecutor(
+  // Returns |input_injector_| created and initialized by SetUp(), to mock
+  // DesktopEnvironment::CreateInputInjector().
+  InputInjector* CreateInputInjector(
       scoped_refptr<base::SingleThreadTaskRunner> input_task_runner,
       scoped_refptr<base::SingleThreadTaskRunner> ui_task_runner);
 
   // Creates a dummy SessionController, to mock
   // DesktopEnvironment::CreateSessionController().
   SessionController* CreateSessionController();
 
   // Creates a fake media::ScreenCapturer, to mock
   // DesktopEnvironment::CreateVideoCapturer().
   media::ScreenCapturer* CreateVideoCapturer(
@@ skipping 19 matching lines @@
   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
+  // DesktopEnvironment owns |input_injector_|, but input injection tests need
   // to express expectations on it.
-  scoped_ptr<MockEventExecutor> event_executor_;
+  scoped_ptr<MockInputInjector> input_injector_;
 
   // 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());
+  input_injector_.reset(new MockInputInjector());
 
   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.
@@ skipping 35 matching lines @@
 void ClientSessionTest::StopClientSession() {
   client_session_.reset();
 
   desktop_environment_factory_.reset();
 }
 
 DesktopEnvironment* ClientSessionTest::CreateDesktopEnvironment() {
   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, CreateInputInjectorPtr(_, _))
+      .WillOnce(Invoke(this, &ClientSessionTest::CreateInputInjector));
   EXPECT_CALL(*desktop_environment, CreateSessionControllerPtr())
       .WillOnce(Invoke(this, &ClientSessionTest::CreateSessionController));
   EXPECT_CALL(*desktop_environment, CreateVideoCapturerPtr(_, _))
       .WillOnce(Invoke(this, &ClientSessionTest::CreateVideoCapturer));
 
   return desktop_environment;
 }
 
-EventExecutor* ClientSessionTest::CreateEventExecutor(
+InputInjector* ClientSessionTest::CreateInputInjector(
     scoped_refptr<base::SingleThreadTaskRunner> input_task_runner,
     scoped_refptr<base::SingleThreadTaskRunner> ui_task_runner) {
-  EXPECT_TRUE(event_executor_);
-  return event_executor_.release();
+  EXPECT_TRUE(input_injector_);
+  return input_injector_.release();
 }
 
 SessionController* ClientSessionTest::CreateSessionController() {
   return new MockSessionController();
 }
 
 media::ScreenCapturer* ClientSessionTest::CreateVideoCapturer(
     scoped_refptr<base::SingleThreadTaskRunner> capture_task_runner,
     scoped_refptr<base::SingleThreadTaskRunner> encode_task_runner) {
   return new media::ScreenCapturerFake();
@@ skipping 21 matching lines @@
   protocol::ClipboardEvent clipboard_event2;
   clipboard_event2.set_mime_type(kMimeTypeTextUtf8);
   clipboard_event2.set_data("b");
 
   protocol::ClipboardEvent clipboard_event3;
   clipboard_event3.set_mime_type(kMimeTypeTextUtf8);
   clipboard_event3.set_data("c");
 
   Expectation authenticated =
       EXPECT_CALL(session_event_handler_, OnSessionAuthenticated(_));
-  EXPECT_CALL(*event_executor_, StartPtr(_))
+  EXPECT_CALL(*input_injector_, StartPtr(_))
       .After(authenticated);
   EXPECT_CALL(session_event_handler_, OnSessionChannelsConnected(_))
       .After(authenticated);
 
   // 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.
   Sequence s;
   EXPECT_CALL(video_stub_, ProcessVideoPacketPtr(_, _))
       .InSequence(s)
       .After(authenticated)
       .WillOnce(DoAll(
           // This event should get through to the clipboard stub.
           InjectClipboardEvent(connection_, clipboard_event2),
           InvokeWithoutArgs(this, &ClientSessionTest::DisconnectClientSession),
           // This event should not get through to the clipboard stub,
           // because the client has disconnected.
           InjectClipboardEvent(connection_, clipboard_event3),
           InvokeWithoutArgs(this, &ClientSessionTest::StopClientSession)));
-  EXPECT_CALL(*event_executor_, InjectClipboardEvent(EqualsClipboardEvent(
+  EXPECT_CALL(*input_injector_, InjectClipboardEvent(EqualsClipboardEvent(
       kMimeTypeTextUtf8, "b")))
       .InSequence(s);
   EXPECT_CALL(session_event_handler_, OnSessionClosed(_))
       .InSequence(s);
 
   // This event should not get through to the clipboard stub,
   // because the client isn't authenticated yet.
   connection_->clipboard_stub()->InjectClipboardEvent(clipboard_event1);
 
   ConnectClientSession();
@@ skipping 37 matching lines @@
   protocol::MouseEvent mouse_event2;
   mouse_event2.set_x(200);
   mouse_event2.set_y(201);
 
   protocol::MouseEvent mouse_event3;
   mouse_event3.set_x(300);
   mouse_event3.set_y(301);
 
   Expectation authenticated =
       EXPECT_CALL(session_event_handler_, OnSessionAuthenticated(_));
-  EXPECT_CALL(*event_executor_, StartPtr(_))
+  EXPECT_CALL(*input_injector_, StartPtr(_))
       .After(authenticated);
   EXPECT_CALL(session_event_handler_, OnSessionChannelsConnected(_))
       .After(authenticated);
 
   // 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.
   Sequence s;
   EXPECT_CALL(video_stub_, ProcessVideoPacketPtr(_, _))
       .InSequence(s)
       .After(authenticated)
       .WillOnce(DoAll(
           // These events should get through to the input stub.
           InjectKeyEvent(connection_, key_event2_down),
           InjectKeyEvent(connection_, key_event2_up),
           InjectMouseEvent(connection_, mouse_event2),
           InvokeWithoutArgs(this, &ClientSessionTest::DisconnectClientSession),
           // These events should not get through to the input stub,
           // because the client has disconnected.
           InjectKeyEvent(connection_, key_event3),
           InjectMouseEvent(connection_, mouse_event3),
           InvokeWithoutArgs(this, &ClientSessionTest::StopClientSession)));
-  EXPECT_CALL(*event_executor_, InjectKeyEvent(EqualsUsbEvent(2, true)))
+  EXPECT_CALL(*input_injector_, InjectKeyEvent(EqualsUsbEvent(2, true)))
       .InSequence(s);
-  EXPECT_CALL(*event_executor_, InjectKeyEvent(EqualsUsbEvent(2, false)))
+  EXPECT_CALL(*input_injector_, InjectKeyEvent(EqualsUsbEvent(2, false)))
       .InSequence(s);
-  EXPECT_CALL(*event_executor_, InjectMouseEvent(EqualsMouseEvent(200, 201)))
+  EXPECT_CALL(*input_injector_, InjectMouseEvent(EqualsMouseEvent(200, 201)))
       .InSequence(s);
   EXPECT_CALL(session_event_handler_, OnSessionClosed(_))
       .InSequence(s);
 
   // These events should not get through to the input stub,
   // because the client isn't authenticated yet.
   connection_->input_stub()->InjectKeyEvent(key_event1);
   connection_->input_stub()->InjectMouseEvent(mouse_event1);
 
   ConnectClientSession();
   message_loop_.Run();
 }
 
 TEST_F(ClientSessionTest, LocalInputTest) {
   protocol::MouseEvent mouse_event1;
   mouse_event1.set_x(100);
   mouse_event1.set_y(101);
   protocol::MouseEvent mouse_event2;
   mouse_event2.set_x(200);
   mouse_event2.set_y(201);
   protocol::MouseEvent mouse_event3;
   mouse_event3.set_x(300);
   mouse_event3.set_y(301);
 
   Expectation authenticated =
       EXPECT_CALL(session_event_handler_, OnSessionAuthenticated(_));
-  EXPECT_CALL(*event_executor_, StartPtr(_))
+  EXPECT_CALL(*input_injector_, StartPtr(_))
       .After(authenticated);
   EXPECT_CALL(session_event_handler_, OnSessionChannelsConnected(_))
       .After(authenticated);
 
   // 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.
   Sequence s;
   EXPECT_CALL(video_stub_, ProcessVideoPacketPtr(_, _))
       .InSequence(s)
       .After(authenticated)
       .WillOnce(DoAll(
           // This event should get through to the input stub.
           InjectMouseEvent(connection_, mouse_event1),
 #if !defined(OS_WIN)
           // The OS echoes the injected event back.
           LocalMouseMoved(client_session_.get(), mouse_event1),
 #endif  // !defined(OS_WIN)
           // This one should get throught as well.
           InjectMouseEvent(connection_, mouse_event2),
           // Now this is a genuine local event.
           LocalMouseMoved(client_session_.get(), mouse_event1),
           // This one should be blocked because of the previous  local input
           // event.
           InjectMouseEvent(connection_, mouse_event3),
           // TODO(jamiewalch): Verify that remote inputs are re-enabled
           // eventually (via dependency injection, not sleep!)
           InvokeWithoutArgs(this, &ClientSessionTest::DisconnectClientSession),
           InvokeWithoutArgs(this, &ClientSessionTest::StopClientSession)));
-  EXPECT_CALL(*event_executor_, InjectMouseEvent(EqualsMouseEvent(100, 101)))
+  EXPECT_CALL(*input_injector_, InjectMouseEvent(EqualsMouseEvent(100, 101)))
       .InSequence(s);
-  EXPECT_CALL(*event_executor_, InjectMouseEvent(EqualsMouseEvent(200, 201)))
+  EXPECT_CALL(*input_injector_, InjectMouseEvent(EqualsMouseEvent(200, 201)))
       .InSequence(s);
   EXPECT_CALL(session_event_handler_, OnSessionClosed(_))
       .InSequence(s);
 
   ConnectClientSession();
   message_loop_.Run();
 }
 
 TEST_F(ClientSessionTest, RestoreEventState) {
   protocol::KeyEvent key1;
   key1.set_pressed(true);
   key1.set_usb_keycode(1);
 
   protocol::KeyEvent key2;
   key2.set_pressed(true);
   key2.set_usb_keycode(2);
 
   protocol::MouseEvent mousedown;
   mousedown.set_button(protocol::MouseEvent::BUTTON_LEFT);
   mousedown.set_button_down(true);
 
   Expectation authenticated =
       EXPECT_CALL(session_event_handler_, OnSessionAuthenticated(_));
-  EXPECT_CALL(*event_executor_, StartPtr(_))
+  EXPECT_CALL(*input_injector_, StartPtr(_))
       .After(authenticated);
   EXPECT_CALL(session_event_handler_, OnSessionChannelsConnected(_))
       .After(authenticated);
 
   // 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.
   Sequence s;
   EXPECT_CALL(video_stub_, ProcessVideoPacketPtr(_, _))
       .InSequence(s)
       .After(authenticated)
       .WillOnce(DoAll(
           InjectKeyEvent(connection_, key1),
           InjectKeyEvent(connection_, key2),
           InjectMouseEvent(connection_, mousedown),
           InvokeWithoutArgs(this, &ClientSessionTest::DisconnectClientSession),
           InvokeWithoutArgs(this, &ClientSessionTest::StopClientSession)));
-  EXPECT_CALL(*event_executor_, InjectKeyEvent(EqualsUsbEvent(1, true)))
+  EXPECT_CALL(*input_injector_, InjectKeyEvent(EqualsUsbEvent(1, true)))
       .InSequence(s);
-  EXPECT_CALL(*event_executor_, InjectKeyEvent(EqualsUsbEvent(2, true)))
+  EXPECT_CALL(*input_injector_, InjectKeyEvent(EqualsUsbEvent(2, true)))
       .InSequence(s);
-  EXPECT_CALL(*event_executor_, InjectMouseEvent(EqualsMouseButtonEvent(
+  EXPECT_CALL(*input_injector_, InjectMouseEvent(EqualsMouseButtonEvent(
       protocol::MouseEvent::BUTTON_LEFT, true)))
       .InSequence(s);
-  EXPECT_CALL(*event_executor_, InjectKeyEvent(EqualsUsbEvent(1, false)))
+  EXPECT_CALL(*input_injector_, InjectKeyEvent(EqualsUsbEvent(1, false)))
       .InSequence(s);
-  EXPECT_CALL(*event_executor_, InjectKeyEvent(EqualsUsbEvent(2, false)))
+  EXPECT_CALL(*input_injector_, InjectKeyEvent(EqualsUsbEvent(2, false)))
       .InSequence(s);
-  EXPECT_CALL(*event_executor_, InjectMouseEvent(EqualsMouseButtonEvent(
+  EXPECT_CALL(*input_injector_, InjectMouseEvent(EqualsMouseButtonEvent(
       protocol::MouseEvent::BUTTON_LEFT, false)))
       .InSequence(s);
   EXPECT_CALL(session_event_handler_, OnSessionClosed(_))
       .InSequence(s);
 
   ConnectClientSession();
   message_loop_.Run();
 }
 
 TEST_F(ClientSessionTest, ClampMouseEvents) {
   Expectation authenticated =
       EXPECT_CALL(session_event_handler_, OnSessionAuthenticated(_));
-  EXPECT_CALL(*event_executor_, StartPtr(_))
+  EXPECT_CALL(*input_injector_, StartPtr(_))
       .After(authenticated);
   EXPECT_CALL(session_event_handler_, OnSessionChannelsConnected(_))
       .After(authenticated);
   EXPECT_CALL(session_event_handler_, OnSessionClosed(_))
       .After(authenticated);
 
   Expectation connected = authenticated;
 
   int input_x[3] = { -999, 100, 999 };
   int expected_x[3] = { 0, 100, media::ScreenCapturerFake::kWidth - 1 };
@@ skipping 10 matching lines @@
       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_,
+            EXPECT_CALL(*input_injector_,
                         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_,
+  EXPECT_CALL(*input_injector_,
               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