Collapse the API surface on WebInputEvent via accessor functions.

content/renderer/input/main_thread_event_queue.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 "content/renderer/input/main_thread_event_queue.h"
 
 #include "base/metrics/histogram_macros.h"
 #include "content/common/input/event_with_latency_info.h"
 #include "content/common/input_messages.h"
 
 namespace content {
 
 namespace {
 
 const size_t kTenSeconds = 10 * 1000 * 1000;
 
 bool IsContinuousEvent(const std::unique_ptr<EventWithDispatchType>& event) {
-  switch (event->event().type) {
+  switch (event->event().type()) {
     case blink::WebInputEvent::MouseMove:
     case blink::WebInputEvent::MouseWheel:
       return true;
     case blink::WebInputEvent::TouchMove:
       // TouchMoves that are blocking end up blocking scroll. Do not treat
       // them as continuous events otherwise we will end up waiting up to an
       // additional frame.
       return static_cast<const blink::WebTouchEvent&>(event->event())
                  .dispatchType != blink::WebInputEvent::Blocking;
     default:
@@ skipping 56 matching lines @@
     InputEventDispatchType original_dispatch_type,
     InputEventAckState ack_result) {
   DCHECK(original_dispatch_type == DISPATCH_TYPE_BLOCKING ||
          original_dispatch_type == DISPATCH_TYPE_NON_BLOCKING);
   DCHECK(ack_result == INPUT_EVENT_ACK_STATE_SET_NON_BLOCKING ||
          ack_result == INPUT_EVENT_ACK_STATE_SET_NON_BLOCKING_DUE_TO_FLING ||
          ack_result == INPUT_EVENT_ACK_STATE_NOT_CONSUMED);
 
   bool non_blocking = original_dispatch_type == DISPATCH_TYPE_NON_BLOCKING ||
                       ack_result == INPUT_EVENT_ACK_STATE_SET_NON_BLOCKING;
-  bool is_wheel = event->type == blink::WebInputEvent::MouseWheel;
-  bool is_touch = blink::WebInputEvent::isTouchEventType(event->type);
+  bool is_wheel = event->type() == blink::WebInputEvent::MouseWheel;
+  bool is_touch = blink::WebInputEvent::isTouchEventType(event->type());
 
   if (is_touch) {
     blink::WebTouchEvent* touch_event =
         static_cast<blink::WebTouchEvent*>(event.get());
 
     // Adjust the |dispatchType| on the event since the compositor
     // determined all event listeners are passive.
     if (non_blocking) {
       touch_event->dispatchType =
           blink::WebInputEvent::ListenersNonBlockingPassive;
     }
-    if (touch_event->type == blink::WebInputEvent::TouchStart)
+    if (touch_event->type() == blink::WebInputEvent::TouchStart)
       last_touch_start_forced_nonblocking_due_to_fling_ = false;
 
     if (enable_fling_passive_listener_flag_ &&
         touch_event->touchStartOrFirstTouchMove &&
         touch_event->dispatchType == blink::WebInputEvent::Blocking) {
       // If the touch start is forced to be passive due to fling, its following
       // touch move should also be passive.
       if (ack_result == INPUT_EVENT_ACK_STATE_SET_NON_BLOCKING_DUE_TO_FLING ||
           last_touch_start_forced_nonblocking_due_to_fling_) {
         touch_event->dispatchType =
@@ skipping 194 matching lines @@
   if (needs_main_frame)
     client_->NeedsMainFrame(routing_id_);
 }
 
 bool MainThreadEventQueue::IsRafAlignedInputDisabled() {
   return !handle_raf_aligned_mouse_input_ && !handle_raf_aligned_touch_input_;
 }
 
 bool MainThreadEventQueue::IsRafAlignedEvent(
     const blink::WebInputEvent& event) {
-  switch (event.type) {
+  switch (event.type()) {
     case blink::WebInputEvent::MouseMove:
     case blink::WebInputEvent::MouseWheel:
       return handle_raf_aligned_mouse_input_;
     case blink::WebInputEvent::TouchMove:
       // TouchMoves that are blocking end up blocking scroll. Do not treat
       // them as continuous events otherwise we will end up waiting up to an
       // additional frame.
       return static_cast<const blink::WebTouchEvent&>(event).dispatchType !=
                  blink::WebInputEvent::Blocking &&
              handle_raf_aligned_touch_input_;
     default:
       return false;
   }
 }
 
 }  // namespace content