Collapse the API surface on WebInputEvent via accessor functions.

content/browser/renderer_host/render_widget_host_input_event_router.cc

 // Copyright 2015 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/render_widget_host_input_event_router.h"
 
 #include <vector>
 
 #include "base/metrics/histogram_macros.h"
 
@@ skipping 161 matching lines @@
 void RenderWidgetHostInputEventRouter::RouteMouseEvent(
     RenderWidgetHostViewBase* root_view,
     blink::WebMouseEvent* event,
     const ui::LatencyInfo& latency) {
   RenderWidgetHostViewBase* target;
   gfx::Point transformed_point;
   const int mouse_button_modifiers = blink::WebInputEvent::LeftButtonDown |
                                      blink::WebInputEvent::MiddleButtonDown |
                                      blink::WebInputEvent::RightButtonDown;
   if (mouse_capture_target_.target &&
-      event->type != blink::WebInputEvent::MouseDown &&
-      (event->type == blink::WebInputEvent::MouseUp ||
-       event->modifiers & mouse_button_modifiers)) {
+      event->type() != blink::WebInputEvent::MouseDown &&
+      (event->type() == blink::WebInputEvent::MouseUp ||
+       event->modifiers() & mouse_button_modifiers)) {
     target = mouse_capture_target_.target;
     if (!root_view->TransformPointToCoordSpaceForView(
             gfx::Point(event->x, event->y), target, &transformed_point))
       return;
-    if (event->type == blink::WebInputEvent::MouseUp)
+    if (event->type() == blink::WebInputEvent::MouseUp)
       mouse_capture_target_.target = nullptr;
   } else {
     target = FindEventTarget(root_view, gfx::Point(event->x, event->y),
                              &transformed_point);
   }
 
   // RenderWidgetHostViewGuest does not properly handle direct routing of mouse
   // events, so they have to go by the double-hop forwarding path through
   // the embedding renderer and then BrowserPluginGuest.
   if (target && target->IsRenderWidgetHostViewGuest()) {
@@ skipping 17 matching lines @@
               gfx::Point(event->x, event->y), owner_view, &owner_point)) {
         return;
       }
       event->x = owner_point.x();
       event->y = owner_point.y();
     }
     owner_view->ProcessMouseEvent(*event, latency_info);
     return;
   }
 
-  if (event->type == blink::WebInputEvent::MouseDown)
+  if (event->type() == blink::WebInputEvent::MouseDown)
     mouse_capture_target_.target = target;
 
   if (!target)
     return;
 
   // SendMouseEnterOrLeaveEvents is called with the original event
   // coordinates, which are transformed independently for each view that will
   // receive an event.
