VR: Use more accurate timestamps for input events.

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 12 matching lines @@
 #include "chrome/browser/android/vr_shell/vr_controller.h"
 #include "chrome/browser/android/vr_shell/vr_gl_util.h"
 #include "chrome/browser/android/vr_shell/vr_metrics_util.h"
 #include "chrome/browser/android/vr_shell/vr_shell.h"
 #include "chrome/browser/android/vr_shell/vr_shell_renderer.h"
 #include "chrome/browser/android/vr_shell/vr_usage_monitor.h"
 #include "device/vr/android/gvr/gvr_delegate.h"
 #include "device/vr/android/gvr/gvr_device.h"
 #include "device/vr/android/gvr/gvr_gamepad_data_provider.h"
 #include "third_party/WebKit/public/platform/WebGestureEvent.h"
-#include "third_party/WebKit/public/platform/WebInputEvent.h"
 #include "third_party/WebKit/public/platform/WebMouseEvent.h"
 #include "ui/gl/android/scoped_java_surface.h"
 #include "ui/gl/android/surface_texture.h"
 #include "ui/gl/gl_bindings.h"
 #include "ui/gl/gl_context.h"
 #include "ui/gl/gl_fence_egl.h"
 #include "ui/gl/gl_surface.h"
 #include "ui/gl/init/gl_factory.h"
 
 namespace vr_shell {
@@ skipping 121 matching lines @@
   result.matrix().set(1, 1, Y);
   result.matrix().set(1, 2, B);
   result.matrix().set(2, 2, C);
   result.matrix().set(2, 3, D);
   result.matrix().set(3, 2, -1);
   result.matrix().set(3, 3, 0);
 
   return result;
 }
 
-std::unique_ptr<blink::WebMouseEvent> MakeMouseEvent(
-    blink::WebInputEvent::Type type,
-    double timestamp,
-    const gfx::Point& location,
-    bool down) {
-  blink::WebInputEvent::Modifiers modifiers =
-      down ? blink::WebInputEvent::kLeftButtonDown
-           : blink::WebInputEvent::kNoModifiers;
-  std::unique_ptr<blink::WebMouseEvent> mouse_event(
-      new blink::WebMouseEvent(type, modifiers, timestamp));
-  mouse_event->pointer_type = blink::WebPointerProperties::PointerType::kMouse;
-  mouse_event->button = blink::WebPointerProperties::Button::kLeft;
-  mouse_event->SetPositionInWidget(location.x(), location.y());
-  mouse_event->click_count = 1;
-
-  return mouse_event;
-}
-
 void TransformToGvrMat(const gfx::Transform& in, gvr::Mat4f* out) {
   for (int i = 0; i < 4; ++i) {
     for (int j = 0; j < 4; ++j) {
       out->m[i][j] = in.matrix().get(i, j);
     }
   }
 }
 
 void GvrMatToTransform(const gvr::Mat4f& in, gfx::Transform* out) {
   for (int i = 0; i < 4; ++i) {
@@ skipping 433 matching lines @@
 
 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_ ||
       controller_->ButtonUpHappened(gvr::kControllerButtonClick)) {
     touch_pending_ = false;
-    std::unique_ptr<blink::WebGestureEvent> gesture(new blink::WebGestureEvent(
+    auto gesture = base::MakeUnique<blink::WebGestureEvent>(
         blink::WebInputEvent::kGestureTapDown,
-        blink::WebInputEvent::kNoModifiers, NowSeconds()));
+        blink::WebInputEvent::kNoModifiers, NowSeconds());
     gesture->source_device = blink::kWebGestureDeviceTouchpad;
     gesture->x = 0;
     gesture->y = 0;
     SendGestureToContent(std::move(gesture));
     DVLOG(1) << __FUNCTION__ << ": sent CLICK gesture";
   }
 }
 
 void VrShellGl::SendFlingCancel(GestureList& gesture_list) {
   if (!fling_target_)
@@ skipping 62 matching lines @@
   // Scrolling currently only supported on content window.
   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(), in_click_));
+    SendGestureToContent(
+        MakeMouseEvent(blink::WebInputEvent::kMouseLeave, gfx::Point()));
   } 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,
