Remote assistance on Chrome OS Part IX - Input injection on Ozone

remoting/host/input_injector_chromeos.cc

 // Copyright 2014 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_chromeos.h"
 
-#include "base/logging.h"
+#include "base/bind.h"
+#include "base/bind_helpers.h"
+#include "base/location.h"
+#include "remoting/host/chromeos/display_transform_util.h"
+#include "remoting/host/clipboard.h"
 #include "remoting/proto/internal.pb.h"
+#include "ui/events/keycodes/dom3/dom_code.h"
+#include "ui/events/keycodes/dom4/keycode_converter.h"
+#include "ui/ozone/public/ozone_platform.h"
+#include "ui/ozone/public/system_input_injector.h"
 
 namespace remoting {
 
 using protocol::ClipboardEvent;
 using protocol::KeyEvent;
 using protocol::MouseEvent;
 using protocol::TextEvent;
 
-// TODO(kelvinp): Implement this class (See crbug.com/426716).
+namespace {
+
+ui::EventFlags MouseButtonToUIFlags(MouseEvent::MouseButton button) {
+  switch (button) {
+    case MouseEvent::BUTTON_LEFT:
+      return ui::EF_LEFT_MOUSE_BUTTON;
+    case MouseEvent::BUTTON_RIGHT:
+      return ui::EF_RIGHT_MOUSE_BUTTON;
+    case MouseEvent::BUTTON_MIDDLE:
+      return ui::EF_MIDDLE_MOUSE_BUTTON;
+    default:
+      NOTREACHED();
+      return ui::EF_NONE;
+  }
+}
+
+}  // namespace
+
+class InputInjectorChromeos::Core {

[Wez, 2014/12/04 01:28:25]

nit: Suggest comment to clarify that this class is run exclusively on
<whatever-thread>

[kelvinp, 2014/12/05 03:17:28]

Done.

+ public:
+  explicit Core(scoped_ptr<ui::SystemInputInjector> delegate_);
+
+  // Mirrors the public InputInjectorChromeos interface.
+  void InjectClipboardEvent(const ClipboardEvent& event);
+  void InjectKeyEvent(const KeyEvent& event);
+  void InjectTextEvent(const TextEvent& event);
+  void InjectMouseEvent(const MouseEvent& event);
+  void Start(scoped_ptr<protocol::ClipboardStub> client_clipboard);
+
+ private:
+  scoped_ptr<ui::SystemInputInjector> delegate_;
+  scoped_ptr<Clipboard> clipboard_;
+
+  DISALLOW_COPY_AND_ASSIGN(Core);
+};
+
+InputInjectorChromeos::Core::Core(scoped_ptr<ui::SystemInputInjector> delegate)
+    : delegate_(delegate.Pass()),
+      clipboard_(Clipboard::Create()) {

[Wez, 2014/12/04 01:28:25]

nit: Clarify what sort of Clipboard we're creating here; is it going to be the
usual X11 one?

[kelvinp, 2014/12/05 03:17:28]

Done.

+  DCHECK(delegate);
+
+  // TODO(kelvinp): Disable AutoRepeat as long as keys are pressed on ChromeOS
+  // when the auto-repeat API is ready to avoid triggering the auto-repeat if
+  // network congestion delays the key-up event from the client
+  // (See crbug.com/425201).

[Wez, 2014/12/04 01:28:25]

This comment belongs in InjectKeyEvent, I think?

[kelvinp, 2014/12/05 03:17:28]

Done.

+}
+
+void InputInjectorChromeos::Core::InjectClipboardEvent(
+    const ClipboardEvent& event) {
+  clipboard_->InjectClipboardEvent(event);
+}
+
+void InputInjectorChromeos::Core::InjectKeyEvent(const KeyEvent& event) {
+  if (!event.has_pressed() || !event.has_usb_keycode()) {

[Wez, 2014/12/04 01:28:25]

Why do you need these tests? Events are received via the IPC channel or
EventDispatcher, both of which suppress events that are missing these fields,
don't they?  If so then you should just DCHECK

[kelvinp, 2014/12/05 03:17:28]

Done.

+    return;
+  }
+
+  ui::DomCode dom_code =
+      ui::KeycodeConverter::UsbKeycodeToDomCode(event.usb_keycode());
+
+  // Ignore events which can't be mapped.
+  if (dom_code != ui::DomCode::NONE) {
+    delegate_->InjectKeyPress(dom_code, event.pressed());
+  }
+}
+
+void InputInjectorChromeos::Core::InjectTextEvent(const TextEvent& event) {
+  // TextEvents are not supported on Chrome OS.
+  NOTIMPLEMENTED();

[Wez, 2014/12/04 01:28:25]

Doesn't that mean that the Android client won't work properly? In which case
refer to the bug for getting this properly implemented.

[kelvinp, 2014/12/05 03:17:28]

We only support It2me on ChromeOS, which is not supported on Android.  So we are
fine for now.

+}
+
+void InputInjectorChromeos::Core::InjectMouseEvent(const MouseEvent& event) {
+  if (event.has_button() && event.has_button_down()) {
+    delegate_->InjectMouseButton(MouseButtonToUIFlags(event.button()),
+                                 event.button_down());
+  } else if (event.has_wheel_delta_y() || event.has_wheel_delta_x()) {
+    delegate_->InjectMouseWheel(event.wheel_delta_x(), event.wheel_delta_y());
+  } else {
+    DCHECK(event.has_x() && event.has_y());
+    delegate_->MoveCursorTo(
+        ConvertPointToNativeScreen(gfx::PointF(event.x(), event.y())));
+  }
+}
+
+void InputInjectorChromeos::Core::Start(
+    scoped_ptr<protocol::ClipboardStub> client_clipboard) {
+  clipboard_->Start(client_clipboard.Pass());
+}
+
 InputInjectorChromeos::InputInjectorChromeos(
     scoped_refptr<base::SingleThreadTaskRunner> task_runner)
     : input_task_runner_(task_runner) {
-  NOTIMPLEMENTED();
+  ui::OzonePlatform* ozone_platform = ui::OzonePlatform::GetInstance();
+  core_.reset(new Core(ozone_platform->CreateSystemInputInjector()));
 }
 
 InputInjectorChromeos::~InputInjectorChromeos() {
-  NOTIMPLEMENTED();
+  input_task_runner_->DeleteSoon(FROM_HERE, core_.release());
 }
 
 void InputInjectorChromeos::InjectClipboardEvent(const ClipboardEvent& event) {
-  NOTIMPLEMENTED();
+  input_task_runner_->PostTask(
+      FROM_HERE, base::Bind(&Core::InjectClipboardEvent,
+                            base::Unretained(core_.get()), event));
 }
 
 void InputInjectorChromeos::InjectKeyEvent(const KeyEvent& event) {
-  NOTIMPLEMENTED();
+  input_task_runner_->PostTask(
+      FROM_HERE,
+      base::Bind(&Core::InjectKeyEvent, base::Unretained(core_.get()), event));
 }
 
 void InputInjectorChromeos::InjectTextEvent(const TextEvent& event) {
-  NOTIMPLEMENTED();
+  input_task_runner_->PostTask(
+      FROM_HERE,
+      base::Bind(&Core::InjectTextEvent, base::Unretained(core_.get()), event));
 }
 
 void InputInjectorChromeos::InjectMouseEvent(const MouseEvent& event) {
-  NOTIMPLEMENTED();
+  input_task_runner_->PostTask(
+      FROM_HERE, base::Bind(&Core::InjectMouseEvent,
+                            base::Unretained(core_.get()), event));
 }
 
 void InputInjectorChromeos::Start(
     scoped_ptr<protocol::ClipboardStub> client_clipboard) {
-  NOTIMPLEMENTED();
+  input_task_runner_->PostTask(
+      FROM_HERE, base::Bind(&Core::Start, base::Unretained(core_.get()),
+                            base::Passed(&client_clipboard)));
 }
 
 // static
 scoped_ptr<InputInjector> InputInjector::Create(
     scoped_refptr<base::SingleThreadTaskRunner> input_task_runner,
     scoped_refptr<base::SingleThreadTaskRunner> ui_task_runner) {
-  scoped_ptr<InputInjectorChromeos> injector(new InputInjectorChromeos(
-      ui_task_runner));
-  return injector.Pass();
+  return make_scoped_ptr(new InputInjectorChromeos(ui_task_runner));

[Wez, 2014/12/04 01:28:25]

nit: Explain why the Core runs on the ui task runner.

[kelvinp, 2014/12/05 03:17:28]

Done.

 }
 
 }  // namespace remoting