Refactor VR Shell Input. Locks input to click/scroll targets.

chrome/browser/android/vr_shell/vr_controller.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_controller.h"
 
 #include <algorithm>
 #include <cmath>
 #include <utility>
 
 #include "base/logging.h"
 #include "base/memory/ptr_util.h"
 #include "base/time/time.h"
 #include "chrome/browser/android/vr_shell/elbow_model.h"
 #include "device/vr/vr_math.h"
+#include "third_party/WebKit/public/platform/WebGestureEvent.h"
+#include "third_party/WebKit/public/platform/WebInputEvent.h"
 #include "third_party/gvr-android-sdk/src/libraries/headers/vr/gvr/capi/include/gvr.h"
 #include "third_party/gvr-android-sdk/src/libraries/headers/vr/gvr/capi/include/gvr_controller.h"
 
 namespace vr_shell {
 
 namespace {
 
 constexpr float kDisplacementScaleFactor = 300.0f;
 
 // A slop represents a small rectangular region around the first touch point of
@@ skipping 211 matching lines @@
     if (extrapolated_touch_ == kMaxNumOfExtrapolations) {
       overall_velocity_ = {0, 0};
     }
     extrapolated_touch_ = 0;
   }
   last_touch_timestamp_ = controller_state_->GetLastTouchTimestamp();
   last_timestamp_nanos_ =
       gvr::GvrApi::GetTimePointNow().monotonic_system_time_nanos;
 }
 
