remoting/host/local_input_monitor_linux.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/local_input_monitor.h"
   6
   7 #include <sys/select.h>
   8 #include <unistd.h>
   9 #define XK_MISCELLANY
  10 #include <X11/keysymdef.h>
  11
  12 #include "base/basictypes.h"
  13 #include "base/bind.h"
  14 #include "base/callback.h"
  15 #include "base/compiler_specific.h"
  16 #include "base/location.h"
  17 #include "base/logging.h"
  18 #include "base/message_loop/message_loop.h"
  19 #include "base/message_loop/message_pump_libevent.h"
  20 #include "base/single_thread_task_runner.h"
  21 #include "base/threading/non_thread_safe.h"
  22 #include "remoting/host/client_session_control.h"
  23 #include "third_party/webrtc/modules/desktop_capture/desktop_geometry.h"
  24
  25 // These includes need to be later than dictated by the style guide due to
  26 // Xlib header pollution, specifically the min, max, and Status macros.
  27 #include <X11/XKBlib.h>
  28 #include <X11/Xlibint.h>
  29 #include <X11/extensions/record.h>
  30
  31 namespace remoting {
  32
  33 namespace {
  34
  35 class LocalInputMonitorLinux : public base::NonThreadSafe,
  36                                public LocalInputMonitor {
  37  public:
  38   LocalInputMonitorLinux(
  39       scoped_refptr<base::SingleThreadTaskRunner> caller_task_runner,
  40       scoped_refptr<base::SingleThreadTaskRunner> input_task_runner,
  41       base::WeakPtr<ClientSessionControl> client_session_control);
  42   virtual ~LocalInputMonitorLinux();
  43
  44  private:
  45   // The actual implementation resides in LocalInputMonitorLinux::Core class.
  46   class Core
  47       : public base::RefCountedThreadSafe<Core>,
  48         public base::MessagePumpLibevent::Watcher {
  49    public:
  50     Core(scoped_refptr<base::SingleThreadTaskRunner> caller_task_runner,
  51          scoped_refptr<base::SingleThreadTaskRunner> input_task_runner,
  52          base::WeakPtr<ClientSessionControl> client_session_control);
  53
  54     void Start();
  55     void Stop();
  56
  57    private:
  58     friend class base::RefCountedThreadSafe<Core>;
  59     virtual ~Core();
  60
  61     void StartOnInputThread();
  62     void StopOnInputThread();
  63
  64     // base::MessagePumpLibevent::Watcher interface.
  65     virtual void OnFileCanReadWithoutBlocking(int fd) OVERRIDE;
  66     virtual void OnFileCanWriteWithoutBlocking(int fd) OVERRIDE;
  67
  68     // Processes key and mouse events.
  69     void ProcessXEvent(xEvent* event);
  70
  71     static void ProcessReply(XPointer self, XRecordInterceptData* data);
  72
  73     // Task runner on which public methods of this class must be called.
  74     scoped_refptr<base::SingleThreadTaskRunner> caller_task_runner_;
  75
  76     // Task runner on which X Window events are received.
  77     scoped_refptr<base::SingleThreadTaskRunner> input_task_runner_;
  78
  79     // Points to the object receiving mouse event notifications and session
  80     // disconnect requests.
  81     base::WeakPtr<ClientSessionControl> client_session_control_;
  82
  83     // Used to receive base::MessagePumpLibevent::Watcher events.
  84     base::MessagePumpLibevent::FileDescriptorWatcher controller_;
  85
  86     // True when Alt is pressed.
  87     bool alt_pressed_;
  88
  89     // True when Ctrl is pressed.
  90     bool ctrl_pressed_;
  91
  92     Display* display_;
  93     Display* x_record_display_;
  94     XRecordRange* x_record_range_[2];
  95     XRecordContext x_record_context_;
  96
  97     DISALLOW_COPY_AND_ASSIGN(Core);
  98   };
  99
 100   scoped_refptr<Core> core_;
 101
 102   DISALLOW_COPY_AND_ASSIGN(LocalInputMonitorLinux);
 103 };
 104
 105 LocalInputMonitorLinux::LocalInputMonitorLinux(
 106     scoped_refptr<base::SingleThreadTaskRunner> caller_task_runner,
 107     scoped_refptr<base::SingleThreadTaskRunner> input_task_runner,
 108     base::WeakPtr<ClientSessionControl> client_session_control)
 109     : core_(new Core(caller_task_runner,
 110                      input_task_runner,
 111                      client_session_control)) {
 112   core_->Start();
 113 }
 114
 115 LocalInputMonitorLinux::~LocalInputMonitorLinux() {
 116   core_->Stop();
 117 }
 118
 119 LocalInputMonitorLinux::Core::Core(
 120     scoped_refptr<base::SingleThreadTaskRunner> caller_task_runner,
 121     scoped_refptr<base::SingleThreadTaskRunner> input_task_runner,
 122     base::WeakPtr<ClientSessionControl> client_session_control)
 123     : caller_task_runner_(caller_task_runner),
 124       input_task_runner_(input_task_runner),
 125       client_session_control_(client_session_control),
 126       alt_pressed_(false),
 127       ctrl_pressed_(false),
 128       display_(NULL),
 129       x_record_display_(NULL),
 130       x_record_context_(0) {
 131   DCHECK(caller_task_runner_->BelongsToCurrentThread());
 132   DCHECK(client_session_control_.get());
 133
 134   x_record_range_[0] = NULL;
 135   x_record_range_[1] = NULL;
 136 }
 137
 138 void LocalInputMonitorLinux::Core::Start() {
 139   DCHECK(caller_task_runner_->BelongsToCurrentThread());
 140
 141   input_task_runner_->PostTask(FROM_HERE,
 142                                base::Bind(&Core::StartOnInputThread, this));
 143 }
 144
 145 void LocalInputMonitorLinux::Core::Stop() {
 146   DCHECK(caller_task_runner_->BelongsToCurrentThread());
 147
 148   input_task_runner_->PostTask(FROM_HERE,
 149                                base::Bind(&Core::StopOnInputThread, this));
 150 }
 151
 152 LocalInputMonitorLinux::Core::~Core() {
 153   DCHECK(!display_);
 154   DCHECK(!x_record_display_);
 155   DCHECK(!x_record_range_[0]);
 156   DCHECK(!x_record_range_[1]);
 157   DCHECK(!x_record_context_);
 158 }
 159
 160 void LocalInputMonitorLinux::Core::StartOnInputThread() {
 161   DCHECK(input_task_runner_->BelongsToCurrentThread());
 162   DCHECK(!display_);
 163   DCHECK(!x_record_display_);
 164   DCHECK(!x_record_range_[0]);
 165   DCHECK(!x_record_range_[1]);
 166   DCHECK(!x_record_context_);
 167
 168   // TODO(jamiewalch): We should pass the display in. At that point, since
 169   // XRecord needs a private connection to the X Server for its data channel
 170   // and both channels are used from a separate thread, we'll need to duplicate
 171   // them with something like the following:
 172   //   XOpenDisplay(DisplayString(display));
 173   display_ = XOpenDisplay(NULL);
 174   x_record_display_ = XOpenDisplay(NULL);
 175   if (!display_ || !x_record_display_) {
 176     LOG(ERROR) << "Couldn't open X display";
 177     return;
 178   }
 179
 180   int xr_opcode, xr_event, xr_error;
 181   if (!XQueryExtension(display_, "RECORD", &xr_opcode, &xr_event, &xr_error)) {
 182     LOG(ERROR) << "X Record extension not available.";
 183     return;
 184   }
 185
 186   x_record_range_[0] = XRecordAllocRange();
 187   x_record_range_[1] = XRecordAllocRange();
 188   if (!x_record_range_[0] || !x_record_range_[1]) {
 189     LOG(ERROR) << "XRecordAllocRange failed.";
 190     return;
 191   }
 192   x_record_range_[0]->device_events.first = MotionNotify;
 193   x_record_range_[0]->device_events.last = MotionNotify;
 194   x_record_range_[1]->device_events.first = KeyPress;
 195   x_record_range_[1]->device_events.last = KeyRelease;
 196   XRecordClientSpec client_spec = XRecordAllClients;
 197
 198   x_record_context_ = XRecordCreateContext(
 199       x_record_display_, 0, &client_spec, 1, x_record_range_,
 200       arraysize(x_record_range_));
 201   if (!x_record_context_) {
 202     LOG(ERROR) << "XRecordCreateContext failed.";
 203     return;
 204   }
 205
 206   if (!XRecordEnableContextAsync(x_record_display_, x_record_context_,
 207                                  &Core::ProcessReply,
 208                                  reinterpret_cast<XPointer>(this))) {
 209     LOG(ERROR) << "XRecordEnableContextAsync failed.";
 210     return;
 211   }
 212
 213   // Register OnFileCanReadWithoutBlocking() to be called every time there is
 214   // something to read from |x_record_display_|.
 215   base::MessageLoopForIO* message_loop = base::MessageLoopForIO::current();
 216   int result =
 217       message_loop->WatchFileDescriptor(ConnectionNumber(x_record_display_),
 218                                         true,
 219                                         base::MessageLoopForIO::WATCH_READ,
 220                                         &controller_,
 221                                         this);
 222   if (!result) {
 223     LOG(ERROR) << "Failed to create X record task.";
 224     return;
 225   }
 226
 227   // Fetch pending events if any.
 228   while (XPending(x_record_display_)) {
 229     XEvent ev;
 230     XNextEvent(x_record_display_, &ev);
 231   }
 232 }
 233
 234 void LocalInputMonitorLinux::Core::StopOnInputThread() {
 235   DCHECK(input_task_runner_->BelongsToCurrentThread());
 236
 237   // Context must be disabled via the control channel because we can't send
 238   // any X protocol traffic over the data channel while it's recording.
 239   if (x_record_context_) {
 240     XRecordDisableContext(display_, x_record_context_);
 241     XFlush(display_);
 242   }
 243
 244   controller_.StopWatchingFileDescriptor();
 245
 246   if (x_record_range_[0]) {
 247     XFree(x_record_range_[0]);
 248     x_record_range_[0] = NULL;
 249   }
 250   if (x_record_range_[1]) {
 251     XFree(x_record_range_[1]);
 252     x_record_range_[1] = NULL;
 253   }
 254   if (x_record_context_) {
 255     XRecordFreeContext(x_record_display_, x_record_context_);
 256     x_record_context_ = 0;
 257   }
 258   if (x_record_display_) {
 259     XCloseDisplay(x_record_display_);
 260     x_record_display_ = NULL;
 261   }
 262   if (display_) {
 263     XCloseDisplay(display_);
 264     display_ = NULL;
 265   }
 266 }
 267
 268 void LocalInputMonitorLinux::Core::OnFileCanReadWithoutBlocking(int fd) {
 269   DCHECK(input_task_runner_->BelongsToCurrentThread());
 270
 271   // Fetch pending events if any.
 272   while (XPending(x_record_display_)) {
 273     XEvent ev;
 274     XNextEvent(x_record_display_, &ev);
 275   }
 276 }
 277
 278 void LocalInputMonitorLinux::Core::OnFileCanWriteWithoutBlocking(int fd) {
 279   NOTREACHED();
 280 }
 281
 282 void LocalInputMonitorLinux::Core::ProcessXEvent(xEvent* event) {
 283   DCHECK(input_task_runner_->BelongsToCurrentThread());
 284
 285   if (event->u.u.type == MotionNotify) {
 286     webrtc::DesktopVector position(event->u.keyButtonPointer.rootX,
 287                                    event->u.keyButtonPointer.rootY);
 288     caller_task_runner_->PostTask(
 289         FROM_HERE, base::Bind(&ClientSessionControl::OnLocalMouseMoved,
 290                               client_session_control_,
 291                               position));
 292   } else {
 293     int key_code = event->u.u.detail;
 294     bool down = event->u.u.type == KeyPress;
 295     KeySym key_sym = XkbKeycodeToKeysym(display_, key_code, 0, 0);
 296     if (key_sym == XK_Control_L || key_sym == XK_Control_R) {
 297       ctrl_pressed_ = down;
 298     } else if (key_sym == XK_Alt_L || key_sym == XK_Alt_R) {
 299       alt_pressed_ = down;
 300     } else if (key_sym == XK_Escape && down && alt_pressed_ && ctrl_pressed_) {
 301       caller_task_runner_->PostTask(
 302           FROM_HERE, base::Bind(&ClientSessionControl::DisconnectSession,
 303                                 client_session_control_));
 304     }
 305   }
 306 }
 307
 308 // static
 309 void LocalInputMonitorLinux::Core::ProcessReply(XPointer self,
 310                                                 XRecordInterceptData* data) {
 311   if (data->category == XRecordFromServer) {
 312     xEvent* event = reinterpret_cast<xEvent*>(data->data);
 313     reinterpret_cast<Core*>(self)->ProcessXEvent(event);
 314   }
 315   XRecordFreeData(data);
 316 }
 317
 318 }  // namespace
 319
 320 scoped_ptr<LocalInputMonitor> LocalInputMonitor::Create(
 321     scoped_refptr<base::SingleThreadTaskRunner> caller_task_runner,
 322     scoped_refptr<base::SingleThreadTaskRunner> input_task_runner,
 323     scoped_refptr<base::SingleThreadTaskRunner> ui_task_runner,
 324     base::WeakPtr<ClientSessionControl> client_session_control) {
 325   return scoped_ptr<LocalInputMonitor>(
 326       new LocalInputMonitorLinux(caller_task_runner,
 327                                  input_task_runner,
 328                                  client_session_control));
 329 }
 330
 331 }  // namespace remoting