Collapse the API surface on WebInputEvent via accessor functions.

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 <cmath>
 
 #include "base/logging.h"
 #include "base/time/time.h"
@@ skipping 178 matching lines @@
   std::vector<std::unique_ptr<WebGestureEvent>> gesture_list;
   std::unique_ptr<WebGestureEvent> gesture(new WebGestureEvent());
 
   if (controller_state_->GetConnectionState() != gvr::kControllerConnected) {
     gesture_list.push_back(std::move(gesture));
     return gesture_list;
   }
   UpdateTouchInfo();
   UpdateGestureFromTouchInfo(gesture.get());
 
-  if (gesture->type == WebInputEvent::Undefined &&
+  if (gesture->type() == WebInputEvent::Undefined &&
       ButtonUpHappened(gvr::kControllerButtonClick)) {
-    gesture->type = WebInputEvent::GestureTapDown;
+    gesture->setType(WebInputEvent::GestureTapDown);
     gesture->x = 0;
     gesture->y = 0;
   }
   gesture->sourceDevice = blink::WebGestureDeviceTouchpad;
   gesture_list.push_back(std::move(gesture));
 
-  if (gesture_list.back()->type == WebInputEvent::GestureScrollEnd) {
+  if (gesture_list.back()->type() == WebInputEvent::GestureScrollEnd) {
     if (!ButtonDownHappened(gvr::kControllerButtonClick)) {
-      std::unique_ptr<WebGestureEvent> fling(new WebGestureEvent());
-      fling->timeStampSeconds = gesture_list.back()->timeStampSeconds;
+      std::unique_ptr<WebGestureEvent> fling(new WebGestureEvent(
+          WebInputEvent::GestureFlingStart, WebInputEvent::NoModifiers,
+          gesture_list.back()->timeStampSeconds()));
       fling->sourceDevice = blink::WebGestureDeviceTouchpad;
-      fling->type = WebInputEvent::GestureFlingStart;
       if (IsHorizontalGesture()) {
         fling->data.flingStart.velocityX =
             overall_velocity_.x * kDisplacementScaleFactor;
       } else {
         fling->data.flingStart.velocityY =
             overall_velocity_.y * kDisplacementScaleFactor;
       }
       gesture_list.push_back(std::move(fling));
     }
     Reset();
   }
 
   return gesture_list;
 }
 
 void VrController::UpdateGestureFromTouchInfo(WebGestureEvent* gesture) {
-  gesture->timeStampSeconds =
-      (base::TimeTicks::Now() - base::TimeTicks()).InSecondsF();
+  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:
       LOG(ERROR) << "Wrong gesture detector state: " << state_;
       break;
   }
 }
 
 void VrController::HandleWaitingState(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->type = WebInputEvent::GestureFlingCancel;
+    gesture->setType(WebInputEvent::GestureFlingCancel);
     gesture->data.flingCancel.preventBoosting = false;
   }
 }
 
 void VrController::HandleDetectingState(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 (UpdateCurrentTouchpoint() && touch_info_->is_touching &&
       !InSlop(touch_info_->touch_point.position) &&
       !ButtonDownHappened(gvr::kControllerButtonClick)) {
     state_ = SCROLLING;
-    gesture->type = WebInputEvent::GestureScrollBegin;
+    gesture->setType(WebInputEvent::GestureScrollBegin);
     UpdateGesture(gesture);
     gesture->data.scrollBegin.deltaXHint =
         displacement_.x * kDisplacementScaleFactor;
     gesture->data.scrollBegin.deltaYHint =
         displacement_.y * kDisplacementScaleFactor;
   }
 }
 
 void VrController::HandleScrollingState(WebGestureEvent* gesture) {
   // Update current touch point.
   bool touch_position_changed = UpdateCurrentTouchpoint();
   if (touch_info_->touch_up || !(touch_info_->is_touching) ||
       ButtonDownHappened(gvr::kControllerButtonClick)) {
     // Gesture ends.
-    gesture->type = WebInputEvent::GestureScrollEnd;
+    gesture->setType(WebInputEvent::GestureScrollEnd);
     UpdateGesture(gesture);
   } else if (touch_position_changed) {
     // User continues scrolling and there is a change in touch position.
-    gesture->type = WebInputEvent::GestureScrollUpdate;
+    gesture->setType(WebInputEvent::GestureScrollUpdate);
     UpdateGesture(gesture);
     if (IsHorizontalGesture()) {
       gesture->data.scrollUpdate.deltaX =
           displacement_.x * kDisplacementScaleFactor;
     } else {
       gesture->data.scrollUpdate.deltaY =
           displacement_.y * kDisplacementScaleFactor;
     }
   }
 }
@@ skipping 57 matching lines @@
   gvr::Vec2f velocity = Vector::ScalarMult(displacement, 1 / duration);
 
   float weight = duration / (kRC + duration);
 
   overall_velocity_ =
       Vector::Add(Vector::ScalarMult(overall_velocity_, 1 - weight),
                   Vector::ScalarMult(velocity, weight));
 }
 
 }  // namespace vr_shell