Rename EventExecutor to InputInjector.

remoting/host/win/session_input_injector.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/win/session_event_executor.h"
+#include "remoting/host/win/session_input_injector.h"
 
 #include <set>
 #include <string>
 
 #include "base/bind.h"
 #include "base/callback.h"
 #include "base/compiler_specific.h"
 #include "base/location.h"
 #include "base/single_thread_task_runner.h"
 #include "base/win/windows_version.h"
@@ skipping 20 matching lines @@
 }
 
 } // namespace
 
 namespace remoting {
 
 using protocol::ClipboardEvent;
 using protocol::MouseEvent;
 using protocol::KeyEvent;
 
-class SessionEventExecutorWin::Core
-    : public base::RefCountedThreadSafe<SessionEventExecutorWin::Core>,
-      public EventExecutor {
+class SessionInputInjectorWin::Core
+    : public base::RefCountedThreadSafe<SessionInputInjectorWin::Core>,
+      public InputInjector {
  public:
   Core(
       scoped_refptr<base::SingleThreadTaskRunner> input_task_runner,
-      scoped_ptr<EventExecutor> nested_executor,
+      scoped_ptr<InputInjector> nested_executor,
       scoped_refptr<base::SingleThreadTaskRunner> inject_sas_task_runner,
       const base::Closure& inject_sas);
 
-  // EventExecutor implementation.
+  // InputInjector implementation.
   virtual void Start(
       scoped_ptr<protocol::ClipboardStub> client_clipboard) OVERRIDE;
 
   // protocol::ClipboardStub implementation.
   virtual void InjectClipboardEvent(
       const protocol::ClipboardEvent& event) OVERRIDE;
 
   // protocol::InputStub implementation.
   virtual void InjectKeyEvent(const protocol::KeyEvent& event) OVERRIDE;
   virtual void InjectMouseEvent(const protocol::MouseEvent& event) OVERRIDE;
 
  private:
   friend class base::RefCountedThreadSafe<Core>;
   virtual ~Core();
 
   // Switches to the desktop receiving a user input if different from
   // the current one.
   void SwitchToInputDesktop();
 
   scoped_refptr<base::SingleThreadTaskRunner> input_task_runner_;
 
   // Pointer to the next event executor.
-  scoped_ptr<EventExecutor> nested_executor_;
+  scoped_ptr<InputInjector> nested_executor_;
 
   scoped_refptr<base::SingleThreadTaskRunner> inject_sas_task_runner_;
 
   media::ScopedThreadDesktop desktop_;
 
   // Used to inject Secure Attention Sequence on Vista+.
   base::Closure inject_sas_;
 
   // Used to inject Secure Attention Sequence on XP.
   scoped_ptr<SasInjector> sas_injector_;
 
   // Keys currently pressed by the client, used to detect Ctrl-Alt-Del.
   std::set<uint32> pressed_keys_;
 
   DISALLOW_COPY_AND_ASSIGN(Core);
 };
 
-SessionEventExecutorWin::Core::Core(
+SessionInputInjectorWin::Core::Core(
     scoped_refptr<base::SingleThreadTaskRunner> input_task_runner,
-    scoped_ptr<EventExecutor> nested_executor,
+    scoped_ptr<InputInjector> nested_executor,
     scoped_refptr<base::SingleThreadTaskRunner> inject_sas_task_runner,
     const base::Closure& inject_sas)
     : input_task_runner_(input_task_runner),
       nested_executor_(nested_executor.Pass()),
       inject_sas_task_runner_(inject_sas_task_runner),
       inject_sas_(inject_sas) {
 }
 
-void SessionEventExecutorWin::Core::Start(
+void SessionInputInjectorWin::Core::Start(
     scoped_ptr<protocol::ClipboardStub> client_clipboard) {
   if (!input_task_runner_->BelongsToCurrentThread()) {
     input_task_runner_->PostTask(
         FROM_HERE,
         base::Bind(&Core::Start, this, base::Passed(&client_clipboard)));
     return;
   }
 
   nested_executor_->Start(client_clipboard.Pass());
 }
 
-void SessionEventExecutorWin::Core::InjectClipboardEvent(
+void SessionInputInjectorWin::Core::InjectClipboardEvent(
     const ClipboardEvent& event) {
   if (!input_task_runner_->BelongsToCurrentThread()) {
     input_task_runner_->PostTask(
         FROM_HERE, base::Bind(&Core::InjectClipboardEvent, this, event));
     return;
   }
 
   nested_executor_->InjectClipboardEvent(event);
 }
 
-void SessionEventExecutorWin::Core::InjectKeyEvent(const KeyEvent& event) {
+void SessionInputInjectorWin::Core::InjectKeyEvent(const KeyEvent& event) {
   if (!input_task_runner_->BelongsToCurrentThread()) {
     input_task_runner_->PostTask(
         FROM_HERE, base::Bind(&Core::InjectKeyEvent, this, event));
     return;
   }
 
   // HostEventDispatcher should drop events lacking the pressed field.
   DCHECK(event.has_pressed());
 
   if (event.has_usb_keycode()) {
@@ skipping 16 matching lines @@
       pressed_keys_.insert(event.usb_keycode());
     } else {
       pressed_keys_.erase(event.usb_keycode());
     }
   }
 
   SwitchToInputDesktop();
   nested_executor_->InjectKeyEvent(event);
 }
 
-void SessionEventExecutorWin::Core::InjectMouseEvent(const MouseEvent& event) {
+void SessionInputInjectorWin::Core::InjectMouseEvent(const MouseEvent& event) {
   if (!input_task_runner_->BelongsToCurrentThread()) {
     input_task_runner_->PostTask(
         FROM_HERE, base::Bind(&Core::InjectMouseEvent, this, event));
     return;
   }
 
   SwitchToInputDesktop();
   nested_executor_->InjectMouseEvent(event);
 }
 
-SessionEventExecutorWin::Core::~Core() {
+SessionInputInjectorWin::Core::~Core() {
 }
 
-void SessionEventExecutorWin::Core::SwitchToInputDesktop() {
+void SessionInputInjectorWin::Core::SwitchToInputDesktop() {
   // Switch to the desktop receiving user input if different from the current
   // one.
   scoped_ptr<media::Desktop> input_desktop = media::Desktop::GetInputDesktop();
   if (input_desktop.get() != NULL && !desktop_.IsSame(*input_desktop)) {
     // If SetThreadDesktop() fails, the thread is still assigned a desktop.
     // So we can continue capture screen bits, just from a diffected desktop.
     desktop_.SetThreadDesktop(input_desktop.Pass());
   }
 }
 
-SessionEventExecutorWin::SessionEventExecutorWin(
+SessionInputInjectorWin::SessionInputInjectorWin(
     scoped_refptr<base::SingleThreadTaskRunner> input_task_runner,
-    scoped_ptr<EventExecutor> nested_executor,
+    scoped_ptr<InputInjector> nested_executor,
     scoped_refptr<base::SingleThreadTaskRunner> inject_sas_task_runner,
     const base::Closure& inject_sas) {
   core_ = new Core(input_task_runner, nested_executor.Pass(),
                    inject_sas_task_runner, inject_sas);
 }
 
-SessionEventExecutorWin::~SessionEventExecutorWin() {
+SessionInputInjectorWin::~SessionInputInjectorWin() {
 }
 
-void SessionEventExecutorWin::Start(
+void SessionInputInjectorWin::Start(
     scoped_ptr<protocol::ClipboardStub> client_clipboard) {
   core_->Start(client_clipboard.Pass());
 }
 
-void SessionEventExecutorWin::InjectClipboardEvent(
+void SessionInputInjectorWin::InjectClipboardEvent(
     const protocol::ClipboardEvent& event) {
   core_->InjectClipboardEvent(event);
 }
 
-void SessionEventExecutorWin::InjectKeyEvent(const protocol::KeyEvent& event) {
+void SessionInputInjectorWin::InjectKeyEvent(const protocol::KeyEvent& event) {
   core_->InjectKeyEvent(event);
 }
 
-void SessionEventExecutorWin::InjectMouseEvent(
+void SessionInputInjectorWin::InjectMouseEvent(
     const protocol::MouseEvent& event) {
   core_->InjectMouseEvent(event);
 }
 
 }  // namespace remoting