Add the plumbing that will carry a clipboard item from a chromoting client to a host.

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/XF86keysym.h>
 #include <X11/keysym.h>
 #include <X11/extensions/XTest.h>
 
 #include "base/basictypes.h"
 #include "base/bind.h"
 #include "base/compiler_specific.h"
 #include "base/logging.h"
 #include "base/message_loop.h"
 #include "remoting/proto/internal.pb.h"
 
 namespace remoting {
 
+using protocol::ClipboardEvent;
+using protocol::KeyEvent;
 using protocol::MouseEvent;
-using protocol::KeyEvent;
 
 namespace {
 
 // USB to XKB keycode map table.
 #define USB_KEYMAP(usb, xkb, win, mac) {usb, xkb}
 #include "remoting/host/usb_keycode_map.h"
 
 // A class to generate events on Linux.
 class EventExecutorLinux : public EventExecutor {
  public:
   EventExecutorLinux(MessageLoop* message_loop, Capturer* capturer);
   virtual ~EventExecutorLinux();
 
   bool Init();
 
+  // Clipboard stub interface.
+  virtual void InjectClipboardEvent(const ClipboardEvent& event)
+      OVERRIDE;
+
+  // InputStub interface.
   virtual void InjectKeyEvent(const KeyEvent& event) OVERRIDE;
   virtual void InjectMouseEvent(const MouseEvent& event) OVERRIDE;
 
  private:
   // |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);
 
@@ skipping 257 matching lines @@
   if (!XGetWindowAttributes(display_, root_window_, &root_attr)) {
     LOG(ERROR) << "Unable to get window attributes";
     return false;
   }
 
   width_ = root_attr.width;
   height_ = root_attr.height;
   return true;
 }
 
+void EventExecutorLinux::InjectClipboardEvent(const ClipboardEvent& event) {
+  // TODO(simonmorris): Implement clipboard injection.
+}
+
 void EventExecutorLinux::InjectKeyEvent(const KeyEvent& event) {
   if (MessageLoop::current() != message_loop_) {
     message_loop_->PostTask(
         FROM_HERE,
         base::Bind(&EventExecutorLinux::InjectKeyEvent, base::Unretained(this),
                    event));
     return;
   }
 
   int keycode = 0;
@@ skipping 119 matching lines @@
   }
   if (event.has_wheel_offset_x() && event.wheel_offset_x() != 0) {
     int dx = event.wheel_offset_x();
     InjectScrollWheelClicks(HorizontalScrollWheelToX11ButtonNumber(dx),
                             abs(dx));
   }
 }
 
 }  // namespace
 
-scoped_ptr<protocol::InputStub> EventExecutor::Create(MessageLoop* message_loop,
-                                                      Capturer* capturer) {
+scoped_ptr<protocol::HostEventStub> EventExecutor::Create(
+    MessageLoop* message_loop, Capturer* capturer) {
   scoped_ptr<EventExecutorLinux> executor(
       new EventExecutorLinux(message_loop, capturer));
   if (!executor->Init()) {
     executor.reset(NULL);
   }
-  return executor.PassAs<protocol::InputStub>();
+  return executor.PassAs<protocol::HostEventStub>();
 }
 
 }  // namespace remoting