Implement InputStub in the host side for chromoting

remoting/host/event_executor_linux.cc

 // Copyright (c) 2010 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/event_executor_linux.h"
 
 #include <X11/Xlib.h>
 #include <X11/keysym.h>
 #include <X11/extensions/XTest.h>
 
 #include "base/logging.h"
+#include "base/message_loop.h"
+#include "base/task.h"
 #include "remoting/proto/internal.pb.h"
 
 namespace remoting {
 
 static int MouseButtonToX11ButtonNumber(MouseButton button) {
   switch (button) {
     case MouseButtonLeft:
       return 1;
 
     case MouseButtonRight:
@@ skipping 171 matching lines @@
 
   return kPepperToX11Keysym[keycode];
 }
 
 class EventExecutorLinuxPimpl {
  public:
   explicit EventExecutorLinuxPimpl(EventExecutorLinux* executor);
   ~EventExecutorLinuxPimpl();
 
   bool Init();  // TODO(ajwong): Do we really want this to be synchronous?
-
-  void HandleInputEvent(ChromotingClientMessage* message);
+  void HandleMouse(const MouseEvent* message);
+  void HandleKey(const KeyEvent* key_event);
 
  private:
   void HandleMouseSetPosition(const MouseSetPositionEvent& position_event);
   void HandleMouseMove(const MouseMoveEvent& move_event);
   void HandleMouseWheel(const MouseWheelEvent& wheel_event);
   void HandleMouseButtonDown(const MouseDownEvent& mouse_down_event);
   void HandleMouseButtonUp(const MouseUpEvent& mouse_up_event);
-  void HandleKey(const KeyEvent& key_event);
   void DeinitXlib();
 
   // Reference to containing class so we can access friend functions.
   // Not owned.
   EventExecutorLinux* executor_;
 
   // X11 graphics context.
   Display* display_;
   GC gc_;
   Window root_window_;
   int width_;
   int height_;
 
   int test_event_base_;
   int test_error_base_;
 };
 
-EventExecutorLinux::EventExecutorLinux(Capturer* capturer)
-  : EventExecutor(capturer),
-    pimpl_(new EventExecutorLinuxPimpl(this)) {
-  CHECK(pimpl_->Init());
-}
-
-EventExecutorLinux::~EventExecutorLinux() {
-}
-
-void EventExecutorLinux::HandleInputEvent(ChromotingClientMessage* message) {
-  pimpl_->HandleInputEvent(message);
-}
-
 EventExecutorLinuxPimpl::EventExecutorLinuxPimpl(EventExecutorLinux* executor)
     : executor_(executor),
       display_(NULL),
       gc_(NULL),
       root_window_(BadValue),
       width_(0),
       height_(0) {
 }
 
 EventExecutorLinuxPimpl::~EventExecutorLinuxPimpl() {
@@ skipping 42 matching lines @@
     DeinitXlib();
     return false;
   }
 
   width_ = root_attr.width;
   height_ = root_attr.height;
 
   return true;
 }
 
-void EventExecutorLinuxPimpl::HandleInputEvent(
-    ChromotingClientMessage* message) {
-  if (message->has_mouse_set_position_event()) {
-    HandleMouseSetPosition(message->mouse_set_position_event());
-  } else if (message->has_mouse_move_event()) {
-    HandleMouseMove(message->mouse_move_event());
-  } else if (message->has_mouse_wheel_event()) {
-    HandleMouseWheel(message->mouse_wheel_event());
-  } else if (message->has_mouse_down_event()) {
-    HandleMouseButtonDown(message->mouse_down_event());
-  } else if (message->has_mouse_up_event()) {
-    HandleMouseButtonUp(message->mouse_up_event());
-  } else if (message->has_key_event()) {
-    HandleKey(message->key_event());
+void EventExecutorLinuxPimpl::HandleMouse(
+    const MouseEvent* mouse_event) {
+  if (mouse_event->has_set_position()) {
+    HandleMouseSetPosition(mouse_event->set_position());
+  } else if (mouse_event->has_wheel()) {
+    HandleMouseWheel(mouse_event->wheel());
+  } else if (mouse_event->has_down()) {
+    HandleMouseButtonDown(mouse_event->down());
+  } else if (mouse_event->has_up()) {
+    HandleMouseButtonUp(mouse_event->up());
   }
-  delete message;
 }
 
 void EventExecutorLinuxPimpl::HandleMouseSetPosition(
     const MouseSetPositionEvent& position_event) {
   if (position_event.x() < 0 || position_event.y() < 0 ||
       position_event.x() > width_ || position_event.y() > height_) {
     // A misbehaving client may send these. Drop events that are out of range.
     // TODO(ajwong): How can we log this sanely? We don't want to DOS the server
     // with a misbehaving client by logging like crazy.
     return;
@@ skipping 38 matching lines @@
     LOG(WARNING) << "Ignoring unknown button type: "
                  << mouse_up_event.button();
     return;
   }
 
   VLOG(3) << "Button " << mouse_up_event.button()
           << " received, sending up " << button_number;
   XTestFakeButtonEvent(display_, button_number, False, CurrentTime);
 }
 
-void EventExecutorLinuxPimpl::HandleKey(const KeyEvent& key_event) {
+void EventExecutorLinuxPimpl::HandleKey(const KeyEvent* key_event) {
   // TODO(ajwong): This will only work for QWERTY keyboards.
-  int keysym = ChromotocolKeycodeToX11Keysym(key_event.key());
+  int keysym = ChromotocolKeycodeToX11Keysym(key_event->key());
 
   if (keysym == -1) {
-    LOG(WARNING) << "Ignoring unknown key: " << key_event.key();
+    LOG(WARNING) << "Ignoring unknown key: " << key_event->key();
     return;
   }
 
   // Translate the keysym into a keycode understandable by the X display.
   int keycode = XKeysymToKeycode(display_, keysym);
   if (keycode == 0) {
     LOG(WARNING) << "Ignoring undefined keysym: " << keysym
-                 << " for key: " << key_event.key();
+                 << " for key: " << key_event->key();
     return;
   }
 
-  VLOG(3) << "Got pepper key: " << key_event.key()
+  VLOG(3) << "Got pepper key: " << key_event->key()
           << " sending keysym: " << keysym
           << " to keycode: " << keycode;
-  XTestFakeKeyEvent(display_, keycode, key_event.pressed(), CurrentTime);
+  XTestFakeKeyEvent(display_, keycode, key_event->pressed(), CurrentTime);
 }
 
 void EventExecutorLinuxPimpl::DeinitXlib() {
   // TODO(ajwong): We should expose a "close" or "shutdown" method.
   if (gc_) {
     if (!XFreeGC(display_, gc_)) {
       LOG(ERROR) << "Unable to free Xlib GC";
     }
     gc_ = NULL;
   }
 
   if (display_) {
     if (!XCloseDisplay(display_)) {
       LOG(ERROR) << "Unable to close the Xlib Display.";
     }
     display_ = NULL;
   }
 }
 
+EventExecutorLinux::EventExecutorLinux(
+    MessageLoop* message_loop, Capturer* capturer)
+    : message_loop_(message_loop),
+      capturer_(capturer),
+      pimpl_(new EventExecutorLinuxPimpl(this)) {
+  CHECK(pimpl_->Init());
+}
+
+EventExecutorLinux::~EventExecutorLinux() {
+}
+
+void EventExecutorLinux::InjectKeyEvent(const KeyEvent* event, Task* done) {
+  if (MessageLoop::current() != message_loop_) {
+    message_loop_->PostTask(
+        FROM_HERE,
+        NewRunnableMethod(this, &EventExecutorLinux::InjectKeyEvent,
+                          event, done));
+    return;
+  }
+  pimpl_->HandleKey(event);
+  done->Run();
+  delete done;
+}
+
+void EventExecutorLinux::InjectMouseEvent(const MouseEvent* event,
+                                          Task* done) {
+  if (MessageLoop::current() != message_loop_) {
+    message_loop_->PostTask(
+        FROM_HERE,
+        NewRunnableMethod(this, &EventExecutorLinux::InjectMouseEvent,
+                          event, done));
+    return;
+  }
+  pimpl_->HandleMouse(event);
+  done->Run();
+  delete done;
+}
+
 }  // namespace remoting