VR: Send separate down and up events for controller clicks.

chrome/browser/android/vr_shell/vr_shell_gl.cc

 // Copyright 2016 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 "chrome/browser/android/vr_shell/vr_shell_gl.h"
 
 #include <chrono>
 #include <limits>
 #include <utility>
 
@@ skipping 145 matching lines @@
   result.m[2][2] = C;
   result.m[2][3] = D;
   result.m[3][2] = -1;
 
   return result;
 }
 
 std::unique_ptr<blink::WebMouseEvent> MakeMouseEvent(
     blink::WebInputEvent::Type type,
     double timestamp,
-    const gfx::Point& loc) {
-  std::unique_ptr<blink::WebMouseEvent> mouse_event(new blink::WebMouseEvent(
-      type, blink::WebInputEvent::kNoModifiers, timestamp));
+    const gfx::Point& loc,
+    bool down) {
+  blink::WebInputEvent::Modifiers mods =

[cjgrant, 2017/06/13 19:39:04]

s/mods/modifiers/ ?  And s/loc/location/ above?

[mthiesse, 2017/06/13 19:55:45]

Done.

+      down ? blink::WebInputEvent::kLeftButtonDown
+           : blink::WebInputEvent::kNoModifiers;
+  std::unique_ptr<blink::WebMouseEvent> mouse_event(
+      new blink::WebMouseEvent(type, mods, timestamp));
   mouse_event->pointer_type = blink::WebPointerProperties::PointerType::kMouse;
+  mouse_event->button = blink::WebPointerProperties::Button::kLeft;
   mouse_event->SetPositionInWidget(loc.x(), loc.y());
   mouse_event->click_count = 1;
 
   return mouse_event;
 }
 
 
 void MatfToGvrMat(const vr::Mat4f& in, gvr::Mat4f* out) {
   // If our std::array implementation doesn't have any non-data members, we can
   // just cast the gvr matrix to an std::array.
@@ skipping 419 matching lines @@
     }
   }
   // If we're still scrolling, don't hover (and we can't be clicking, because
   // click ends scroll).
   if (in_scroll_)
     return;
   SendHoverLeave(target_element);
   if (!SendHoverEnter(target_element, target_local_point, local_point_pixels)) {
     SendHoverMove(target_local_point, local_point_pixels);
   }
