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

remoting/host/input_injector_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/input_injector.h"
 
 #include <X11/extensions/XInput.h>
 #include <X11/extensions/XTest.h>
 #include <X11/Xlib.h>
 #include <X11/XKBlib.h>
@@ skipping 69 matching lines @@
     }
   }
 
   return false;
 }
 
 // Pixel-to-wheel-ticks conversion ratio used by GTK.
 // From third_party/WebKit/Source/web/gtk/WebInputEventFactory.cpp .
 const float kWheelTicksPerPixel = 3.0f / 160.0f;
 
-// A class to generate events on X11.
-class InputInjectorX11 : public InputInjector {
+// A class to generate events on Linux.
+class InputInjectorLinux : public InputInjector {
  public:
-  explicit InputInjectorX11(
+  explicit InputInjectorLinux(
       scoped_refptr<base::SingleThreadTaskRunner> task_runner);
-  ~InputInjectorX11() override;
+  ~InputInjectorLinux() override;
 
   bool Init();
 
   // Clipboard stub interface.
   void InjectClipboardEvent(const ClipboardEvent& event) override;
 
   // InputStub interface.
   void InjectKeyEvent(const KeyEvent& event) override;
   void InjectTextEvent(const TextEvent& event) override;
   void InjectMouseEvent(const MouseEvent& event) override;
 
   // InputInjector interface.
   void Start(scoped_ptr<protocol::ClipboardStub> client_clipboard) override;
 
  private:
-  // The actual implementation resides in InputInjectorX11::Core class.
+  // The actual implementation resides in InputInjectorLinux::Core class.
   class Core : public base::RefCountedThreadSafe<Core> {
    public:
     explicit Core(scoped_refptr<base::SingleThreadTaskRunner> task_runner);
 
     bool Init();
 
     // Mirrors the ClipboardStub interface.
     void InjectClipboardEvent(const ClipboardEvent& event);
 
     // Mirrors the InputStub interface.
@@ skipping 51 matching lines @@
 
     scoped_ptr<Clipboard> clipboard_;
 
     bool saved_auto_repeat_enabled_;
 
     DISALLOW_COPY_AND_ASSIGN(Core);
   };
 
   scoped_refptr<Core> core_;
 
-  DISALLOW_COPY_AND_ASSIGN(InputInjectorX11);
+  DISALLOW_COPY_AND_ASSIGN(InputInjectorLinux);
 };
 
-InputInjectorX11::InputInjectorX11(
+InputInjectorLinux::InputInjectorLinux(
     scoped_refptr<base::SingleThreadTaskRunner> task_runner) {
   core_ = new Core(task_runner);
 }
 
-InputInjectorX11::~InputInjectorX11() {
+InputInjectorLinux::~InputInjectorLinux() {
   core_->Stop();
 }
 
-bool InputInjectorX11::Init() {
+bool InputInjectorLinux::Init() {
   return core_->Init();
 }
 
-void InputInjectorX11::InjectClipboardEvent(const ClipboardEvent& event) {
+void InputInjectorLinux::InjectClipboardEvent(const ClipboardEvent& event) {
   core_->InjectClipboardEvent(event);
 }
 
-void InputInjectorX11::InjectKeyEvent(const KeyEvent& event) {
+void InputInjectorLinux::InjectKeyEvent(const KeyEvent& event) {
   core_->InjectKeyEvent(event);
 }
 
-void InputInjectorX11::InjectTextEvent(const TextEvent& event) {
+void InputInjectorLinux::InjectTextEvent(const TextEvent& event) {
   core_->InjectTextEvent(event);
 }
 
-void InputInjectorX11::InjectMouseEvent(const MouseEvent& event) {
+void InputInjectorLinux::InjectMouseEvent(const MouseEvent& event) {
   core_->InjectMouseEvent(event);
 }
 
-void InputInjectorX11::Start(
+void InputInjectorLinux::Start(
     scoped_ptr<protocol::ClipboardStub> client_clipboard) {
   core_->Start(client_clipboard.Pass());
 }
 
-InputInjectorX11::Core::Core(
+InputInjectorLinux::Core::Core(
     scoped_refptr<base::SingleThreadTaskRunner> task_runner)
     : task_runner_(task_runner),
       latest_mouse_position_(-1, -1),
       wheel_ticks_x_(0.0f),
       wheel_ticks_y_(0.0f),
       display_(XOpenDisplay(NULL)),
       root_window_(BadValue),
       saved_auto_repeat_enabled_(false) {
 }
 
-bool InputInjectorX11::Core::Init() {
+bool InputInjectorLinux::Core::Init() {
   CHECK(display_);
 
   if (!task_runner_->BelongsToCurrentThread())
     task_runner_->PostTask(FROM_HERE, base::Bind(&Core::InitClipboard, this));
 
   root_window_ = RootWindow(display_, DefaultScreen(display_));
   if (root_window_ == BadValue) {
     LOG(ERROR) << "Unable to get the root window";
     return false;
   }
 
   // TODO(ajwong): Do we want to check the major/minor version at all for XTest?
   int major = 0;
   int minor = 0;
   if (!XTestQueryExtension(display_, &test_event_base_, &test_error_base_,
                            &major, &minor)) {
     LOG(ERROR) << "Server does not support XTest.";
     return false;
   }
   InitMouseButtonMap();
   return true;
 }
 
-void InputInjectorX11::Core::InjectClipboardEvent(
+void InputInjectorLinux::Core::InjectClipboardEvent(
     const ClipboardEvent& event) {
   if (!task_runner_->BelongsToCurrentThread()) {
     task_runner_->PostTask(
         FROM_HERE, base::Bind(&Core::InjectClipboardEvent, this, event));
     return;
   }
 
   // |clipboard_| will ignore unknown MIME-types, and verify the data's format.
   clipboard_->InjectClipboardEvent(event);
 }
 
-void InputInjectorX11::Core::InjectKeyEvent(const KeyEvent& event) {
+void InputInjectorLinux::Core::InjectKeyEvent(const KeyEvent& event) {
   // HostEventDispatcher should filter events missing the pressed field.
   if (!event.has_pressed() || !event.has_usb_keycode())
     return;
 
   if (!task_runner_->BelongsToCurrentThread()) {
     task_runner_->PostTask(FROM_HERE,
                            base::Bind(&Core::InjectKeyEvent, this, event));
     return;
   }
 
@@ skipping 28 matching lines @@
       // Re-enable auto-repeat, if necessary, when all keys are released.
       if (saved_auto_repeat_enabled_)
         SetAutoRepeatEnabled(true);
     }
   }
 
   XTestFakeKeyEvent(display_, keycode, event.pressed(), CurrentTime);
   XFlush(display_);
 }
 
-void InputInjectorX11::Core::InjectTextEvent(const TextEvent& event) {
+void InputInjectorLinux::Core::InjectTextEvent(const TextEvent& event) {
   if (!task_runner_->BelongsToCurrentThread()) {
     task_runner_->PostTask(FROM_HERE,
                            base::Bind(&Core::InjectTextEvent, this, event));
     return;
   }
 
   const std::string text = event.text();
   for (int32 index = 0; index < static_cast<int32>(text.size()); ++index) {
     uint32_t code_point;
     if (!base::ReadUnicodeCharacter(
@@ skipping 10 matching lines @@
 
     XTestFakeKeyEvent(display_, keycode, True, CurrentTime);
     XTestFakeKeyEvent(display_, keycode, False, CurrentTime);
 
     XkbLockModifiers(display_, XkbUseCoreKbd, modifiers, 0);
   }
 
   XFlush(display_);
 }
 
-InputInjectorX11::Core::~Core() {
+InputInjectorLinux::Core::~Core() {
   CHECK(pressed_keys_.empty());
 }
 
-void InputInjectorX11::Core::InitClipboard() {
+void InputInjectorLinux::Core::InitClipboard() {
   DCHECK(task_runner_->BelongsToCurrentThread());
   clipboard_ = Clipboard::Create();
 }
 
-bool InputInjectorX11::Core::IsAutoRepeatEnabled() {
+bool InputInjectorLinux::Core::IsAutoRepeatEnabled() {
   XKeyboardState state;
   if (!XGetKeyboardControl(display_, &state)) {
     LOG(ERROR) << "Failed to get keyboard auto-repeat status, assuming ON.";
     return true;
   }
   return state.global_auto_repeat == AutoRepeatModeOn;
 }
 
-void InputInjectorX11::Core::SetAutoRepeatEnabled(bool mode) {
+void InputInjectorLinux::Core::SetAutoRepeatEnabled(bool mode) {
   XKeyboardControl control;
   control.auto_repeat_mode = mode ? AutoRepeatModeOn : AutoRepeatModeOff;
   XChangeKeyboardControl(display_, KBAutoRepeatMode, &control);
 }
 
-void InputInjectorX11::Core::InjectScrollWheelClicks(int button, int count) {
+void InputInjectorLinux::Core::InjectScrollWheelClicks(int button, int count) {
   if (button < 0) {
     LOG(WARNING) << "Ignoring unmapped scroll wheel button";
     return;
   }
   for (int i = 0; i < count; i++) {
     // Generate a button-down and a button-up to simulate a wheel click.
     XTestFakeButtonEvent(display_, button, true, CurrentTime);
     XTestFakeButtonEvent(display_, button, false, CurrentTime);
   }
 }
 
-void InputInjectorX11::Core::InjectMouseEvent(const MouseEvent& event) {
+void InputInjectorLinux::Core::InjectMouseEvent(const MouseEvent& event) {
   if (!task_runner_->BelongsToCurrentThread()) {
     task_runner_->PostTask(FROM_HERE,
                            base::Bind(&Core::InjectMouseEvent, this, event));
     return;
   }
 
   if (event.has_delta_x() &&
       event.has_delta_y() &&
       (event.delta_x() != 0 || event.delta_y() != 0)) {
     latest_mouse_position_.set(-1, -1);
@@ skipping 70 matching lines @@
     wheel_ticks_x_ -= ticks_x;
   }
   if (ticks_x != 0) {
     InjectScrollWheelClicks(HorizontalScrollWheelToX11ButtonNumber(ticks_x),
                             abs(ticks_x));
   }
 
   XFlush(display_);
 }
 
-void InputInjectorX11::Core::InitMouseButtonMap() {
+void InputInjectorLinux::Core::InitMouseButtonMap() {
   // TODO(rmsousa): Run this on global/device mapping change events.
 
   // Do not touch global pointer mapping, since this may affect the local user.
   // Instead, try to work around it by reversing the mapping.
   // Note that if a user has a global mapping that completely disables a button
   // (by assigning 0 to it), we won't be able to inject it.
   int num_buttons = XGetPointerMapping(display_, NULL, 0);
   scoped_ptr<unsigned char[]> pointer_mapping(new unsigned char[num_buttons]);
   num_buttons = XGetPointerMapping(display_, pointer_mapping.get(),
                                    num_buttons);
@@ skipping 55 matching lines @@
     button_mapping[i] = i + 1;
   }
   error = XSetDeviceButtonMapping(display_, device, button_mapping.get(),
                                   num_device_buttons);
   if (error != Success)
     LOG(ERROR) << "Failed to set XTest device button mapping: " << error;
 
   XCloseDevice(display_, device);
 }
 
-int InputInjectorX11::Core::MouseButtonToX11ButtonNumber(
+int InputInjectorLinux::Core::MouseButtonToX11ButtonNumber(
     MouseEvent::MouseButton button) {
   switch (button) {
     case MouseEvent::BUTTON_LEFT:
       return pointer_button_map_[0];
 
     case MouseEvent::BUTTON_RIGHT:
       return pointer_button_map_[2];
 
     case MouseEvent::BUTTON_MIDDLE:
       return pointer_button_map_[1];
 
     case MouseEvent::BUTTON_UNDEFINED:
     default:
       return -1;
   }
 }
 
-int InputInjectorX11::Core::HorizontalScrollWheelToX11ButtonNumber(int dx) {
+int InputInjectorLinux::Core::HorizontalScrollWheelToX11ButtonNumber(int dx) {
   return (dx > 0 ? pointer_button_map_[5] : pointer_button_map_[6]);
 }
 
-int InputInjectorX11::Core::VerticalScrollWheelToX11ButtonNumber(int dy) {
+int InputInjectorLinux::Core::VerticalScrollWheelToX11ButtonNumber(int dy) {
   // Positive y-values are wheel scroll-up events (button 4), negative y-values
   // are wheel scroll-down events (button 5).
   return (dy > 0 ? pointer_button_map_[3] : pointer_button_map_[4]);
 }
 
-void InputInjectorX11::Core::Start(
+void InputInjectorLinux::Core::Start(
     scoped_ptr<protocol::ClipboardStub> client_clipboard) {
   if (!task_runner_->BelongsToCurrentThread()) {
     task_runner_->PostTask(
         FROM_HERE,
         base::Bind(&Core::Start, this, base::Passed(&client_clipboard)));
     return;
   }
 
   InitMouseButtonMap();
 
   clipboard_->Start(client_clipboard.Pass());
 }
 
-void InputInjectorX11::Core::Stop() {
+void InputInjectorLinux::Core::Stop() {
   if (!task_runner_->BelongsToCurrentThread()) {
     task_runner_->PostTask(FROM_HERE, base::Bind(&Core::Stop, this));
     return;
   }
 
   clipboard_->Stop();
 }
 
 }  // namespace
 
 scoped_ptr<InputInjector> InputInjector::Create(
     scoped_refptr<base::SingleThreadTaskRunner> main_task_runner,
     scoped_refptr<base::SingleThreadTaskRunner> ui_task_runner) {
-  scoped_ptr<InputInjectorX11> injector(
-      new InputInjectorX11(main_task_runner));
+  scoped_ptr<InputInjectorLinux> injector(
+      new InputInjectorLinux(main_task_runner));
   if (!injector->Init())
     return nullptr;
   return injector.Pass();
 }
 
 }  // namespace remoting