-  if ((event->type == blink::WebInputEvent::MouseLeave ||
-       event->type == blink::WebInputEvent::MouseMove) &&
+  if ((event->type() == blink::WebInputEvent::MouseLeave ||
+       event->type() == blink::WebInputEvent::MouseMove) &&
       target != last_mouse_move_target_)
     SendMouseEnterOrLeaveEvents(event, target, root_view);
 
   event->x = transformed_point.x();
   event->y = transformed_point.y();
   target->ProcessMouseEvent(*event, latency);
 }
 
 void RenderWidgetHostInputEventRouter::RouteMouseWheelEvent(
     RenderWidgetHostViewBase* root_view,
@@ skipping 27 matching lines @@
   };
 }
 
 namespace {
 
 unsigned CountChangedTouchPoints(const blink::WebTouchEvent& event) {
   unsigned changed_count = 0;
 
   blink::WebTouchPoint::State required_state =
       blink::WebTouchPoint::StateUndefined;
-  switch (event.type) {
+  switch (event.type()) {
     case blink::WebInputEvent::TouchStart:
       required_state = blink::WebTouchPoint::StatePressed;
       break;
     case blink::WebInputEvent::TouchEnd:
       required_state = blink::WebTouchPoint::StateReleased;
       break;
     case blink::WebInputEvent::TouchCancel:
       required_state = blink::WebTouchPoint::StateCancelled;
       break;
     default:
       // We'll only ever call this method for TouchStart, TouchEnd
       // and TounchCancel events, so mark the rest as not-reached.
       NOTREACHED();
     }
   for (unsigned i = 0; i < event.touchesLength; ++i) {
     if (event.touches[i].state == required_state)
       ++changed_count;
   }
 
-  DCHECK(event.type == blink::WebInputEvent::TouchCancel || changed_count == 1);
+  DCHECK(event.type() == blink::WebInputEvent::TouchCancel ||
+         changed_count == 1);
   return changed_count;
 }
 
 }  // namespace
 
 void RenderWidgetHostInputEventRouter::RouteTouchEvent(
     RenderWidgetHostViewBase* root_view,
     blink::WebTouchEvent* event,
     const ui::LatencyInfo& latency) {
-  switch (event->type) {
+  switch (event->type()) {
     case blink::WebInputEvent::TouchStart: {
       active_touches_ += CountChangedTouchPoints(*event);
       if (active_touches_ == 1) {
         // Since this is the first touch, it defines the target for the rest
         // of this sequence.
         DCHECK(!touch_target_.target);
         gfx::Point transformed_point;
         gfx::Point original_point(event->touches[0].position.x,
                                   event->touches[0].position.y);
         touch_target_.target =
             FindEventTarget(root_view, original_point, &transformed_point);
 
         // TODO(wjmaclean): Instead of just computing a delta, we should extract
         // the complete transform. We assume it doesn't change for the duration
         // of the touch sequence, though this could be wrong; a better approach
         // might be to always transform each point to the |touch_target_.target|
         // for the duration of the sequence.
         touch_target_.delta = transformed_point - original_point;
         touchscreen_gesture_target_queue_.push_back(touch_target_);
 
         if (!touch_target_.target)
           return;
 
         if (touch_target_.target == bubbling_gesture_scroll_target_.target) {
           SendGestureScrollEnd(
               bubbling_gesture_scroll_target_.target,
-              DummyGestureScrollUpdate(event->timeStampSeconds));
+              DummyGestureScrollUpdate(event->timeStampSeconds()));
           CancelScrollBubbling(bubbling_gesture_scroll_target_.target);
         }
       }
 
       if (touch_target_.target) {
         TransformEventTouchPositions(event, touch_target_.delta);
         touch_target_.target->ProcessTouchEvent(*event, latency);
       }
       break;
     }
@@ skipping 146 matching lines @@
 
 void RenderWidgetHostInputEventRouter::BubbleScrollEvent(
     RenderWidgetHostViewBase* target_view,
     const blink::WebGestureEvent& event) {
   // TODO(kenrb, tdresser): This needs to be refactored when scroll latching
   // is implemented (see https://crbug.com/526463). This design has some
   // race problems that can result in lost scroll delta, which are very
   // difficult to resolve until this is changed to do all scroll targeting,
   // including bubbling, based on GestureScrollBegin.
   DCHECK(target_view);
-  DCHECK(event.type == blink::WebInputEvent::GestureScrollUpdate ||
-         event.type == blink::WebInputEvent::GestureScrollEnd);
+  DCHECK(event.type() == blink::WebInputEvent::GestureScrollUpdate ||
+         event.type() == blink::WebInputEvent::GestureScrollEnd);
   // DCHECK_XNOR the current and original bubble targets. Both should be set
   // if a bubbling gesture scroll is in progress.
   DCHECK(!first_bubbling_scroll_target_.target ==
          !bubbling_gesture_scroll_target_.target);
 
   ui::LatencyInfo latency_info =
       ui::WebInputEventTraits::CreateLatencyInfoForWebGestureEvent(event);
 
   // If target_view is already set up for bubbled scrolls, we forward
   // the event to the current scroll target without further consideration.
   if (target_view == first_bubbling_scroll_target_.target) {
     bubbling_gesture_scroll_target_.target->ProcessGestureEvent(event,
                                                                 latency_info);
-    if (event.type == blink::WebInputEvent::GestureScrollEnd) {
+    if (event.type() == blink::WebInputEvent::GestureScrollEnd) {
       first_bubbling_scroll_target_.target = nullptr;
       bubbling_gesture_scroll_target_.target = nullptr;
     }
     return;
   }
 
   // Disregard GestureScrollEnd events going to non-current targets.
   // These should only happen on ACKs of synthesized GSE events that are
   // sent from SendGestureScrollEnd calls, and are not relevant here.
-  if (event.type == blink::WebInputEvent::GestureScrollEnd)
+  if (event.type() == blink::WebInputEvent::GestureScrollEnd)
     return;
 
   // This is a special case to catch races where multiple GestureScrollUpdates
   // have been sent to a renderer before the first one was ACKed, and the ACK
   // caused a bubble retarget. In this case they all get forwarded.
   if (target_view == bubbling_gesture_scroll_target_.target) {
     bubbling_gesture_scroll_target_.target->ProcessGestureEvent(event,
                                                                 latency_info);
     return;
   }
@@ skipping 18 matching lines @@
 
   bubbling_gesture_scroll_target_.target = target_view;
 
   SendGestureScrollBegin(target_view, event);
   target_view->ProcessGestureEvent(event, latency_info);
 }
 
 void RenderWidgetHostInputEventRouter::SendGestureScrollBegin(
     RenderWidgetHostViewBase* view,
     const blink::WebGestureEvent& event) {
-  DCHECK(event.type == blink::WebInputEvent::GestureScrollUpdate ||
-         event.type == blink::WebInputEvent::GesturePinchBegin);
+  DCHECK(event.type() == blink::WebInputEvent::GestureScrollUpdate ||
+         event.type() == blink::WebInputEvent::GesturePinchBegin);
   blink::WebGestureEvent scroll_begin(event);
   scroll_begin.setType(blink::WebInputEvent::GestureScrollBegin);
   scroll_begin.data.scrollBegin.deltaXHint = event.data.scrollUpdate.deltaX;
   scroll_begin.data.scrollBegin.deltaYHint = event.data.scrollUpdate.deltaY;
   scroll_begin.data.scrollBegin.deltaHintUnits =
       event.data.scrollUpdate.deltaUnits;
   view->ProcessGestureEvent(
       scroll_begin,
       ui::WebInputEventTraits::CreateLatencyInfoForWebGestureEvent(event));
 }
 
 void RenderWidgetHostInputEventRouter::SendGestureScrollEnd(
     RenderWidgetHostViewBase* view,
     const blink::WebGestureEvent& event) {
-  DCHECK(event.type == blink::WebInputEvent::GestureScrollUpdate ||
-         event.type == blink::WebInputEvent::GesturePinchEnd);
+  DCHECK(event.type() == blink::WebInputEvent::GestureScrollUpdate ||
+         event.type() == blink::WebInputEvent::GesturePinchEnd);
   blink::WebGestureEvent scroll_end(event);
   scroll_end.setType(blink::WebInputEvent::GestureScrollEnd);
   scroll_end.setTimeStampSeconds(
       (base::TimeTicks::Now() - base::TimeTicks()).InSecondsF());
   scroll_end.data.scrollEnd.inertialPhase =
       event.data.scrollUpdate.inertialPhase;
   scroll_end.data.scrollEnd.deltaUnits = event.data.scrollUpdate.deltaUnits;
   view->ProcessGestureEvent(
       scroll_end,
       ui::WebInputEventTraits::CreateLatencyInfoForWebGestureEvent(event));
@@ skipping 55 matching lines @@
       FindEventTarget(root_view, point, transformed_point)
           ->GetRenderWidgetHost());
 }
 
 void RenderWidgetHostInputEventRouter::RouteTouchscreenGestureEvent(
     RenderWidgetHostViewBase* root_view,
     blink::WebGestureEvent* event,
     const ui::LatencyInfo& latency) {
   DCHECK_EQ(blink::WebGestureDeviceTouchscreen, event->sourceDevice);
 
-  if (event->type == blink::WebInputEvent::GesturePinchBegin) {
+  if (event->type() == blink::WebInputEvent::GesturePinchBegin) {
     in_touchscreen_gesture_pinch_ = true;
     // If the root view wasn't already receiving the gesture stream, then we
     // need to wrap the diverted pinch events in a GestureScrollBegin/End.
     // TODO(wjmaclean,kenrb,tdresser): When scroll latching lands, we can
     // revisit how this code should work.
     // https://crbug.com/526463
     auto rwhi =
         static_cast<RenderWidgetHostImpl*>(root_view->GetRenderWidgetHost());
     // If the root view is the current gesture target, then we explicitly don't
     // send a GestureScrollBegin, as by the time we see GesturePinchBegin there
     // should have been one.
     if (root_view != touchscreen_gesture_target_.target &&
         !rwhi->is_in_touchscreen_gesture_scroll()) {
       gesture_pinch_did_send_scroll_begin_ = true;
       SendGestureScrollBegin(root_view, *event);
     }
   }
 
   if (in_touchscreen_gesture_pinch_) {
     root_view->ProcessGestureEvent(*event, latency);
-    if (event->type == blink::WebInputEvent::GesturePinchEnd) {
+    if (event->type() == blink::WebInputEvent::GesturePinchEnd) {
       in_touchscreen_gesture_pinch_ = false;
       // If the root view wasn't already receiving the gesture stream, then we
       // need to wrap the diverted pinch events in a GestureScrollBegin/End.
       auto rwhi =
           static_cast<RenderWidgetHostImpl*>(root_view->GetRenderWidgetHost());
       if (root_view != touchscreen_gesture_target_.target &&
           gesture_pinch_did_send_scroll_begin_ &&
           rwhi->is_in_touchscreen_gesture_scroll()) {
         SendGestureScrollEnd(root_view, *event);
       }
       gesture_pinch_did_send_scroll_begin_ = false;
     }
     return;
   }
 
   // We use GestureTapDown to detect the start of a gesture sequence since there
   // is no WebGestureEvent equivalent for ET_GESTURE_BEGIN. Note that this
   // means the GestureFlingCancel that always comes between ET_GESTURE_BEGIN and
   // GestureTapDown is sent to the previous target, in case it is still in a
   // fling.
-  if (event->type == blink::WebInputEvent::GestureTapDown) {
+  if (event->type() == blink::WebInputEvent::GestureTapDown) {
     bool no_target = touchscreen_gesture_target_queue_.empty();
     // This UMA metric is temporary, and will be removed once it has fulfilled
     // it's purpose, namely telling us when the incidents of empty
     // gesture-queues has dropped to zero. https://crbug.com/642008
     UMA_HISTOGRAM_BOOLEAN("Event.FrameEventRouting.NoGestureTarget", no_target);
     if (no_target) {
       LOG(ERROR) << "Gesture sequence start detected with no target available.";
       // Ignore this gesture sequence as no target is available.
       // TODO(wjmaclean): this only happens on Windows, and should not happen.
       // https://crbug.com/595422
       touchscreen_gesture_target_.target = nullptr;
       return;
     }
 
     touchscreen_gesture_target_ = touchscreen_gesture_target_queue_.front();
     touchscreen_gesture_target_queue_.pop_front();
 
     // Abort any scroll bubbling in progress to avoid double entry.
     if (touchscreen_gesture_target_.target &&
         touchscreen_gesture_target_.target ==
             bubbling_gesture_scroll_target_.target) {
       SendGestureScrollEnd(bubbling_gesture_scroll_target_.target,
-                           DummyGestureScrollUpdate(event->timeStampSeconds));
+                           DummyGestureScrollUpdate(event->timeStampSeconds()));
       CancelScrollBubbling(bubbling_gesture_scroll_target_.target);
     }
   }
 
   if (!touchscreen_gesture_target_.target)
     return;
 
   // TODO(mohsen): Add tests to check event location.
   event->x += touchscreen_gesture_target_.delta.x();
   event->y += touchscreen_gesture_target_.delta.y();
   touchscreen_gesture_target_.target->ProcessGestureEvent(*event, latency);
 }
 
 void RenderWidgetHostInputEventRouter::RouteTouchpadGestureEvent(
     RenderWidgetHostViewBase* root_view,
     blink::WebGestureEvent* event,
     const ui::LatencyInfo& latency) {
   DCHECK_EQ(blink::WebGestureDeviceTouchpad, event->sourceDevice);
 
-  if (event->type == blink::WebInputEvent::GesturePinchBegin ||
-      event->type == blink::WebInputEvent::GestureFlingStart) {
+  if (event->type() == blink::WebInputEvent::GesturePinchBegin ||
+      event->type() == blink::WebInputEvent::GestureFlingStart) {
     gfx::Point transformed_point;
     gfx::Point original_point(event->x, event->y);
     touchpad_gesture_target_.target =
         FindEventTarget(root_view, original_point, &transformed_point);
     // TODO(mohsen): Instead of just computing a delta, we should extract the
     // complete transform. We assume it doesn't change for the duration of the
     // touchpad gesture sequence, though this could be wrong; a better approach
     // might be to always transform each point to the
     // |touchpad_gesture_target_.target| for the duration of the sequence.
     touchpad_gesture_target_.delta = transformed_point - original_point;
 
     // Abort any scroll bubbling in progress to avoid double entry.
     if (touchpad_gesture_target_.target &&
         touchpad_gesture_target_.target ==
             bubbling_gesture_scroll_target_.target) {
       SendGestureScrollEnd(bubbling_gesture_scroll_target_.target,
-                           DummyGestureScrollUpdate(event->timeStampSeconds));
+                           DummyGestureScrollUpdate(event->timeStampSeconds()));
       CancelScrollBubbling(bubbling_gesture_scroll_target_.target);
     }
   }
 
   if (!touchpad_gesture_target_.target)
     return;
 
   // TODO(mohsen): Add tests to check event location.
   event->x += touchpad_gesture_target_.delta.x();
   event->y += touchpad_gesture_target_.delta.y();
   touchpad_gesture_target_.target->ProcessGestureEvent(*event, latency);
 }
 
 }  // namespace content