-  SendButtonDown(target_element, target_local_point);
-  if (!SendButtonUp(target_element, target_local_point))
+  SendButtonDown(target_element, target_local_point, local_point_pixels);
+  if (!SendButtonUp(target_element, target_local_point, local_point_pixels))
     SendTap(target_element, target_local_point, local_point_pixels);
 }
 
 void VrShellGl::HandleWebVrCompatibilityClick() {
   if (!ShouldDrawWebVr())
     return;
 
   // Process screen touch events for Cardboard button compatibility.
   // Also send tap events for controller "touchpad click" events.
   if (touch_pending_ ||
@@ skipping 78 matching lines @@
   DCHECK_EQ(input_locked_element_->fill(), Fill::CONTENT);
   SendGestureToContent(std::move(gesture_list.front()));
   gesture_list.erase(gesture_list.begin());
 }
 
 void VrShellGl::SendHoverLeave(UiElement* target) {
   if (!hover_target_ || (target == hover_target_))
     return;
   if (hover_target_->fill() == Fill::CONTENT) {
     SendGestureToContent(MakeMouseEvent(blink::WebInputEvent::kMouseLeave,
-                                        NowSeconds(), gfx::Point()));
+                                        NowSeconds(), gfx::Point(), in_click_));
   } else {
     hover_target_->OnHoverLeave();
   }
   hover_target_ = nullptr;
 }
 
 bool VrShellGl::SendHoverEnter(UiElement* target,
                                const gfx::PointF& target_point,
                                const gfx::Point& local_point_pixels) {
   if (!target || target == hover_target_)
     return false;
   if (target->fill() == Fill::CONTENT) {
     SendGestureToContent(MakeMouseEvent(blink::WebInputEvent::kMouseEnter,
-                                        NowSeconds(), local_point_pixels));
+                                        NowSeconds(), local_point_pixels,
+                                        in_click_));
   } else {
     target->OnHoverEnter(target_point);
   }
   hover_target_ = target;
   return true;
 }
 
 void VrShellGl::SendHoverMove(const gfx::PointF& target_point,
                               const gfx::Point& local_point_pixels) {
   if (!hover_target_)
     return;
   if (hover_target_->fill() == Fill::CONTENT) {
     SendGestureToContent(MakeMouseEvent(blink::WebInputEvent::kMouseMove,
-                                        NowSeconds(), local_point_pixels));
+                                        NowSeconds(), local_point_pixels,
+                                        in_click_));
   } else {
     hover_target_->OnMove(target_point);
   }
 }
 
 void VrShellGl::SendButtonDown(UiElement* target,
-                               const gfx::PointF& target_point) {
+                               const gfx::PointF& target_point,
+                               const gfx::Point& local_point_pixels) {
   if (in_click_)
     return;
   if (!controller_->ButtonDownHappened(gvr::kControllerButtonClick))
     return;
   input_locked_element_ = target;
   in_click_ = true;
-  // We don't support down/up for content yet.
-  if (!target || target->fill() == Fill::CONTENT)
+  if (!target)
     return;
-  target->OnButtonDown(target_point);
+  if (target->fill() == Fill::CONTENT) {
+    SendGestureToContent(MakeMouseEvent(blink::WebInputEvent::kMouseDown,
+                                        NowSeconds(), local_point_pixels,
+                                        in_click_));
+  } else {
+    target->OnButtonDown(target_point);
+  }
 }
 
 bool VrShellGl::SendButtonUp(UiElement* target,
-                             const gfx::PointF& target_point) {
+                             const gfx::PointF& target_point,
+                             const gfx::Point& local_point_pixels) {
   if (!in_click_)
     return false;
-  if (!controller_->ButtonUpHappened(gvr::kControllerButtonClick))
+  if (!controller_->ButtonUpHappened(gvr::kControllerButtonClick) &&
+      controller_->ButtonState(gvr::kControllerButtonClick))
     return false;
   in_click_ = false;
   if (!input_locked_element_)
     return true;
   DCHECK(input_locked_element_ == target);
   input_locked_element_ = nullptr;
-  // We don't support down/up for content yet.
-  if (target->fill() == Fill::CONTENT)
-    return false;
-  target->OnButtonUp(target_point);
+  if (target->fill() == Fill::CONTENT) {
+    SendGestureToContent(MakeMouseEvent(blink::WebInputEvent::kMouseUp,
+                                        NowSeconds(), local_point_pixels,
+                                        in_click_));
+  } else {
+    target->OnButtonUp(target_point);
+  }
   return true;
 }
 
 void VrShellGl::SendTap(UiElement* target,
                         const gfx::PointF& target_point,
                         const gfx::Point& local_point_pixels) {
   if (!target)
     return;
-  if (controller_->ButtonUpHappened(gvr::kControllerButtonClick) &&
-      target->fill() == Fill::CONTENT)
-    touch_pending_ = true;
   if (!touch_pending_)
     return;
   touch_pending_ = false;
   if (target->fill() == Fill::CONTENT) {
     auto gesture = base::MakeUnique<blink::WebGestureEvent>(
         blink::WebInputEvent::kGestureTapDown,
         blink::WebInputEvent::kNoModifiers, NowSeconds());
     gesture->source_device = blink::kWebGestureDeviceTouchpad;
     gesture->x = local_point_pixels.x();
     gesture->y = local_point_pixels.y();
@@ skipping 788 matching lines @@
   // This assumes that the initial webvr_surface_size_ was set to the
   // appropriate recommended render resolution as the default size during
   // InitializeGl. Revisit if the initialization order changes.
   device::mojom::VRDisplayInfoPtr info =
       device::GvrDelegate::CreateVRDisplayInfo(gvr_api_.get(),
                                                webvr_surface_size_, device_id);
   browser_->RunVRDisplayInfoCallback(callback, &info);
 }
 
 }  // namespace vr_shell