remoting/host/clipboard_x11.cc

   1 // Copyright (c) 2012 The Chromium Authors. All rights reserved.
   2 // Use of this source code is governed by a BSD-style license that can be
   3 // found in the LICENSE file.
   4
   5 #include "remoting/host/clipboard.h"
   6
   7 #include <X11/Xlib.h>
   8
   9 #include "base/bind.h"
  10 #include "base/logging.h"
  11 #include "base/message_loop/message_loop.h"
  12 #include "remoting/host/linux/x_server_clipboard.h"
  13 #include "remoting/proto/event.pb.h"
  14 #include "remoting/protocol/clipboard_stub.h"
  15
  16 namespace remoting {
  17
  18 // This code is expected to be called on the desktop thread only.
  19 class ClipboardX11 : public Clipboard,
  20                      public base::MessageLoopForIO::Watcher {
  21  public:
  22   ClipboardX11();
  23   virtual ~ClipboardX11();
  24
  25   // Clipboard interface.
  26   virtual void Start(
  27       scoped_ptr<protocol::ClipboardStub> client_clipboard) OVERRIDE;
  28   virtual void InjectClipboardEvent(
  29       const protocol::ClipboardEvent& event) OVERRIDE;
  30   virtual void Stop() OVERRIDE;
  31
  32   // MessageLoopForIO::Watcher interface.
  33   virtual void OnFileCanReadWithoutBlocking(int fd) OVERRIDE;
  34   virtual void OnFileCanWriteWithoutBlocking(int fd) OVERRIDE;
  35
  36  private:
  37   void OnClipboardChanged(const std::string& mime_type,
  38                           const std::string& data);
  39   void PumpXEvents();
  40
  41   scoped_ptr<protocol::ClipboardStub> client_clipboard_;
  42
  43   // Underlying X11 clipboard implementation.
  44   XServerClipboard x_server_clipboard_;
  45
  46   // Connection to the X server, used by |x_server_clipboard_|. This is created
  47   // and owned by this class.
  48   Display* display_;
  49
  50   // Watcher used to handle X11 events from |display_|.
  51   base::MessageLoopForIO::FileDescriptorWatcher x_connection_watcher_;
  52
  53   DISALLOW_COPY_AND_ASSIGN(ClipboardX11);
  54 };
  55
  56 ClipboardX11::ClipboardX11()
  57     : display_(NULL) {
  58 }
  59
  60 ClipboardX11::~ClipboardX11() {
  61   Stop();
  62 }
  63
  64 void ClipboardX11::Start(
  65     scoped_ptr<protocol::ClipboardStub> client_clipboard) {
  66   // TODO(lambroslambrou): Share the X connection with InputInjector.
  67   display_ = XOpenDisplay(NULL);
  68   if (!display_) {
  69     LOG(ERROR) << "Couldn't open X display";
  70     return;
  71   }
  72   client_clipboard_.swap(client_clipboard);
  73
  74   x_server_clipboard_.Init(display_,
  75                            base::Bind(&ClipboardX11::OnClipboardChanged,
  76                                       base::Unretained(this)));
  77
  78   base::MessageLoopForIO::current()->WatchFileDescriptor(
  79       ConnectionNumber(display_),
  80       true,
  81       base::MessageLoopForIO::WATCH_READ,
  82       &x_connection_watcher_,
  83       this);
  84   PumpXEvents();
  85 }
  86
  87 void ClipboardX11::InjectClipboardEvent(
  88     const protocol::ClipboardEvent& event) {
  89   x_server_clipboard_.SetClipboard(event.mime_type(), event.data());
  90 }
  91
  92 void ClipboardX11::Stop() {
  93   client_clipboard_.reset();
  94   x_connection_watcher_.StopWatchingFileDescriptor();
  95
  96   if (display_) {
  97     XCloseDisplay(display_);
  98     display_ = NULL;
  99   }
 100 }
 101
 102 void ClipboardX11::OnFileCanReadWithoutBlocking(int fd) {
 103   PumpXEvents();
 104 }
 105
 106 void ClipboardX11::OnFileCanWriteWithoutBlocking(int fd) {
 107 }
 108
 109 void ClipboardX11::OnClipboardChanged(const std::string& mime_type,
 110                                       const std::string& data) {
 111   protocol::ClipboardEvent event;
 112   event.set_mime_type(mime_type);
 113   event.set_data(data);
 114
 115   if (client_clipboard_.get()) {
 116     client_clipboard_->InjectClipboardEvent(event);
 117   }
 118 }
 119
 120 void ClipboardX11::PumpXEvents() {
 121   DCHECK(display_);
 122
 123   while (XPending(display_)) {
 124     XEvent event;
 125     XNextEvent(display_, &event);
 126     x_server_clipboard_.ProcessXEvent(&event);
 127   }
 128 }
 129
 130 scoped_ptr<Clipboard> Clipboard::Create() {
 131   return scoped_ptr<Clipboard>(new ClipboardX11());
 132 }
 133
 134 }  // namespace remoting