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

[alexeypa (please no reviews), 2013/03/22 21:19:38]

nit: |input_injector_|.

-  // DesktopEnvironment::CreateEventExecutor().
-  EventExecutor* CreateEventExecutor(
+  // 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 21 matching lines @@
   // 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.
-  scoped_ptr<MockEventExecutor> event_executor_;
+  scoped_ptr<MockInputInjector> event_executor_;

[alexeypa (please no reviews), 2013/03/22 21:19:38]

nit: |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());
+  event_executor_.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();
 }
 
 SessionController* ClientSessionTest::CreateSessionController() {
   return new MockSessionController();
 }
 
@@ skipping 312 matching lines @@
       .After(connected)
       .WillOnce(DoAll(
           InvokeWithoutArgs(this, &ClientSessionTest::DisconnectClientSession),
           InvokeWithoutArgs(this, &ClientSessionTest::StopClientSession)));
 
   ConnectClientSession();
   message_loop_.Run();
 }
 
 }  // namespace remoting