Revert "Remote assistance on Chrome OS Part VIII - Compile on Ozone"

remoting/host/local_input_monitor_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/local_input_monitor.h"
 
 #include <sys/select.h>
 #include <unistd.h>
 #define XK_MISCELLANY
 #include <X11/keysymdef.h>
@@ skipping 14 matching lines @@
 // These includes need to be later than dictated by the style guide due to
 // Xlib header pollution, specifically the min, max, and Status macros.
 #include <X11/XKBlib.h>
 #include <X11/Xlibint.h>
 #include <X11/extensions/record.h>
 
 namespace remoting {
 
 namespace {
 
-class LocalInputMonitorX11 : public base::NonThreadSafe,
+class LocalInputMonitorLinux : public base::NonThreadSafe,
                                public LocalInputMonitor {
  public:
-  LocalInputMonitorX11(
+  LocalInputMonitorLinux(
       scoped_refptr<base::SingleThreadTaskRunner> caller_task_runner,
       scoped_refptr<base::SingleThreadTaskRunner> input_task_runner,
       base::WeakPtr<ClientSessionControl> client_session_control);
-  ~LocalInputMonitorX11() override;
+  ~LocalInputMonitorLinux() override;
 
  private:
-  // The actual implementation resides in LocalInputMonitorX11::Core class.
+  // The actual implementation resides in LocalInputMonitorLinux::Core class.
   class Core
       : public base::RefCountedThreadSafe<Core>,
         public base::MessagePumpLibevent::Watcher {
    public:
     Core(scoped_refptr<base::SingleThreadTaskRunner> caller_task_runner,
          scoped_refptr<base::SingleThreadTaskRunner> input_task_runner,
          base::WeakPtr<ClientSessionControl> client_session_control);
 
     void Start();
     void Stop();
@@ skipping 36 matching lines @@
     Display* display_;
     Display* x_record_display_;
     XRecordRange* x_record_range_[2];
     XRecordContext x_record_context_;
 
     DISALLOW_COPY_AND_ASSIGN(Core);
   };
 
   scoped_refptr<Core> core_;
 
-  DISALLOW_COPY_AND_ASSIGN(LocalInputMonitorX11);
+  DISALLOW_COPY_AND_ASSIGN(LocalInputMonitorLinux);
 };
 
-LocalInputMonitorX11::LocalInputMonitorX11(
+LocalInputMonitorLinux::LocalInputMonitorLinux(
     scoped_refptr<base::SingleThreadTaskRunner> caller_task_runner,
     scoped_refptr<base::SingleThreadTaskRunner> input_task_runner,
     base::WeakPtr<ClientSessionControl> client_session_control)
     : core_(new Core(caller_task_runner,
                      input_task_runner,
                      client_session_control)) {
   core_->Start();
 }
 
-LocalInputMonitorX11::~LocalInputMonitorX11() {
+LocalInputMonitorLinux::~LocalInputMonitorLinux() {
   core_->Stop();
 }
 
-LocalInputMonitorX11::Core::Core(
+LocalInputMonitorLinux::Core::Core(
     scoped_refptr<base::SingleThreadTaskRunner> caller_task_runner,
     scoped_refptr<base::SingleThreadTaskRunner> input_task_runner,
     base::WeakPtr<ClientSessionControl> client_session_control)
     : caller_task_runner_(caller_task_runner),
       input_task_runner_(input_task_runner),
       client_session_control_(client_session_control),
       alt_pressed_(false),
       ctrl_pressed_(false),
       display_(NULL),
       x_record_display_(NULL),
       x_record_context_(0) {
   DCHECK(caller_task_runner_->BelongsToCurrentThread());
   DCHECK(client_session_control_.get());
 
   x_record_range_[0] = NULL;
   x_record_range_[1] = NULL;
 }
 
-void LocalInputMonitorX11::Core::Start() {
+void LocalInputMonitorLinux::Core::Start() {
   DCHECK(caller_task_runner_->BelongsToCurrentThread());
 
   input_task_runner_->PostTask(FROM_HERE,
                                base::Bind(&Core::StartOnInputThread, this));
 }
 
-void LocalInputMonitorX11::Core::Stop() {
+void LocalInputMonitorLinux::Core::Stop() {
   DCHECK(caller_task_runner_->BelongsToCurrentThread());
 
   input_task_runner_->PostTask(FROM_HERE,
                                base::Bind(&Core::StopOnInputThread, this));
 }
 
-LocalInputMonitorX11::Core::~Core() {
+LocalInputMonitorLinux::Core::~Core() {
   DCHECK(!display_);
   DCHECK(!x_record_display_);
   DCHECK(!x_record_range_[0]);
   DCHECK(!x_record_range_[1]);
   DCHECK(!x_record_context_);
 }
 
-void LocalInputMonitorX11::Core::StartOnInputThread() {
+void LocalInputMonitorLinux::Core::StartOnInputThread() {
   DCHECK(input_task_runner_->BelongsToCurrentThread());
   DCHECK(!display_);
   DCHECK(!x_record_display_);
   DCHECK(!x_record_range_[0]);
   DCHECK(!x_record_range_[1]);
   DCHECK(!x_record_context_);
 
   // TODO(jamiewalch): We should pass the display in. At that point, since
   // XRecord needs a private connection to the X Server for its data channel
   // and both channels are used from a separate thread, we'll need to duplicate
@@ skipping 53 matching lines @@
     return;
   }
 
   // Fetch pending events if any.
   while (XPending(x_record_display_)) {
     XEvent ev;
     XNextEvent(x_record_display_, &ev);
   }
 }
 
-void LocalInputMonitorX11::Core::StopOnInputThread() {
+void LocalInputMonitorLinux::Core::StopOnInputThread() {
   DCHECK(input_task_runner_->BelongsToCurrentThread());
 
   // Context must be disabled via the control channel because we can't send
   // any X protocol traffic over the data channel while it's recording.
   if (x_record_context_) {
     XRecordDisableContext(display_, x_record_context_);
     XFlush(display_);
   }
 
   controller_.StopWatchingFileDescriptor();
@@ skipping 13 matching lines @@
   if (x_record_display_) {
     XCloseDisplay(x_record_display_);
     x_record_display_ = NULL;
   }
   if (display_) {
     XCloseDisplay(display_);
     display_ = NULL;
   }
 }
 
-void LocalInputMonitorX11::Core::OnFileCanReadWithoutBlocking(int fd) {
+void LocalInputMonitorLinux::Core::OnFileCanReadWithoutBlocking(int fd) {
   DCHECK(input_task_runner_->BelongsToCurrentThread());
 
   // Fetch pending events if any.
   while (XPending(x_record_display_)) {
     XEvent ev;
     XNextEvent(x_record_display_, &ev);
   }
 }
 
-void LocalInputMonitorX11::Core::OnFileCanWriteWithoutBlocking(int fd) {
+void LocalInputMonitorLinux::Core::OnFileCanWriteWithoutBlocking(int fd) {
   NOTREACHED();
 }
 
-void LocalInputMonitorX11::Core::ProcessXEvent(xEvent* event) {
+void LocalInputMonitorLinux::Core::ProcessXEvent(xEvent* event) {
   DCHECK(input_task_runner_->BelongsToCurrentThread());
 
   if (event->u.u.type == MotionNotify) {
     webrtc::DesktopVector position(event->u.keyButtonPointer.rootX,
                                    event->u.keyButtonPointer.rootY);
     caller_task_runner_->PostTask(
         FROM_HERE, base::Bind(&ClientSessionControl::OnLocalMouseMoved,
                               client_session_control_,
                               position));
   } else {
     int key_code = event->u.u.detail;
     bool down = event->u.u.type == KeyPress;
     KeySym key_sym = XkbKeycodeToKeysym(display_, key_code, 0, 0);
     if (key_sym == XK_Control_L || key_sym == XK_Control_R) {
       ctrl_pressed_ = down;
     } else if (key_sym == XK_Alt_L || key_sym == XK_Alt_R) {
       alt_pressed_ = down;
     } else if (key_sym == XK_Escape && down && alt_pressed_ && ctrl_pressed_) {
       caller_task_runner_->PostTask(
           FROM_HERE, base::Bind(&ClientSessionControl::DisconnectSession,
                                 client_session_control_));
     }
   }
 }
 
 // static
-void LocalInputMonitorX11::Core::ProcessReply(XPointer self,
+void LocalInputMonitorLinux::Core::ProcessReply(XPointer self,
                                                 XRecordInterceptData* data) {
   if (data->category == XRecordFromServer) {
     xEvent* event = reinterpret_cast<xEvent*>(data->data);
     reinterpret_cast<Core*>(self)->ProcessXEvent(event);
   }
   XRecordFreeData(data);
 }
 
 }  // namespace
 
 scoped_ptr<LocalInputMonitor> LocalInputMonitor::Create(
     scoped_refptr<base::SingleThreadTaskRunner> caller_task_runner,
     scoped_refptr<base::SingleThreadTaskRunner> input_task_runner,
     scoped_refptr<base::SingleThreadTaskRunner> ui_task_runner,
     base::WeakPtr<ClientSessionControl> client_session_control) {
-  return make_scoped_ptr(new LocalInputMonitorX11(
+  return make_scoped_ptr(new LocalInputMonitorLinux(
       caller_task_runner, input_task_runner, client_session_control));
 }
 
 }  // namespace remoting