Collapse the API surface on WebInputEvent via accessor functions.

content/browser/renderer_host/input/touch_event_queue.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 "content/browser/renderer_host/input/touch_event_queue.h"
 
 #include <utility>
 
 #include "base/auto_reset.h"
 #include "base/macros.h"
@@ skipping 20 matching lines @@
 // A sanity check on touches received to ensure that touch movement outside
 // the platform slop region will cause scrolling.
 const double kMaxConceivablePlatformSlopRegionLengthDipsSquared = 60. * 60.;
 
 TouchEventWithLatencyInfo ObtainCancelEventForTouchEvent(
     const TouchEventWithLatencyInfo& event_to_cancel) {
   TouchEventWithLatencyInfo event = event_to_cancel;
   WebTouchEventTraits::ResetTypeAndTouchStates(
       WebInputEvent::TouchCancel,
       // TODO(rbyers): Shouldn't we use a fresh timestamp?
-      event.event.timeStampSeconds,
-      &event.event);
+      event.event.timeStampSeconds(), &event.event);
   return event;
 }
 
 bool ShouldTouchTriggerTimeout(const WebTouchEvent& event) {
-  return (event.type == WebInputEvent::TouchStart ||
-          event.type == WebInputEvent::TouchMove) &&
+  return (event.type() == WebInputEvent::TouchStart ||
+          event.type() == WebInputEvent::TouchMove) &&
          event.dispatchType == WebInputEvent::Blocking;
 }
 
 // Compare all properties of touch points to determine the state.
 bool HasPointChanged(const WebTouchPoint& point_1,
     const WebTouchPoint& point_2) {
   DCHECK_EQ(point_1.id, point_2.id);
   if (point_1.screenPosition != point_2.screenPosition ||
       point_1.position != point_2.position ||
       point_1.radiusX != point_2.radiusX ||
@@ skipping 232 matching lines @@
 class TouchEventQueue::TouchMoveSlopSuppressor {
  public:
   TouchMoveSlopSuppressor() : suppressing_touchmoves_(false) {}
 
   bool FilterEvent(const WebTouchEvent& event) {
     if (WebTouchEventTraits::IsTouchSequenceStart(event)) {
       suppressing_touchmoves_ = true;
       touch_start_location_ = gfx::PointF(event.touches[0].position);
     }
 
-    if (event.type == WebInputEvent::TouchEnd ||
-        event.type == WebInputEvent::TouchCancel)
+    if (event.type() == WebInputEvent::TouchEnd ||
+        event.type() == WebInputEvent::TouchCancel)
       suppressing_touchmoves_ = false;
 
-    if (event.type != WebInputEvent::TouchMove)
+    if (event.type() != WebInputEvent::TouchMove)
       return false;
 
     if (suppressing_touchmoves_) {
       if (event.touchesLength > 1) {
         suppressing_touchmoves_ = false;
       } else if (event.movedBeyondSlopRegion) {
         suppressing_touchmoves_ = false;
       } else {
         // No sane slop region should be larger than 60 DIPs.
         DCHECK_LT((gfx::PointF(event.touches[0].position) -
@@ skipping 209 matching lines @@
   // We receive an ack for async touchmove from render.
   if (!ack_pending_async_touchmove_ids_.empty() &&
       ack_pending_async_touchmove_ids_.front() == unique_touch_event_id) {
     // Remove the first touchmove from the ack_pending_async_touchmove queue.
     ack_pending_async_touchmove_ids_.pop_front();
     // Send the next pending async touch move once we receive all acks back.
     if (pending_async_touchmove_ && ack_pending_async_touchmove_ids_.empty()) {
       DCHECK(touch_queue_.empty());
 
       // Dispatch the next pending async touch move when time expires.
-      if (pending_async_touchmove_->event.timeStampSeconds >=
+      if (pending_async_touchmove_->event.timeStampSeconds() >=
           last_sent_touch_timestamp_sec_ + kAsyncTouchMoveIntervalSec) {
         FlushPendingAsyncTouchmove();
       }
     }
     return;
   }
 
   DCHECK(!dispatching_touch_ack_);
   dispatching_touch_ = false;
 
@@ skipping 42 matching lines @@
 }
 
 void TouchEventQueue::ForwardNextEventToRenderer() {
   TRACE_EVENT0("input", "TouchEventQueue::ForwardNextEventToRenderer");
 
   DCHECK(!empty());
   DCHECK(!dispatching_touch_);
   TouchEventWithLatencyInfo touch = touch_queue_.front()->coalesced_event();
 
   if (send_touch_events_async_ &&
-      touch.event.type == WebInputEvent::TouchMove) {
+      touch.event.type() == WebInputEvent::TouchMove) {
     // Throttling touchmove's in a continuous touchmove stream while scrolling
     // reduces the risk of jank. However, it's still important that the web
     // application be sent touches at key points in the gesture stream,
     // e.g., when the application slop region is exceeded or touchmove
     // coalescing fails because of different modifiers.
     bool send_touchmove_now = size() > 1;
     send_touchmove_now |= pending_async_touchmove_ &&
                           !pending_async_touchmove_->CanCoalesceWith(touch);
     send_touchmove_now |=
         ack_pending_async_touchmove_ids_.empty() &&
-        (touch.event.timeStampSeconds >=
+        (touch.event.timeStampSeconds() >=
          last_sent_touch_timestamp_sec_ + kAsyncTouchMoveIntervalSec);
 
     if (!send_touchmove_now) {
       if (!pending_async_touchmove_) {
         pending_async_touchmove_.reset(new TouchEventWithLatencyInfo(touch));
       } else {
         DCHECK(pending_async_touchmove_->CanCoalesceWith(touch));
         pending_async_touchmove_->CoalesceWith(touch);
       }
       DCHECK_EQ(1U, size());
       PopTouchEventToClient(INPUT_EVENT_ACK_STATE_NOT_CONSUMED);
       // It's possible (though unlikely) that ack'ing the current touch will
       // trigger the queueing of another touch event (e.g., a touchcancel). As
       // forwarding of the queued event will be deferred while the ack is being
       // dispatched (see |OnTouchEvent()|), try forwarding it now.
       TryForwardNextEventToRenderer();
       return;
     }
   }
 
-  last_sent_touch_timestamp_sec_ = touch.event.timeStampSeconds;
+  last_sent_touch_timestamp_sec_ = touch.event.timeStampSeconds();
 
   // Flush any pending async touch move. If it can be combined with the current
   // (touchmove) event, great, otherwise send it immediately but separately. Its
   // ack will trigger forwarding of the original |touch| event.
   if (pending_async_touchmove_) {
     if (pending_async_touchmove_->CanCoalesceWith(touch)) {
       pending_async_touchmove_->CoalesceWith(touch);
       pending_async_touchmove_->event.dispatchType =
           send_touch_events_async_ ? WebInputEvent::EventNonBlocking
                                    : WebInputEvent::Blocking;
       touch = *pending_async_touchmove_;
       pending_async_touchmove_.reset();
     } else {
       FlushPendingAsyncTouchmove();
       return;
     }
   }
 
   // Note: Touchstart events are marked cancelable to allow transitions between
   // platform scrolling and JS pinching. Touchend events, however, remain
   // uncancelable, mitigating the risk of jank when transitioning to a fling.
-  if (send_touch_events_async_ && touch.event.type != WebInputEvent::TouchStart)
+  if (send_touch_events_async_ &&
+      touch.event.type() != WebInputEvent::TouchStart)
     touch.event.dispatchType = WebInputEvent::EventNonBlocking;
 
   SendTouchEventImmediately(&touch);
 }
 
 void TouchEventQueue::FlushPendingAsyncTouchmove() {
   DCHECK(!dispatching_touch_);
   std::unique_ptr<TouchEventWithLatencyInfo> touch =
       std::move(pending_async_touchmove_);
   touch->event.dispatchType = WebInputEvent::EventNonBlocking;
   touch_queue_.push_front(
       base::MakeUnique<CoalescedWebTouchEvent>(*touch, true));
   SendTouchEventImmediately(touch.get());
 }
 
 void TouchEventQueue::OnGestureScrollEvent(
     const GestureEventWithLatencyInfo& gesture_event) {
-  if (gesture_event.event.type == blink::WebInputEvent::GestureScrollBegin) {
+  if (gesture_event.event.type() == blink::WebInputEvent::GestureScrollBegin) {
     if (has_handler_for_current_sequence_ &&
         !drop_remaining_touches_in_sequence_) {
       DCHECK(!touchmove_slop_suppressor_->suppressing_touchmoves())
           <<  "A touch handler should be offered a touchmove before scrolling.";
     }
 
     pending_async_touchmove_.reset();
 
     return;
   }
 
-  if (gesture_event.event.type == blink::WebInputEvent::GestureScrollUpdate &&
+  if (gesture_event.event.type() == blink::WebInputEvent::GestureScrollUpdate &&
       gesture_event.event.resendingPluginId == -1) {
     send_touch_events_async_ = true;
   }
 }
 
 void TouchEventQueue::OnGestureEventAck(
     const GestureEventWithLatencyInfo& event,
     InputEventAckState ack_result) {
   // Throttle sending touchmove events as long as the scroll events are handled.
   // Note that there's no guarantee that this ACK is for the most recent
   // gesture event (or even part of the current sequence).  Worst case, the
   // delay in updating the absorption state will result in minor UI glitches.
   // A valid |pending_async_touchmove_| will be flushed when the next event is
   // forwarded. Scroll updates that are being resent from a GuestView are
   // ignored.
-  if (event.event.type == blink::WebInputEvent::GestureScrollUpdate &&
+  if (event.event.type() == blink::WebInputEvent::GestureScrollUpdate &&
       event.event.resendingPluginId == -1) {
     send_touch_events_async_ = (ack_result == INPUT_EVENT_ACK_STATE_CONSUMED);
   }
 }
 
 void TouchEventQueue::OnHasTouchEventHandlers(bool has_handlers) {
   DCHECK(!dispatching_touch_ack_);
   DCHECK(!dispatching_touch_);
   has_handlers_ = has_handlers;
 }
 
 bool TouchEventQueue::IsPendingAckTouchStart() const {
   DCHECK(!dispatching_touch_ack_);
   if (touch_queue_.empty())
     return false;
 
   const blink::WebTouchEvent& event =
       touch_queue_.front()->coalesced_event().event;
-  return (event.type == WebInputEvent::TouchStart);
+  return (event.type() == WebInputEvent::TouchStart);
 }
 
 void TouchEventQueue::SetAckTimeoutEnabled(bool enabled) {
   if (timeout_handler_)
     timeout_handler_->SetEnabled(enabled);
 }
 
 void TouchEventQueue::SetIsMobileOptimizedSite(bool mobile_optimized_site) {
   if (timeout_handler_)
     timeout_handler_->SetUseMobileTimeout(mobile_optimized_site);
@@ skipping 47 matching lines @@
       std::move(touch_queue_.front());
   DCHECK(acked_event);
 
   UpdateTouchConsumerStates(acked_event->coalesced_event().event, ack_result);
 
   // Note that acking the touch-event may result in multiple gestures being sent
   // to the renderer, or touch-events being queued.
   base::AutoReset<bool> dispatching_touch_ack(&dispatching_touch_ack_, true);
 
   // Skip ack for TouchScrollStarted since it was synthesized within the queue.
-  if (acked_event->coalesced_event().event.type !=
+  if (acked_event->coalesced_event().event.type() !=
       WebInputEvent::TouchScrollStarted) {
     acked_event->DispatchAckToClient(ack_result, optional_latency_info,
                                      client_);
   }
 
   touch_queue_.pop_front();
 }
 
 void TouchEventQueue::SendTouchEventImmediately(
     TouchEventWithLatencyInfo* touch) {
   // TODO(crbug.com/600773): Hack to avoid cyclic reentry to this method.
   if (dispatching_touch_)
     return;
 
-  if (touch->event.type == WebInputEvent::TouchStart)
+  if (touch->event.type() == WebInputEvent::TouchStart)
     touch->event.touchStartOrFirstTouchMove = true;
 
   // For touchmove events, compare touch points position from current event
   // to last sent event and update touch points state.
-  if (touch->event.type == WebInputEvent::TouchMove) {
+  if (touch->event.type() == WebInputEvent::TouchMove) {
     CHECK(last_sent_touchevent_);
-    if (last_sent_touchevent_->type == WebInputEvent::TouchStart)
+    if (last_sent_touchevent_->type() == WebInputEvent::TouchStart)
       touch->event.touchStartOrFirstTouchMove = true;
     for (unsigned int i = 0; i < last_sent_touchevent_->touchesLength; ++i) {
       const WebTouchPoint& last_touch_point =
           last_sent_touchevent_->touches[i];
       // Touches with same id may not have same index in Touches array.
       for (unsigned int j = 0; j < touch->event.touchesLength; ++j) {
         const WebTouchPoint& current_touchmove_point = touch->event.touches[j];
         if (current_touchmove_point.id != last_touch_point.id)
           continue;
 
         if (!HasPointChanged(last_touch_point, current_touchmove_point))
           touch->event.touches[j].state = WebTouchPoint::StateStationary;
 
         break;
       }
     }
   }
 
-  if (touch->event.type != WebInputEvent::TouchScrollStarted) {
+  if (touch->event.type() != WebInputEvent::TouchScrollStarted) {
     if (last_sent_touchevent_)
       *last_sent_touchevent_ = touch->event;
     else
       last_sent_touchevent_.reset(new WebTouchEvent(touch->event));
   }
 
   base::AutoReset<bool> dispatching_touch(&dispatching_touch_, true);
 
   client_->SendTouchEventImmediately(*touch);
 
   // A synchronous ack will reset |dispatching_touch_|, in which case the touch
   // timeout should not be started and the count also should not be increased.
   if (dispatching_touch_) {
-    if (touch->event.type == WebInputEvent::TouchMove &&
+    if (touch->event.type() == WebInputEvent::TouchMove &&
         touch->event.dispatchType != WebInputEvent::Blocking) {
       // When we send out a uncancelable touch move, we increase the count and
       // we do not process input event ack any more, we will just ack to client
       // and wait for the ack from render. Also we will remove it from the front
       // of the queue.
       ack_pending_async_touchmove_ids_.push_back(
           touch->event.uniqueTouchEventId);
       dispatching_touch_ = false;
       PopTouchEventToClient(INPUT_EVENT_ACK_STATE_IGNORED);
       TryForwardNextEventToRenderer();
       return;
     }
 
     if (timeout_handler_)
       timeout_handler_->StartIfNecessary(*touch);
   }
 }
 
 TouchEventQueue::PreFilterResult
 TouchEventQueue::FilterBeforeForwarding(const WebTouchEvent& event) {
-  if (event.type == WebInputEvent::TouchScrollStarted)
+  if (event.type() == WebInputEvent::TouchScrollStarted)
     return FORWARD_TO_RENDERER;
 
   if (WebTouchEventTraits::IsTouchSequenceStart(event)) {
     has_handler_for_current_sequence_ = false;
     send_touch_events_async_ = false;
     pending_async_touchmove_.reset();
     last_sent_touchevent_.reset();
 
     touch_sequence_start_position_ = gfx::PointF(event.touches[0].position);
     drop_remaining_touches_in_sequence_ = false;
     if (!has_handlers_) {
       drop_remaining_touches_in_sequence_ = true;
       return ACK_WITH_NO_CONSUMER_EXISTS;
     }
   }
 
   if (timeout_handler_ && timeout_handler_->FilterEvent(event))
     return ACK_WITH_NO_CONSUMER_EXISTS;
 
   if (touchmove_slop_suppressor_->FilterEvent(event))
     return ACK_WITH_NOT_CONSUMED;
 
   if (drop_remaining_touches_in_sequence_ &&
-      event.type != WebInputEvent::TouchCancel) {
+      event.type() != WebInputEvent::TouchCancel) {
     return ACK_WITH_NO_CONSUMER_EXISTS;
   }
 
-  if (event.type == WebInputEvent::TouchStart) {
+  if (event.type() == WebInputEvent::TouchStart) {
     return (has_handlers_ || has_handler_for_current_sequence_)
                ? FORWARD_TO_RENDERER
                : ACK_WITH_NO_CONSUMER_EXISTS;
   }
 
   if (has_handler_for_current_sequence_) {
     // Only forward a touch if it has a non-stationary pointer that is active
     // in the current touch sequence.
     for (size_t i = 0; i < event.touchesLength; ++i) {
       const WebTouchPoint& point = event.touches[i];
       if (point.state == WebTouchPoint::StateStationary)
         continue;
 
       // |last_sent_touchevent_| will be non-null as long as there is an
       // active touch sequence being forwarded to the renderer.
       if (!last_sent_touchevent_)
         continue;
 
       for (size_t j = 0; j < last_sent_touchevent_->touchesLength; ++j) {
         if (point.id != last_sent_touchevent_->touches[j].id)
           continue;
 
-        if (event.type != WebInputEvent::TouchMove)
+        if (event.type() != WebInputEvent::TouchMove)
           return FORWARD_TO_RENDERER;
 
         // All pointers in TouchMove events may have state as StateMoved,
         // even though none of the pointers have not changed in real.
         // Forward these events when at least one pointer has changed.
         if (HasPointChanged(last_sent_touchevent_->touches[j], point))
           return FORWARD_TO_RENDERER;
 
         // This is a TouchMove event for which we have yet to find a
         // non-stationary pointer. Continue checking the next pointers
         // in the |event|.
         break;
       }
 
     }
   }
 
   return ACK_WITH_NO_CONSUMER_EXISTS;
 }
 
 void TouchEventQueue::UpdateTouchConsumerStates(const WebTouchEvent& event,
                                                 InputEventAckState ack_result) {
-  if (event.type == WebInputEvent::TouchStart) {
+  if (event.type() == WebInputEvent::TouchStart) {
     if (ack_result == INPUT_EVENT_ACK_STATE_CONSUMED)
       send_touch_events_async_ = false;
     has_handler_for_current_sequence_ |=
         ack_result != INPUT_EVENT_ACK_STATE_NO_CONSUMER_EXISTS;
   } else if (WebTouchEventTraits::IsTouchSequenceEnd(event)) {
     has_handler_for_current_sequence_ = false;
   }
 }
 
 }  // namespace content