Implement clipboard for Chromoting Linux hosts.

remoting/host/event_executor_linux.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/event_executor.h"
 
 #include <set>
 
 #include <X11/Xlib.h>
 #include <X11/extensions/XTest.h>
 
 #include "base/basictypes.h"
 #include "base/bind.h"
 #include "base/compiler_specific.h"
 #include "base/location.h"
 #include "base/logging.h"
 #include "base/single_thread_task_runner.h"
+#include "remoting/host/clipboard.h"
 #include "remoting/proto/internal.pb.h"
 #include "third_party/skia/include/core/SkPoint.h"
 
 namespace remoting {
 
 namespace {
 
 using protocol::ClipboardEvent;
 using protocol::KeyEvent;
 using protocol::MouseEvent;
@@ skipping 18 matching lines @@
   // InputStub interface.
   virtual void InjectKeyEvent(const KeyEvent& event) OVERRIDE;
   virtual void InjectMouseEvent(const MouseEvent& event) OVERRIDE;
 
   // EventExecutor interface.
   virtual void Start(
       scoped_ptr<protocol::ClipboardStub> client_clipboard) OVERRIDE;
   virtual void StopAndDelete() OVERRIDE;
 
  private:
+  void InitClipboard();
+
   // |mode| is one of the AutoRepeatModeOn, AutoRepeatModeOff,
   // AutoRepeatModeDefault constants defined by the XChangeKeyboardControl()
   // API.
   void SetAutoRepeatForKey(int keycode, int mode);
   void InjectScrollWheelClicks(int button, int count);
 
   scoped_refptr<base::SingleThreadTaskRunner> task_runner_;
 
   std::set<int> pressed_keys_;
   SkIPoint latest_mouse_position_;
 
   // X11 graphics context.
   Display* display_;
   Window root_window_;
 
   int test_event_base_;
   int test_error_base_;
 
+  scoped_ptr<Clipboard> clipboard_;
+
   DISALLOW_COPY_AND_ASSIGN(EventExecutorLinux);
 };
 
 int MouseButtonToX11ButtonNumber(MouseEvent::MouseButton button) {
   switch (button) {
     case MouseEvent::BUTTON_LEFT:
       return 1;
 
     case MouseEvent::BUTTON_RIGHT:
       return 3;
@@ skipping 17 matching lines @@
   // are wheel scroll-down events (button 5).
   return (dy > 0 ? 4 : 5);
 }
 
 EventExecutorLinux::EventExecutorLinux(
     scoped_refptr<base::SingleThreadTaskRunner> task_runner)
     : task_runner_(task_runner),
       latest_mouse_position_(SkIPoint::Make(-1, -1)),
       display_(XOpenDisplay(NULL)),
       root_window_(BadValue) {
+  if (!task_runner_->BelongsToCurrentThread()) {
+    task_runner_->PostTask(
+        FROM_HERE,
+        base::Bind(&EventExecutorLinux::InitClipboard, base::Unretained(this)));
+  }
 }
 
 EventExecutorLinux::~EventExecutorLinux() {
   CHECK(pressed_keys_.empty());
 }
 
 bool EventExecutorLinux::Init() {
   CHECK(display_);
 
   root_window_ = RootWindow(display_, DefaultScreen(display_));
   if (root_window_ == BadValue) {
     LOG(ERROR) << "Unable to get the root window";
     return false;
   }
 
   // TODO(ajwong): Do we want to check the major/minor version at all for XTest?
   int major = 0;
   int minor = 0;
   if (!XTestQueryExtension(display_, &test_event_base_, &test_error_base_,
                            &major, &minor)) {
     LOG(ERROR) << "Server does not support XTest.";
     return false;
   }
 
   return true;
 }
 
 void EventExecutorLinux::InjectClipboardEvent(const ClipboardEvent& event) {
-  // TODO(simonmorris): Implement clipboard injection.
+  if (!task_runner_->BelongsToCurrentThread()) {
+    task_runner_->PostTask(
+        FROM_HERE,
+        base::Bind(&EventExecutorLinux::InjectClipboardEvent,
+                   base::Unretained(this), event));
+    return;
+  }
+
+  clipboard_->InjectClipboardEvent(event);
 }
 
 void EventExecutorLinux::InjectKeyEvent(const KeyEvent& event) {
   // HostEventDispatcher should filter events missing the pressed field.
   DCHECK(event.has_pressed());
   DCHECK(event.has_usb_keycode());
 
   if (!task_runner_->BelongsToCurrentThread()) {
     task_runner_->PostTask(
         FROM_HERE,
@@ skipping 29 matching lines @@
     // case, this ensures that key-repeating will continue to work normally
     // for the local user of the host machine.  "ModeDefault" is used instead
     // of "ModeOn", since some keys (such as Shift) should not auto-repeat.
     SetAutoRepeatForKey(keycode, AutoRepeatModeDefault);
   }
 
   XTestFakeKeyEvent(display_, keycode, event.pressed(), CurrentTime);
   XFlush(display_);
 }
 
+void EventExecutorLinux::InitClipboard() {
+  clipboard_ = Clipboard::Create();

[Sergey Ulanov, 2012/09/14 19:35:01]

thread DCHECK please.

[Lambros, 2012/09/14 21:35:13]

Done.

+}
+
 void EventExecutorLinux::SetAutoRepeatForKey(int keycode, int mode) {
   XKeyboardControl control;
   control.key = keycode;
   control.auto_repeat_mode = mode;
   XChangeKeyboardControl(display_, KBKey | KBAutoRepeatMode, &control);
 }
 
 void EventExecutorLinux::InjectScrollWheelClicks(int button, int count) {
   for (int i = 0; i < count; i++) {
     // Generate a button-down and a button-up to simulate a wheel click.
@@ skipping 57 matching lines @@
     int dx = event.wheel_offset_x();
     InjectScrollWheelClicks(HorizontalScrollWheelToX11ButtonNumber(dx),
                             abs(dx));
   }
 
   XFlush(display_);
 }
 
 void EventExecutorLinux::Start(
     scoped_ptr<protocol::ClipboardStub> client_clipboard) {
-  return;
+  if (!task_runner_->BelongsToCurrentThread()) {
+    task_runner_->PostTask(
+        FROM_HERE,
+        base::Bind(&EventExecutorLinux::Start, base::Unretained(this),
+                   base::Passed(client_clipboard.Pass())));

[Sergey Ulanov, 2012/09/14 19:35:01]

FYI: alternative, slightly shorter syntax is base::Passed(&client_clipboard).

[Lambros, 2012/09/14 21:35:13]

This got changed to the shorter syntax when I rebased to ToT.

+    return;
+  }
+
+  clipboard_->Start(client_clipboard.Pass());
 }
 
 void EventExecutorLinux::StopAndDelete() {
   delete this;
 }
 
 }  // namespace
 
 scoped_ptr<EventExecutor> EventExecutor::Create(
     scoped_refptr<base::SingleThreadTaskRunner> main_task_runner,
     scoped_refptr<base::SingleThreadTaskRunner> ui_task_runner) {
   scoped_ptr<EventExecutorLinux> executor(
       new EventExecutorLinux(main_task_runner));
   if (!executor->Init())
     return scoped_ptr<EventExecutor>(NULL);
   return executor.PassAs<EventExecutor>();
 }
 
 }  // namespace remoting