Implement clipboard for Chromoting Linux hosts.

remoting/host/clipboard_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/clipboard.h"
 
+#include <X11/Xlib.h>
+
+#include "base/bind.h"
 #include "base/logging.h"
+#include "base/message_loop.h"
+#include "base/message_pump_libevent.h"

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

don't need this include. See my comment below.

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

Done.

+#include "remoting/host/x_server_clipboard.h"
+#include "remoting/proto/event.pb.h"
+#include "remoting/protocol/clipboard_stub.h"
 
 namespace remoting {
 
-class ClipboardLinux : public Clipboard {
+class ClipboardLinux : public Clipboard, base::MessagePumpLibevent::Watcher {

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

It's better to use MessageLoopForIO::Watcher here. It's just a typedef for
base::MessagePumpLibevent::Watcher, but looks less awkward.

Also you forgot to specify public inheritance for the second parent.

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

Add comment to exmplain that we expect this code to be used on the desktop
thread only.

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

Done.

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

Done.

  public:
   ClipboardLinux();
+  virtual ~ClipboardLinux();
 
-  // Must be called on the UI thread.
   virtual void Start(

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

// Clipboard interface.

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

Done.

       scoped_ptr<protocol::ClipboardStub> client_clipboard) OVERRIDE;
   virtual void InjectClipboardEvent(
       const protocol::ClipboardEvent& event) OVERRIDE;
   virtual void Stop() OVERRIDE;
 
  private:
+  void OnClipboardChanged(const std::string& mime_type,
+                          const std::string& data);
+  void PumpEvents();
+
+  // base::MessagePumpLibevent::Watcher interface

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

nit: period at the end of the comment. MessageLoopForIO

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

Done.

+  virtual void OnFileCanReadWithoutBlocking(int fd) OVERRIDE;

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

Per style guide interface implementation must always be public.

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

Done.

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

Done (and moved the implementations so they match the ordering in the class
declaration).

+  virtual void OnFileCanWriteWithoutBlocking(int fd) OVERRIDE;
+
+  scoped_ptr<protocol::ClipboardStub> client_clipboard_;
+
+  XServerClipboard x_server_clipboard_;
+  Display* display_;
+
+  base::MessagePumpLibevent::FileDescriptorWatcher x_connection_watcher_;
+
   DISALLOW_COPY_AND_ASSIGN(ClipboardLinux);
 };
 
+ClipboardLinux::ClipboardLinux() : display_(NULL) {

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

nit: better to place initializer on a separate line

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

Done.

+}
+
+ClipboardLinux::~ClipboardLinux() {
+  Stop();
+}
+
 void ClipboardLinux::Start(
     scoped_ptr<protocol::ClipboardStub> client_clipboard) {
-  NOTIMPLEMENTED();
+  display_ = XOpenDisplay(NULL);

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

Please add TODO to share X connection with the event executor.

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

Done.

+  if (!display_) {
+    LOG(ERROR) << "Couldn't open X display";
+    return;
+  }
+  client_clipboard_.swap(client_clipboard);
+
+  x_server_clipboard_.Init(display_,
+                           base::Bind(&ClipboardLinux::OnClipboardChanged,
+                                      base::Unretained(this)));
+
+  MessageLoopForIO::current()->WatchFileDescriptor(
+      ConnectionNumber(display_), true, MessageLoopForIO::WATCH_READ,
+      &x_connection_watcher_, this);
+  PumpEvents();
 }
 
 void ClipboardLinux::InjectClipboardEvent(
     const protocol::ClipboardEvent& event) {
-  NOTIMPLEMENTED();
+  x_server_clipboard_.SetClipboard(event.mime_type(), event.data());
 }
 
 void ClipboardLinux::Stop() {
-  NOTIMPLEMENTED();
+  client_clipboard_.reset();
+  x_connection_watcher_.StopWatchingFileDescriptor();
+
+  if (display_) {
+    XCloseDisplay(display_);
+    display_ = NULL;
+  }
+}
+
+void ClipboardLinux::OnClipboardChanged(const std::string& mime_type,
+                                        const std::string& data) {
+  protocol::ClipboardEvent event;
+  event.set_mime_type(mime_type);
+  event.set_data(data);
+
+  if (client_clipboard_.get()) {
+    client_clipboard_->InjectClipboardEvent(event);
+  }
+}
+
+void ClipboardLinux::PumpEvents() {
+  DCHECK(display_);
+
+  while (XPending(display_)) {
+    XEvent event;
+    XNextEvent(display_, &event);
+    x_server_clipboard_.ProcessXEvent(&event);
+  }
+}
+
+void ClipboardLinux::OnFileCanReadWithoutBlocking(int fd) {
+  PumpEvents();
+}
+
+void ClipboardLinux::OnFileCanWriteWithoutBlocking(int fd) {
 }
 
 scoped_ptr<Clipboard> Clipboard::Create() {
   return scoped_ptr<Clipboard>(new ClipboardLinux());
 }
 
 }  // namespace remoting