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::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 protocol::ClipboardEvent& event)

[Wez, 2012/03/15 01:14:44]

nit: Be consist about protocol::ClipboardEvent vs KeyEvent / MouseEvent?  Have
you avoided using for ClipboardEvent because it's only used in two places?

[simonmorris, 2012/03/15 16:53:19]

I was consistent originally, but another reviewer asked for the change. Now it's
2-1, so I've gone back to the consistent approach.

+      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 protocol::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 130 matching lines @@
                                                       Capturer* capturer) {
   scoped_ptr<EventExecutorLinux> executor(
       new EventExecutorLinux(message_loop, capturer));
   if (!executor->Init()) {
     executor.reset(NULL);
   }
   return executor.PassAs<protocol::InputStub>();
 }
 
 }  // namespace remoting