blimp: Add support for input handling

blimp/client/input/blimp_input_manager.cc

+// Copyright 2015 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 "blimp/client/input/blimp_input_manager.h"
+
+#include "base/auto_reset.h"
+#include "base/bind.h"
+#include "base/location.h"
+#include "ui/events/blink/blink_event_util.h"
+#include "ui/events/gesture_detection/gesture_provider_config_helper.h"
+
+namespace blimp {
+
+scoped_ptr<BlimpInputManager> BlimpInputManager::Create(
+      BlimpInputManagerClient* client,
+      scoped_refptr<base::SingleThreadTaskRunner> main_task_runner,
+      scoped_refptr<base::SingleThreadTaskRunner> compositor_task_runner,
+      const base::WeakPtr<cc::InputHandler>& input_handler) {
+  return make_scoped_ptr(new BlimpInputManager(client,
+                                               main_task_runner,
+                                               compositor_task_runner,
+                                               input_handler));
+}
+
+BlimpInputManager::BlimpInputManager(
+    BlimpInputManagerClient* client,
+    scoped_refptr<base::SingleThreadTaskRunner> main_task_runner,
+    scoped_refptr<base::SingleThreadTaskRunner> compositor_task_runner,
+    const base::WeakPtr<cc::InputHandler>& input_handler)
+    : client_(client),
+      gesture_provider_(ui::GetGestureProviderConfig(
+                ui::GestureProviderConfigType::CURRENT_PLATFORM), this),
+      main_task_runner_(main_task_runner),
+      compositor_task_runner_(compositor_task_runner),
+      main_thread_blocked_(false),
+      weak_factory_(this) {
+  DCHECK(IsMainThread());
+  compositor_task_runner_->PostTask(
+      FROM_HERE,
+      base::Bind(
+          &BlimpInputManager::CreateInputHandlerWrapperOnCompositorThread,
+          base::Unretained(this), weak_factory_.GetWeakPtr(),
+          input_handler));
+}
+
+BlimpInputManager::~BlimpInputManager() {
+  DCHECK(IsMainThread());
+
+  base::WaitableEvent shutdown_event(false /* manual_reset */,
+                                     false /* initially_signaled */);
+  {
+    base::AutoReset<bool> auto_reset_main_thread_blocked(
+        &main_thread_blocked_, true);
+    compositor_task_runner_->PostTask(
+        FROM_HERE,
+        base::Bind(
+            &BlimpInputManager::ShutdownOnCompositorThread,
+            base::Unretained(this), &shutdown_event));
+    shutdown_event.Wait();
+  }
+}
+
+bool BlimpInputManager::OnTouchEvent(const ui::MotionEvent& motion_event) {
+  DCHECK(IsMainThread());
+
+  ui::FilteredGestureProvider::TouchHandlingResult result =
+      gesture_provider_.OnTouchEvent(motion_event);
+  if (!result.succeeded)
+    return false;
+
+  blink::WebTouchEvent touch =
+      ui::CreateWebTouchEventFromMotionEvent(motion_event,
+                                             result.did_generate_scroll);
+
+  // Touch events are queued in the Gesture Provider until acknowledged to
+  // allow them to be consumed by the touch event handlers in blink which can
+  // prevent-default on the event. Since we currently do not support touch
+  // handlers the event is always acknowledged as not consumed.
+  gesture_provider_.OnTouchEventAck(touch.uniqueTouchEventId, false);
+
+  return true;
+}
+
+void BlimpInputManager::OnGestureEvent(const ui::GestureEventData& gesture) {
+  DCHECK(IsMainThread());
+
+  blink::WebGestureEvent web_gesture =
+      ui::CreateWebGestureEventFromGestureEventData(gesture);
+  // TODO(jdduke): Remove this workaround after Android fixes UiAutomator to

[nyquist, 2015/12/05 01:54:42]

I'm not sure jdduke@ will be able to look at this. I don't think he focused on
Chrome anymore.

[Khushal, 2015/12/07 23:01:22]

Oh. I'll assign it to myself then.

+  // stop providing shift meta values to synthetic MotionEvents. This prevents
+  // unintended shift+click interpretation of all accessibility clicks.
+  // See crbug.com/443247.
+  if (web_gesture.type == blink::WebInputEvent::GestureTap &&
+      web_gesture.modifiers == blink::WebInputEvent::ShiftKey) {
+    web_gesture.modifiers = 0;
+  }
+
+  compositor_task_runner_->PostTask(
+      FROM_HERE,
+      base::Bind(
+          &BlimpInputManager::HandleWebInputEventOnCompositorThread,
+          base::Unretained(this), web_gesture));
+}
+
+void BlimpInputManager::CreateInputHandlerWrapperOnCompositorThread(
+    base::WeakPtr<BlimpInputManager> input_manager_weak_ptr,
+    const base::WeakPtr<cc::InputHandler>& input_handler) {
+  DCHECK(IsCompositorThread());
+
+  // The input_handler might have been destroyed at this point.
+  if (!input_handler)
+    return;
+
+  DCHECK(!input_handler_);
+  input_handler_ = make_scoped_ptr(
+      new BlimpInputHandlerWrapper(main_task_runner_,
+                                   input_manager_weak_ptr,
+                                   input_handler.get()));
+}
+
+void BlimpInputManager::HandleWebInputEventOnCompositorThread(
+    const blink::WebInputEvent& input_event) {
+  DCHECK(IsCompositorThread());
+
+  if (input_handler_)
+    input_handler_->HandleWebInputEvent(input_event);
+}
+
+void BlimpInputManager::ShutdownOnCompositorThread(
+    base::WaitableEvent* shutdown_event) {
+  DCHECK(IsCompositorThread());
+  DCHECK(main_thread_blocked_);
+
+  input_handler_.reset();
+  shutdown_event->Signal();
+}
+
+void BlimpInputManager::DidHandleWebInputEvent(
+    const blink::WebInputEvent& input_event, bool consumed) {
+  DCHECK(IsMainThread());
+
+  if (!consumed)
+    client_->SendWebInputEvent(input_event);
+}
+
+bool BlimpInputManager::IsMainThread() const {
+  return main_task_runner_->BelongsToCurrentThread();
+}
+
+bool BlimpInputManager::IsCompositorThread() const {
+  return compositor_task_runner_->BelongsToCurrentThread();
+}
+
+}  // namespace blimp