-                                        in_click_));
+    SendGestureToContent(
+        MakeMouseEvent(blink::WebInputEvent::kMouseEnter, local_point_pixels));
   } 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) {
     // TODO(mthiesse, vollick): Content is currently way too sensitive to mouse
     // moves for how noisy the controller is. It's almost impossible to click a
     // link without unintentionally starting a drag event. For this reason we
     // disable mouse moves, only delivering a down and up event.
     if (in_click_)
       return;
-    SendGestureToContent(MakeMouseEvent(blink::WebInputEvent::kMouseMove,
-                                        NowSeconds(), local_point_pixels,
-                                        in_click_));
+    SendGestureToContent(
+        MakeMouseEvent(blink::WebInputEvent::kMouseMove, local_point_pixels));
   } else {
     hover_target_->OnMove(target_point);
   }
 }
 
 void VrShellGl::SendButtonDown(UiElement* target,
                                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;
   if (!target)
     return;
   if (target->fill() == Fill::CONTENT) {
-    SendGestureToContent(MakeMouseEvent(blink::WebInputEvent::kMouseDown,
-                                        NowSeconds(), local_point_pixels,
-                                        in_click_));
+    SendGestureToContent(
+        MakeMouseEvent(blink::WebInputEvent::kMouseDown, local_point_pixels));
   } else {
     target->OnButtonDown(target_point);
   }
 }
 
 bool VrShellGl::SendButtonUp(UiElement* target,
                              const gfx::PointF& target_point,
                              const gfx::Point& local_point_pixels) {
   if (!in_click_)
     return false;
   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;
   if (target->fill() == Fill::CONTENT) {
-    SendGestureToContent(MakeMouseEvent(blink::WebInputEvent::kMouseUp,
-                                        NowSeconds(), local_point_pixels,
-                                        in_click_));
+    SendGestureToContent(
+        MakeMouseEvent(blink::WebInputEvent::kMouseUp, local_point_pixels));
   } 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 (!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();
     SendGestureToContent(std::move(gesture));
   } else {
     target->OnButtonDown(target_point);
     target->OnButtonUp(target_point);
   }
 }
 
+std::unique_ptr<blink::WebMouseEvent> VrShellGl::MakeMouseEvent(
+    blink::WebInputEvent::Type type,
+    const gfx::Point& location) {
+  blink::WebInputEvent::Modifiers modifiers =
+      in_click_ ? blink::WebInputEvent::kLeftButtonDown
+                : blink::WebInputEvent::kNoModifiers;
+  base::TimeTicks timestamp;
+  switch (type) {
+    case blink::WebInputEvent::kMouseUp:
+    case blink::WebInputEvent::kMouseDown:
+      timestamp = controller_->GetLastButtonTimestamp();
+      break;
+    case blink::WebInputEvent::kMouseMove:
+    case blink::WebInputEvent::kMouseEnter:
+    case blink::WebInputEvent::kMouseLeave:
+      timestamp = controller_->GetLastOrientationTimestamp();
+      break;
+    default:
+      NOTREACHED();
+  }
+
+  auto mouse_event = base::MakeUnique<blink::WebMouseEvent>(
+      type, modifiers, (timestamp - base::TimeTicks()).InSecondsF());
+  mouse_event->pointer_type = blink::WebPointerProperties::PointerType::kMouse;
+  mouse_event->button = blink::WebPointerProperties::Button::kLeft;
+  mouse_event->SetPositionInWidget(location.x(), location.y());
+  // TODO(mthiesse): Should we support double-clicks for input? What should the
+  // timeout be?
+  mouse_event->click_count = 1;
+
+  return mouse_event;
+}
+
 void VrShellGl::SendImmediateExitRequestIfNecessary() {
   gvr::ControllerButton buttons[] = {
       gvr::kControllerButtonClick, gvr::kControllerButtonApp,
       gvr::kControllerButtonHome,
   };
   for (size_t i = 0; i < arraysize(buttons); ++i) {
     if (controller_->ButtonUpHappened(buttons[i]) ||
         controller_->ButtonDownHappened(buttons[i])) {
       browser_->ForceExitVr();
     }
@@ skipping 767 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