Collapse the API surface on WebInputEvent via accessor functions.

ui/events/blink/input_handler_proxy.cc

 // Copyright 2013 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 "ui/events/blink/input_handler_proxy.h"
 
 #include <stddef.h>
 
 #include <algorithm>
 
@@ skipping 65 matching lines @@
 
 double InSecondsF(const base::TimeTicks& time) {
   return (time - base::TimeTicks()).InSecondsF();
 }
 
 bool ShouldSuppressScrollForFlingBoosting(
     const gfx::Vector2dF& current_fling_velocity,
     const WebGestureEvent& scroll_update_event,
     double time_since_last_boost_event,
     double time_since_last_fling_animate) {
-  DCHECK_EQ(WebInputEvent::GestureScrollUpdate, scroll_update_event.type);
+  DCHECK_EQ(WebInputEvent::GestureScrollUpdate, scroll_update_event.type());
 
   gfx::Vector2dF dx(scroll_update_event.data.scrollUpdate.deltaX,
                     scroll_update_event.data.scrollUpdate.deltaY);
   if (gfx::DotProduct(current_fling_velocity, dx) <= 0)
     return false;
 
   if (time_since_last_fling_animate > kFlingBoostTimeoutDelaySeconds)
     return false;
 
   if (time_since_last_boost_event < 0.001)
     return true;
 
   // TODO(jdduke): Use |scroll_update_event.data.scrollUpdate.velocity{X,Y}|.
   // The scroll must be of sufficient velocity to maintain the active fling.
   const gfx::Vector2dF scroll_velocity =
       gfx::ScaleVector2d(dx, 1. / time_since_last_boost_event);
   if (scroll_velocity.LengthSquared() < kMinBoostTouchScrollSpeedSquare)
     return false;
 
   return true;
 }
 
 bool ShouldBoostFling(const gfx::Vector2dF& current_fling_velocity,
                       const WebGestureEvent& fling_start_event) {
-  DCHECK_EQ(WebInputEvent::GestureFlingStart, fling_start_event.type);
+  DCHECK_EQ(WebInputEvent::GestureFlingStart, fling_start_event.type());
 
   gfx::Vector2dF new_fling_velocity(
       fling_start_event.data.flingStart.velocityX,
       fling_start_event.data.flingStart.velocityY);
 
   if (gfx::DotProduct(current_fling_velocity, new_fling_velocity) <= 0)
     return false;
 
   if (current_fling_velocity.LengthSquared() < kMinBoostFlingSpeedSquare)
     return false;
 
   if (new_fling_velocity.LengthSquared() < kMinBoostFlingSpeedSquare)
     return false;
 
   return true;
 }
 
 WebGestureEvent ObtainGestureScrollBegin(const WebGestureEvent& event) {
   WebGestureEvent scroll_begin_event = event;
   scroll_begin_event.setType(WebInputEvent::GestureScrollBegin);
   scroll_begin_event.data.scrollBegin.deltaXHint = 0;
   scroll_begin_event.data.scrollBegin.deltaYHint = 0;
   return scroll_begin_event;
 }
 
 cc::ScrollState CreateScrollStateForGesture(const WebGestureEvent& event) {
   cc::ScrollStateData scroll_state_data;
-  switch (event.type) {
+  switch (event.type()) {
     case WebInputEvent::GestureScrollBegin:
       scroll_state_data.position_x = event.x;
       scroll_state_data.position_y = event.y;
       scroll_state_data.is_beginning = true;
       // On Mac, a GestureScrollBegin in the inertial phase indicates a fling
       // start.
       scroll_state_data.is_in_inertial_phase =
           (event.data.scrollBegin.inertialPhase ==
            WebGestureEvent::MomentumPhase);
       break;
@@ skipping 17 matching lines @@
       break;
     default:
       NOTREACHED();
       break;
   }
   return cc::ScrollState(scroll_state_data);
 }
 
 void ReportInputEventLatencyUma(const WebInputEvent& event,
                                 const ui::LatencyInfo& latency_info) {
-  if (!(event.type == WebInputEvent::GestureScrollBegin ||
-        event.type == WebInputEvent::GestureScrollUpdate ||
-        event.type == WebInputEvent::GesturePinchBegin ||
-        event.type == WebInputEvent::GesturePinchUpdate ||
-        event.type == WebInputEvent::GestureFlingStart)) {
+  if (!(event.type() == WebInputEvent::GestureScrollBegin ||
+        event.type() == WebInputEvent::GestureScrollUpdate ||
+        event.type() == WebInputEvent::GesturePinchBegin ||
+        event.type() == WebInputEvent::GesturePinchUpdate ||
+        event.type() == WebInputEvent::GestureFlingStart)) {
     return;
   }
 
   ui::LatencyInfo::LatencyMap::const_iterator it =
       latency_info.latency_components().find(std::make_pair(
           ui::INPUT_EVENT_LATENCY_ORIGINAL_COMPONENT, 0));
 
   if (it == latency_info.latency_components().end())
     return;
 
   base::TimeDelta delta = base::TimeTicks::Now() - it->second.event_time;
   for (size_t i = 0; i < it->second.event_count; ++i) {
-    switch (event.type) {
+    switch (event.type()) {
       case blink::WebInputEvent::GestureScrollBegin:
         UMA_HISTOGRAM_CUSTOM_COUNTS(
             "Event.Latency.RendererImpl.GestureScrollBegin",
             delta.InMicroseconds(), 1, 1000000, 100);
         break;
       case blink::WebInputEvent::GestureScrollUpdate:
         UMA_HISTOGRAM_CUSTOM_COUNTS(
             // So named for historical reasons.
             "Event.Latency.RendererImpl.GestureScroll2",
             delta.InMicroseconds(), 1, 1000000, 100);
@@ skipping 90 matching lines @@
                          TRACE_EVENT_FLAG_FLOW_IN | TRACE_EVENT_FLAG_FLOW_OUT,
                          "step", "HandleInputEventImpl");
 
   std::unique_ptr<EventWithCallback> event_with_callback =
       base::MakeUnique<EventWithCallback>(std::move(event), latency_info,
                                           tick_clock_->NowTicks(), callback);
 
   // Note: Other input can race ahead of gesture input as they don't have to go
   // through the queue, but we believe it's OK to do so.
   if (!compositor_event_queue_ ||
-      !IsGestureScollOrPinch(event_with_callback->event().type)) {
+      !IsGestureScollOrPinch(event_with_callback->event().type())) {
     DispatchSingleInputEvent(std::move(event_with_callback),
                              tick_clock_->NowTicks());
     return;
   }
 
   if (has_ongoing_compositor_scroll_pinch_) {
     bool needs_animate_input = compositor_event_queue_->empty();
     compositor_event_queue_->Queue(std::move(event_with_callback),
                                    tick_clock_->NowTicks());
     if (needs_animate_input)
       input_handler_->SetNeedsAnimateInput();
     return;
   }
 
   // We have to dispatch the event to know whether the gesture sequence will be
   // handled by the compositor or not.
   DispatchSingleInputEvent(std::move(event_with_callback),
                            tick_clock_->NowTicks());
 }
 
 void InputHandlerProxy::DispatchSingleInputEvent(
     std::unique_ptr<EventWithCallback> event_with_callback,
     const base::TimeTicks now) {
   if (compositor_event_queue_ &&
-      IsGestureScollOrPinch(event_with_callback->event().type)) {
+      IsGestureScollOrPinch(event_with_callback->event().type())) {
     // Report the coalesced count only for continuous events to avoid the noise
     // from non-continuous events.
-    if (IsContinuousGestureEvent(event_with_callback->event().type)) {
+    if (IsContinuousGestureEvent(event_with_callback->event().type())) {
       UMA_HISTOGRAM_CUSTOM_COUNTS(
           "Event.CompositorThreadEventQueue.Continuous.HeadQueueingTime",
           (now - event_with_callback->creation_timestamp()).InMicroseconds(), 1,
           kTenSeconds, 50);
 
       UMA_HISTOGRAM_CUSTOM_COUNTS(
           "Event.CompositorThreadEventQueue.Continuous.TailQueueingTime",
           (now - event_with_callback->last_coalesced_timestamp())
               .InMicroseconds(),
           1, kTenSeconds, 50);
@@ skipping 11 matching lines @@
 
   ui::LatencyInfo monitored_latency_info = event_with_callback->latency_info();
   std::unique_ptr<cc::SwapPromiseMonitor> latency_info_swap_promise_monitor =
       input_handler_->CreateLatencyInfoSwapPromiseMonitor(
           &monitored_latency_info);
 
   current_overscroll_params_.reset();
   InputHandlerProxy::EventDisposition disposition =
       HandleInputEvent(event_with_callback->event());
 
-  switch (event_with_callback->event().type) {
+  switch (event_with_callback->event().type()) {
     case blink::WebGestureEvent::GestureScrollBegin:
     case blink::WebGestureEvent::GesturePinchBegin:
     case blink::WebGestureEvent::GestureScrollUpdate:
     case blink::WebGestureEvent::GesturePinchUpdate:
       has_ongoing_compositor_scroll_pinch_ = disposition == DID_HANDLE;
       break;
 
     case blink::WebGestureEvent::GestureScrollEnd:
     case blink::WebGestureEvent::GesturePinchEnd:
       has_ongoing_compositor_scroll_pinch_ = false;
@@ skipping 17 matching lines @@
     DispatchSingleInputEvent(compositor_event_queue_->Pop(), now);
 }
 
 InputHandlerProxy::EventDisposition InputHandlerProxy::HandleInputEvent(
     const WebInputEvent& event) {
   DCHECK(input_handler_);
 
   if (FilterInputEventForFlingBoosting(event))
     return DID_HANDLE;
 
-  switch (event.type) {
+  switch (event.type()) {
     case WebInputEvent::MouseWheel:
       return HandleMouseWheel(static_cast<const WebMouseWheelEvent&>(event));
 
     case WebInputEvent::GestureScrollBegin:
       return HandleGestureScrollBegin(
           static_cast<const WebGestureEvent&>(event));
 
     case WebInputEvent::GestureScrollUpdate:
       return HandleGestureScrollUpdate(
           static_cast<const WebGestureEvent&>(event));
@@ skipping 92 matching lines @@
       input_handler_->MouseMoveAt(gfx::Point(mouse_event.x, mouse_event.y));
       return DID_NOT_HANDLE;
     }
     case WebInputEvent::MouseLeave: {
       CHECK(input_handler_);
       input_handler_->MouseLeave();
       return DID_NOT_HANDLE;
     }
 
     default:
-      if (WebInputEvent::isKeyboardEventType(event.type)) {
+      if (WebInputEvent::isKeyboardEventType(event.type())) {
         // Only call |CancelCurrentFling()| if a fling was active, as it will
         // otherwise disrupt an in-progress touch scroll.
         if (fling_curve_)
           CancelCurrentFling();
       }
       break;
   }
 
   return DID_NOT_HANDLE;
 }
@@ skipping 261 matching lines @@
   cc::ScrollState scroll_state = CreateScrollStateForGesture(gesture_event);
   gfx::Point scroll_point(gesture_event.x, gesture_event.y);
   gfx::Vector2dF scroll_delta(-gesture_event.data.scrollUpdate.deltaX,
                               -gesture_event.data.scrollUpdate.deltaY);
 
   if (ShouldAnimate(gesture_event.data.scrollUpdate.deltaUnits !=
                     blink::WebGestureEvent::ScrollUnits::Pixels)) {
     DCHECK(!scroll_state.is_in_inertial_phase());
     base::TimeTicks event_time =
         base::TimeTicks() +
-        base::TimeDelta::FromSecondsD(gesture_event.timeStampSeconds);
+        base::TimeDelta::FromSecondsD(gesture_event.timeStampSeconds());
     base::TimeDelta delay = base::TimeTicks::Now() - event_time;
     switch (input_handler_->ScrollAnimated(scroll_point, scroll_delta, delay)
                 .thread) {
       case cc::InputHandler::SCROLL_ON_IMPL_THREAD:
         return DID_HANDLE;
       case cc::InputHandler::SCROLL_IGNORED:
         return DROP_EVENT;
       default:
         return DID_NOT_HANDLE;
     }
@@ skipping 84 matching lines @@
           WebFloatPoint(vx, vy),
           blink::WebSize()));
       disallow_horizontal_fling_scroll_ = !vx;
       disallow_vertical_fling_scroll_ = !vy;
       TRACE_EVENT_ASYNC_BEGIN2("input,benchmark,rail",
                                "InputHandlerProxy::HandleGestureFling::started",
                                this, "vx", vx, "vy", vy);
       // Note that the timestamp will only be used to kickstart the animation if
       // its sufficiently close to the timestamp of the first call |Animate()|.
       has_fling_animation_started_ = false;
-      fling_parameters_.startTime = gesture_event.timeStampSeconds;
+      fling_parameters_.startTime = gesture_event.timeStampSeconds();
       fling_parameters_.delta = WebFloatPoint(vx, vy);
       fling_parameters_.point = WebPoint(gesture_event.x, gesture_event.y);
       fling_parameters_.globalPoint =
           WebPoint(gesture_event.globalX, gesture_event.globalY);
-      fling_parameters_.modifiers = gesture_event.modifiers;
+      fling_parameters_.modifiers = gesture_event.modifiers();
       fling_parameters_.sourceDevice = gesture_event.sourceDevice;
       RequestAnimation();
       return DID_HANDLE;
     }
     case cc::InputHandler::SCROLL_UNKNOWN:
     case cc::InputHandler::SCROLL_ON_MAIN_THREAD: {
       TRACE_EVENT_INSTANT0("input,rail",
                            "InputHandlerProxy::HandleGestureFling::"
                            "scroll_on_main_thread",
                            TRACE_EVENT_SCOPE_THREAD);
@@ skipping 102 matching lines @@
 
 InputHandlerProxy::EventDisposition InputHandlerProxy::HandleTouchEnd(
     const blink::WebTouchEvent& touch_event) {
   if (touch_event.touchesLength == 1)
     touch_start_result_ = kEventDispositionUndefined;
   return DID_NOT_HANDLE;
 }
 
 bool InputHandlerProxy::FilterInputEventForFlingBoosting(
     const WebInputEvent& event) {
-  if (!WebInputEvent::isGestureEventType(event.type))
+  if (!WebInputEvent::isGestureEventType(event.type()))
     return false;
 
   if (!fling_curve_) {
     DCHECK(!deferred_fling_cancel_time_seconds_);
     return false;
   }
 
   const WebGestureEvent& gesture_event =
       static_cast<const WebGestureEvent&>(event);
-  if (gesture_event.type == WebInputEvent::GestureFlingCancel) {
+  if (gesture_event.type() == WebInputEvent::GestureFlingCancel) {
     if (gesture_event.data.flingCancel.preventBoosting)
       return false;
 
     if (current_fling_velocity_.LengthSquared() < kMinBoostFlingSpeedSquare)
       return false;
 
     TRACE_EVENT_INSTANT0("input",
                          "InputHandlerProxy::FlingBoostStart",
                          TRACE_EVENT_SCOPE_THREAD);
     deferred_fling_cancel_time_seconds_ =
-        event.timeStampSeconds + kFlingBoostTimeoutDelaySeconds;
+        event.timeStampSeconds() + kFlingBoostTimeoutDelaySeconds;
     return true;
   }
 
   // A fling is either inactive or is "free spinning", i.e., has yet to be
   // interrupted by a touch gesture, in which case there is nothing to filter.
   if (!deferred_fling_cancel_time_seconds_)
     return false;
 
   // Gestures from a different source should immediately interrupt the fling.
   if (gesture_event.sourceDevice != fling_parameters_.sourceDevice) {
     CancelCurrentFling();
     return false;
   }
 
-  switch (gesture_event.type) {
+  switch (gesture_event.type()) {
     case WebInputEvent::GestureTapCancel:
     case WebInputEvent::GestureTapDown:
       return false;
 
     case WebInputEvent::GestureScrollBegin:
       if (!input_handler_->IsCurrentlyScrollingLayerAt(
               gfx::Point(gesture_event.x, gesture_event.y),
               fling_parameters_.sourceDevice == blink::WebGestureDeviceTouchpad
                   ? cc::InputHandler::NON_BUBBLING_GESTURE
                   : cc::InputHandler::TOUCHSCREEN)) {
         CancelCurrentFling();
         return false;
       }
 
       // TODO(jdduke): Use |gesture_event.data.scrollBegin.delta{X,Y}Hint| to
       // determine if the ScrollBegin should immediately cancel the fling.
       ExtendBoostedFlingTimeout(gesture_event);
       return true;
 
     case WebInputEvent::GestureScrollUpdate: {
       const double time_since_last_boost_event =
-          event.timeStampSeconds - last_fling_boost_event_.timeStampSeconds;
+          event.timeStampSeconds() - last_fling_boost_event_.timeStampSeconds();
       const double time_since_last_fling_animate = std::max(
-          0.0, event.timeStampSeconds - InSecondsF(last_fling_animate_time_));
+          0.0, event.timeStampSeconds() - InSecondsF(last_fling_animate_time_));
       if (ShouldSuppressScrollForFlingBoosting(current_fling_velocity_,
                                                gesture_event,
                                                time_since_last_boost_event,
                                                time_since_last_fling_animate)) {
         ExtendBoostedFlingTimeout(gesture_event);
         return true;
       }
 
       CancelCurrentFling();
       return false;
     }
 
     case WebInputEvent::GestureScrollEnd:
       // Clear the last fling boost event *prior* to fling cancellation,
       // preventing insertion of a synthetic GestureScrollBegin.
       last_fling_boost_event_ = WebGestureEvent();
       CancelCurrentFling();
       return true;
 
     case WebInputEvent::GestureFlingStart: {
       DCHECK_EQ(fling_parameters_.sourceDevice, gesture_event.sourceDevice);
 
       bool fling_boosted =
-          fling_parameters_.modifiers == gesture_event.modifiers &&
+          fling_parameters_.modifiers == gesture_event.modifiers() &&
           ShouldBoostFling(current_fling_velocity_, gesture_event);
 
       gfx::Vector2dF new_fling_velocity(
           gesture_event.data.flingStart.velocityX,
           gesture_event.data.flingStart.velocityY);
       DCHECK(!new_fling_velocity.IsZero());
 
       if (fling_boosted)
         current_fling_velocity_ += new_fling_velocity;
       else
         current_fling_velocity_ = new_fling_velocity;
 
       WebFloatPoint velocity(current_fling_velocity_.x(),
                              current_fling_velocity_.y());
       deferred_fling_cancel_time_seconds_ = 0;
       disallow_horizontal_fling_scroll_ = !velocity.x;
       disallow_vertical_fling_scroll_ = !velocity.y;
       last_fling_boost_event_ = WebGestureEvent();
       fling_curve_.reset(client_->CreateFlingAnimationCurve(
           gesture_event.sourceDevice,
           velocity,
           blink::WebSize()));
-      fling_parameters_.startTime = gesture_event.timeStampSeconds;
+      fling_parameters_.startTime = gesture_event.timeStampSeconds();
       fling_parameters_.delta = velocity;
       fling_parameters_.point = WebPoint(gesture_event.x, gesture_event.y);
       fling_parameters_.globalPoint =
           WebPoint(gesture_event.globalX, gesture_event.globalY);
 
       TRACE_EVENT_INSTANT2("input",
                            fling_boosted ? "InputHandlerProxy::FlingBoosted"
                                          : "InputHandlerProxy::FlingReplaced",
                            TRACE_EVENT_SCOPE_THREAD,
                            "vx",
@@ skipping 14 matching lines @@
       return false;
   }
 }
 
 void InputHandlerProxy::ExtendBoostedFlingTimeout(
     const blink::WebGestureEvent& event) {
   TRACE_EVENT_INSTANT0("input",
                        "InputHandlerProxy::ExtendBoostedFlingTimeout",
                        TRACE_EVENT_SCOPE_THREAD);
   deferred_fling_cancel_time_seconds_ =
-      event.timeStampSeconds + kFlingBoostTimeoutDelaySeconds;
+      event.timeStampSeconds() + kFlingBoostTimeoutDelaySeconds;
   last_fling_boost_event_ = event;
 }
 
 void InputHandlerProxy::Animate(base::TimeTicks time) {
   // If using synchronous animate, then only expect Animate attempts started by
   // the synchronous system. Don't let the InputHandler try to Animate also.
   DCHECK(!input_handler_->IsCurrentlyScrollingViewport() ||
          allow_root_animate_);
 
   if (scroll_elasticity_controller_)
@@ skipping 182 matching lines @@
   has_fling_animation_started_ = false;
   gesture_scroll_on_impl_thread_ = false;
   current_fling_velocity_ = gfx::Vector2dF();
   fling_parameters_ = blink::WebActiveWheelFlingParameters();
 
   if (deferred_fling_cancel_time_seconds_) {
     deferred_fling_cancel_time_seconds_ = 0;
 
     WebGestureEvent last_fling_boost_event = last_fling_boost_event_;
     last_fling_boost_event_ = WebGestureEvent();
-    if (last_fling_boost_event.type == WebInputEvent::GestureScrollBegin ||
-        last_fling_boost_event.type == WebInputEvent::GestureScrollUpdate) {
+    if (last_fling_boost_event.type() == WebInputEvent::GestureScrollBegin ||
+        last_fling_boost_event.type() == WebInputEvent::GestureScrollUpdate) {
       // Synthesize a GestureScrollBegin, as the original was suppressed.
       HandleInputEvent(ObtainGestureScrollBegin(last_fling_boost_event));
     }
   }
 
   return had_fling_animation;
 }
 
 void InputHandlerProxy::RequestAnimation() {
   // When a SynchronousInputHandler is present, root flings should go through
@@ skipping 152 matching lines @@
                  scroll_elasticity_controller_->GetWeakPtr(), gesture_event,
                  scroll_result));
 }
 
 void InputHandlerProxy::SetTickClockForTesting(
     std::unique_ptr<base::TickClock> tick_clock) {
   tick_clock_ = std::move(tick_clock);
 }
 
 }  // namespace ui