-std::vector<std::unique_ptr<WebGestureEvent>> VrController::DetectGestures() {
-  std::vector<std::unique_ptr<WebGestureEvent>> gesture_list;
-  std::unique_ptr<WebGestureEvent> gesture(new WebGestureEvent());
+std::unique_ptr<GestureList> VrController::DetectGestures() {
+  std::unique_ptr<GestureList> gesture_list = base::MakeUnique<GestureList>();
+  std::unique_ptr<blink::WebGestureEvent> gesture(new blink::WebGestureEvent());
 
   if (controller_state_->GetConnectionState() != gvr::kControllerConnected) {
-    gesture_list.push_back(std::move(gesture));
+    gesture_list->push_back(std::move(gesture));
     return gesture_list;
   }
 
   touch_position_changed_ = UpdateCurrentTouchpoint();
   UpdateTouchInfo();
   if (touch_position_changed_)
     UpdateOverallVelocity();
 
   UpdateGestureFromTouchInfo(gesture.get());
+  gesture->source_device = blink::kWebGestureDeviceTouchpad;
+  gesture_list->push_back(std::move(gesture));
 
-  if (gesture->GetType() == WebInputEvent::kUndefined &&
-      ButtonUpHappened(gvr::kControllerButtonClick)) {
-    gesture->SetType(WebInputEvent::kGestureTapDown);
-    gesture->x = 0;
-    gesture->y = 0;
-  }
-  gesture->source_device = blink::kWebGestureDeviceTouchpad;
-  gesture_list.push_back(std::move(gesture));
-
-  if (gesture_list.back()->GetType() == WebInputEvent::kGestureScrollEnd) {
+  if (gesture_list->back()->GetType() ==
+      blink::WebInputEvent::kGestureScrollEnd) {
     if (!ButtonDownHappened(gvr::kControllerButtonClick) &&
         (last_velocity_.x() != 0.0 || last_velocity_.y() != 0.0)) {
-      std::unique_ptr<WebGestureEvent> fling(new WebGestureEvent(
-          WebInputEvent::kGestureFlingStart, WebInputEvent::kNoModifiers,
-          gesture_list.back()->TimeStampSeconds()));
+      std::unique_ptr<blink::WebGestureEvent> fling(
+          new blink::WebGestureEvent(blink::WebInputEvent::kGestureFlingStart,
+                                     blink::WebInputEvent::kNoModifiers,
+                                     gesture_list->back()->TimeStampSeconds()));
       fling->source_device = blink::kWebGestureDeviceTouchpad;
       if (IsHorizontalGesture()) {
         fling->data.fling_start.velocity_x =
             last_velocity_.x() * kDisplacementScaleFactor;
       } else {
         fling->data.fling_start.velocity_y =
             last_velocity_.y() * kDisplacementScaleFactor;
       }
-      gesture_list.push_back(std::move(fling));
+      gesture_list->push_back(std::move(fling));
     }
     Reset();
   }
 
   return gesture_list;
 }
 
-void VrController::UpdateGestureFromTouchInfo(WebGestureEvent* gesture) {
+void VrController::UpdateGestureFromTouchInfo(blink::WebGestureEvent* gesture) {
   gesture->SetTimeStampSeconds(
       (base::TimeTicks::Now() - base::TimeTicks()).InSecondsF());
   switch (state_) {
     // User has not put finger on touch pad.
     case WAITING:
       HandleWaitingState(gesture);
       break;
     // User has not started a gesture (by moving out of slop).
     case TOUCHING:
       HandleDetectingState(gesture);
       break;
     // User is scrolling on touchpad
     case SCROLLING:
       HandleScrollingState(gesture);
       break;
     default:
       NOTREACHED();
       break;
   }
 }
 
-void VrController::HandleWaitingState(WebGestureEvent* gesture) {
+void VrController::HandleWaitingState(blink::WebGestureEvent* gesture) {
   // User puts finger on touch pad (or when the touch down for current gesture
   // is missed, initiate gesture from current touch point).
   if (touch_info_->touch_down || touch_info_->is_touching) {
     // update initial touchpoint
     *init_touch_point_ = touch_info_->touch_point;
     // update current touchpoint
     *cur_touch_point_ = touch_info_->touch_point;
     state_ = TOUCHING;
 
-    gesture->SetType(WebInputEvent::kGestureFlingCancel);
+    gesture->SetType(blink::WebInputEvent::kGestureFlingCancel);
     gesture->data.fling_cancel.prevent_boosting = false;
   }
 }
 
-void VrController::HandleDetectingState(WebGestureEvent* gesture) {
+void VrController::HandleDetectingState(blink::WebGestureEvent* gesture) {
   // User lifts up finger from touch pad.
   if (touch_info_->touch_up || !(touch_info_->is_touching)) {
     Reset();
     return;
   }
 
   // Touch position is changed, the touch point moves outside of slop,
   // and the Controller's button is not down.
   if (touch_position_changed_ && touch_info_->is_touching &&
       !InSlop(touch_info_->touch_point.position) &&
-      !ButtonDownHappened(gvr::kControllerButtonClick)) {
+      !ButtonState(gvr::kControllerButtonClick)) {
     state_ = SCROLLING;
-    gesture->SetType(WebInputEvent::kGestureScrollBegin);
+    gesture->SetType(blink::WebInputEvent::kGestureScrollBegin);
     UpdateGestureParameters();
     gesture->data.scroll_begin.delta_x_hint =
         displacement_.x() * kDisplacementScaleFactor;
     gesture->data.scroll_begin.delta_y_hint =
         displacement_.y() * kDisplacementScaleFactor;
     gesture->data.scroll_begin.delta_hint_units =
         blink::WebGestureEvent::ScrollUnits::kPrecisePixels;
   }
 }
 
-void VrController::HandleScrollingState(WebGestureEvent* gesture) {
+void VrController::HandleScrollingState(blink::WebGestureEvent* gesture) {
   if (touch_info_->touch_up || !(touch_info_->is_touching) ||
       ButtonDownHappened(gvr::kControllerButtonClick)) {
     // Gesture ends.
-    gesture->SetType(WebInputEvent::kGestureScrollEnd);
+    gesture->SetType(blink::WebInputEvent::kGestureScrollEnd);
     UpdateGestureParameters();
   } else if (touch_position_changed_) {
     // User continues scrolling and there is a change in touch position.
-    gesture->SetType(WebInputEvent::kGestureScrollUpdate);
+    gesture->SetType(blink::WebInputEvent::kGestureScrollUpdate);
     UpdateGestureParameters();
     if (IsHorizontalGesture()) {
       gesture->data.scroll_update.delta_x =
           displacement_.x() * kDisplacementScaleFactor;
     } else {
       gesture->data.scroll_update.delta_y =
           displacement_.y() * kDisplacementScaleFactor;
     }
     last_velocity_ = overall_velocity_;
   }
@@ skipping 65 matching lines @@
 
   const gfx::Vector2dF& velocity = ScaleVector2d(displacement, (1 / duration));
 
   float weight = duration / (kRC + duration);
 
   overall_velocity_ = ScaleVector2d(overall_velocity_, (1 - weight)) +
                       ScaleVector2d(velocity, weight);
 }
 
 }  // namespace vr_shell