Rename EventExecutor to InputInjector.

remoting/host/desktop_session_agent.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 "remoting/host/desktop_session_agent.h"
 
 #include "base/file_util.h"
 #include "base/logging.h"
 #include "ipc/ipc_channel_proxy.h"
 #include "ipc/ipc_message.h"
 #include "ipc/ipc_message_macros.h"
 #include "media/video/capture/screen/screen_capture_data.h"
 #include "remoting/base/auto_thread_task_runner.h"
 #include "remoting/base/constants.h"
 #include "remoting/host/audio_capturer.h"
 #include "remoting/host/chromoting_messages.h"
 #include "remoting/host/desktop_environment.h"
 #include "remoting/host/disconnect_window.h"
-#include "remoting/host/event_executor.h"
+#include "remoting/host/input_injector.h"
 #include "remoting/host/local_input_monitor.h"
 #include "remoting/host/remote_input_filter.h"
 #include "remoting/host/screen_resolution.h"
 #include "remoting/host/session_controller.h"
 #include "remoting/proto/audio.pb.h"
 #include "remoting/proto/control.pb.h"
 #include "remoting/proto/event.pb.h"
 #include "remoting/protocol/clipboard_stub.h"
 #include "remoting/protocol/input_event_tracker.h"
 #include "third_party/skia/include/core/SkRegion.h"
@@ skipping 141 matching lines @@
   SendToNetwork(
       new ChromotingDesktopNetworkMsg_ReleaseSharedBuffer(buffer->id()));
 }
 
 void DesktopSessionAgent::OnStartSessionAgent(
     const std::string& authenticated_jid,
     const ScreenResolution& resolution) {
   DCHECK(caller_task_runner()->BelongsToCurrentThread());
   DCHECK(!started_);
   DCHECK(!audio_capturer_);
-  DCHECK(!event_executor_);
+  DCHECK(!input_injector_);
   DCHECK(!video_capturer_);
 
   started_ = true;
 
   // Create a desktop environment for the new session.
   base::Closure disconnect_session =
       base::Bind(&DesktopSessionAgent::DisconnectSession, this);
   scoped_ptr<DesktopEnvironment> desktop_environment =
       delegate_->desktop_environment_factory().Create(authenticated_jid,
                                                       disconnect_session);
 
   // Create the session controller and set the initial screen resolution.
   session_controller_ = desktop_environment->CreateSessionController();
   SetScreenResolution(resolution);
 
-  // Create the event executor.
-  event_executor_ =
-      desktop_environment->CreateEventExecutor(input_task_runner(),
+  // Create the input injector.
+  input_injector_ =
+      desktop_environment->CreateInputInjector(input_task_runner(),
                                                caller_task_runner());
 
-  // Hook up the input filter
-  input_tracker_.reset(new protocol::InputEventTracker(event_executor_.get()));
+  // Hook up the input filter.
+  input_tracker_.reset(new protocol::InputEventTracker(input_injector_.get()));
   remote_input_filter_.reset(new RemoteInputFilter(input_tracker_.get()));
 
 #if defined(OS_WIN)
   // LocalInputMonitorWin filters out an echo of the injected input before it
   // reaches |remote_input_filter_|.
   remote_input_filter_->SetExpectLocalEcho(false);
 #endif  // defined(OS_WIN)
 
-  // Start the event executor.
+  // Start the input injector.
   scoped_ptr<protocol::ClipboardStub> clipboard_stub(
       new DesktopSesssionClipboardStub(this));
-  event_executor_->Start(clipboard_stub.Pass());
+  input_injector_->Start(clipboard_stub.Pass());
 
   // Create the disconnect window.
   disconnect_window_ = DisconnectWindow::Create(&ui_strings_);
   disconnect_window_->Show(
       disconnect_session,
       authenticated_jid.substr(0, authenticated_jid.find('/')));
 
   // Start monitoring local input.
   local_input_monitor_ = LocalInputMonitor::Create(caller_task_runner_,
                                                    input_task_runner_,
@@ skipping 103 matching lines @@
     // Stop monitoring to local input.
     local_input_monitor_->Stop();
     local_input_monitor_.reset();
 
     remote_input_filter_.reset();
 
     // Ensure that any pressed keys or buttons are released.
     input_tracker_->ReleaseAll();
     input_tracker_.reset();
 
-    event_executor_.reset();
+    input_injector_.reset();
     session_controller_.reset();
 
     // Stop the audio capturer.
     audio_capture_task_runner()->PostTask(
         FROM_HERE, base::Bind(&DesktopSessionAgent::StopAudioCapturer, this));
 
     // Stop the video capturer.
     video_capture_task_runner()->PostTask(
         FROM_HERE, base::Bind(&DesktopSessionAgent::StopVideoCapturer, this));
   }
@@ skipping 64 matching lines @@
   DCHECK(caller_task_runner()->BelongsToCurrentThread());
 
   protocol::ClipboardEvent event;
   if (!event.ParseFromString(serialized_event)) {
     LOG(ERROR) << "Failed to parse protocol::ClipboardEvent.";
     return;
   }
 
   // InputStub implementations must verify events themselves, so we don't need
   // verification here. This matches HostEventDispatcher.
-  event_executor_->InjectClipboardEvent(event);
+  input_injector_->InjectClipboardEvent(event);
 }
 
 void DesktopSessionAgent::OnInjectKeyEvent(
     const std::string& serialized_event) {
   DCHECK(caller_task_runner()->BelongsToCurrentThread());
 
   protocol::KeyEvent event;
   if (!event.ParseFromString(serialized_event)) {
     LOG(ERROR) << "Failed to parse protocol::KeyEvent.";
     return;
@@ skipping 111 matching lines @@
     base::ClosePlatformFile(desktop_pipe_.fd);
 #else  // !defined(OS_POSIX)
 #error Unsupported platform.
 #endif  // !defined(OS_POSIX)
 
     desktop_pipe_ = IPC::InvalidPlatformFileForTransit();
   }
 }
 
 }  // namespace remoting