Collapse the API surface on WebInputEvent via accessor functions.

content/browser/renderer_host/render_widget_host_impl.cc

 // Copyright (c) 2012 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_impl.h"
 
 #include <math.h>
 
 #include <set>
 #include <tuple>
@@ skipping 139 matching lines @@
 
  private:
   std::vector<RenderWidgetHostID> hosts_;
   size_t current_index_;
 
   DISALLOW_COPY_AND_ASSIGN(RenderWidgetHostIteratorImpl);
 };
 
 inline blink::WebGestureEvent CreateScrollBeginForWrapping(
     const blink::WebGestureEvent& gesture_event) {
-  DCHECK(gesture_event.type == blink::WebInputEvent::GestureScrollUpdate);
+  DCHECK(gesture_event.type() == blink::WebInputEvent::GestureScrollUpdate);
 
   blink::WebGestureEvent wrap_gesture_scroll_begin(
-      blink::WebInputEvent::GestureScrollBegin, gesture_event.modifiers,
-      gesture_event.timeStampSeconds);
+      blink::WebInputEvent::GestureScrollBegin, gesture_event.modifiers(),
+      gesture_event.timeStampSeconds());
   wrap_gesture_scroll_begin.sourceDevice = gesture_event.sourceDevice;
   wrap_gesture_scroll_begin.data.scrollBegin.deltaXHint = 0;
   wrap_gesture_scroll_begin.data.scrollBegin.deltaYHint = 0;
   wrap_gesture_scroll_begin.resendingPluginId = gesture_event.resendingPluginId;
   wrap_gesture_scroll_begin.data.scrollBegin.deltaHintUnits =
       gesture_event.data.scrollUpdate.deltaUnits;
 
   return wrap_gesture_scroll_begin;
 }
 
 inline blink::WebGestureEvent CreateScrollEndForWrapping(
     const blink::WebGestureEvent& gesture_event) {
-  DCHECK(gesture_event.type == blink::WebInputEvent::GestureScrollUpdate);
+  DCHECK(gesture_event.type() == blink::WebInputEvent::GestureScrollUpdate);
 
   blink::WebGestureEvent wrap_gesture_scroll_end(
-      blink::WebInputEvent::GestureScrollEnd, gesture_event.modifiers,
-      gesture_event.timeStampSeconds);
+      blink::WebInputEvent::GestureScrollEnd, gesture_event.modifiers(),
+      gesture_event.timeStampSeconds());
   wrap_gesture_scroll_end.sourceDevice = gesture_event.sourceDevice;
   wrap_gesture_scroll_end.resendingPluginId = gesture_event.resendingPluginId;
   wrap_gesture_scroll_end.data.scrollEnd.deltaUnits =
       gesture_event.data.scrollUpdate.deltaUnits;
 
   return wrap_gesture_scroll_end;
 }
 
 std::vector<DropData::Metadata> DropDataToMetaData(const DropData& drop_data) {
   std::vector<DropData::Metadata> metadata;
@@ skipping 901 matching lines @@
     return;
 
   // TODO(wjmaclean) Remove the code for supporting resending gesture events
   // when WebView transitions to OOPIF and BrowserPlugin is removed.
   // http://crbug.com/533069
   bool* is_in_gesture_scroll =
       gesture_event.sourceDevice ==
               blink::WebGestureDevice::WebGestureDeviceTouchpad
           ? &is_in_touchpad_gesture_scroll_
           : &is_in_touchscreen_gesture_scroll_;
-  if (gesture_event.type == blink::WebInputEvent::GestureScrollBegin) {
+  if (gesture_event.type() == blink::WebInputEvent::GestureScrollBegin) {
     DCHECK(!(*is_in_gesture_scroll));
     *is_in_gesture_scroll = true;
-  } else if (gesture_event.type == blink::WebInputEvent::GestureScrollEnd ||
-             gesture_event.type == blink::WebInputEvent::GestureFlingStart) {
+  } else if (gesture_event.type() == blink::WebInputEvent::GestureScrollEnd ||
+             gesture_event.type() == blink::WebInputEvent::GestureFlingStart) {
     DCHECK(*is_in_gesture_scroll ||
-           (gesture_event.type == blink::WebInputEvent::GestureFlingStart &&
+           (gesture_event.type() == blink::WebInputEvent::GestureFlingStart &&
             gesture_event.sourceDevice ==
                 blink::WebGestureDevice::WebGestureDeviceTouchpad));
     *is_in_gesture_scroll = false;
   }
 
   bool scroll_update_needs_wrapping =
-      gesture_event.type == blink::WebInputEvent::GestureScrollUpdate &&
+      gesture_event.type() == blink::WebInputEvent::GestureScrollUpdate &&
       gesture_event.resendingPluginId != -1 && !(*is_in_gesture_scroll);
 
   // TODO(crbug.com/544782): Fix WebViewGuestScrollTest.TestGuestWheelScrolls-
   // Bubble to test the resending logic of gesture events.
   if (scroll_update_needs_wrapping) {
     ForwardGestureEventWithLatencyInfo(
         CreateScrollBeginForWrapping(gesture_event),
         ui::WebInputEventTraits::CreateLatencyInfoForWebGestureEvent(
             gesture_event));
   }
@@ skipping 58 matching lines @@
     return;
 
   if (!process_->HasConnection())
     return;
 
   // First, let keypress listeners take a shot at handling the event.  If a
   // listener handles the event, it should not be propagated to the renderer.
   if (KeyPressListenersHandleEvent(key_event)) {
     // Some keypresses that are accepted by the listener may be followed by Char
     // and KeyUp events, which should be ignored.
-    if (key_event.type == WebKeyboardEvent::RawKeyDown)
+    if (key_event.type() == WebKeyboardEvent::RawKeyDown)
       suppress_events_until_keydown_ = true;
     return;
   }
 
   // Double check the type to make sure caller hasn't sent us nonsense that
   // will mess up our key queue.
-  if (!WebInputEvent::isKeyboardEventType(key_event.type))
+  if (!WebInputEvent::isKeyboardEventType(key_event.type()))
     return;
 
   if (suppress_events_until_keydown_) {
     // If the preceding RawKeyDown event was handled by the browser, then we
     // need to suppress all events generated by it until the next RawKeyDown or
     // KeyDown event.
-    if (key_event.type == WebKeyboardEvent::KeyUp ||
-        key_event.type == WebKeyboardEvent::Char)
+    if (key_event.type() == WebKeyboardEvent::KeyUp ||
+        key_event.type() == WebKeyboardEvent::Char)
       return;
-    DCHECK(key_event.type == WebKeyboardEvent::RawKeyDown ||
-           key_event.type == WebKeyboardEvent::KeyDown);
+    DCHECK(key_event.type() == WebKeyboardEvent::RawKeyDown ||
+           key_event.type() == WebKeyboardEvent::KeyDown);
     suppress_events_until_keydown_ = false;
   }
 
   bool is_shortcut = false;
 
   // Only pre-handle the key event if it's not handled by the input method.
   if (delegate_ && !key_event.skip_in_browser) {
     // We need to set |suppress_events_until_keydown_| to true if
     // PreHandleKeyboardEvent() returns true, but |this| may already be
     // destroyed at that time. So set |suppress_events_until_keydown_| true
     // here, then revert it afterwards when necessary.
-    if (key_event.type == WebKeyboardEvent::RawKeyDown)
+    if (key_event.type() == WebKeyboardEvent::RawKeyDown)
       suppress_events_until_keydown_ = true;
 
     // Tab switching/closing accelerators aren't sent to the renderer to avoid
     // a hung/malicious renderer from interfering.
     if (delegate_->PreHandleKeyboardEvent(key_event, &is_shortcut))
       return;
 
-    if (key_event.type == WebKeyboardEvent::RawKeyDown)
+    if (key_event.type() == WebKeyboardEvent::RawKeyDown)
       suppress_events_until_keydown_ = false;
   }
 
   if (touch_emulator_ && touch_emulator_->HandleKeyboardEvent(key_event))
     return;
   ui::LatencyInfo latency_info(ui::SourceEventType::OTHER);
   NativeWebKeyboardEventWithLatencyInfo key_event_with_latency(key_event,
                                                                latency_info);
   key_event_with_latency.event.isBrowserShortcut = is_shortcut;
   DispatchInputEventWithLatencyInfo(key_event, &key_event_with_latency.latency);
@@ skipping 799 matching lines @@
   zoomed_bitmap.setPixels(0);
   Send(new ViewMsg_ReleaseDisambiguationPopupBitmap(GetRoutingID(), id));
 }
 
 void RenderWidgetHostImpl::SetIgnoreInputEvents(bool ignore_input_events) {
   ignore_input_events_ = ignore_input_events;
 }
 
 bool RenderWidgetHostImpl::KeyPressListenersHandleEvent(
     const NativeWebKeyboardEvent& event) {
-  if (event.skip_in_browser || event.type != WebKeyboardEvent::RawKeyDown)
+  if (event.skip_in_browser || event.type() != WebKeyboardEvent::RawKeyDown)
     return false;
 
   for (size_t i = 0; i < key_press_event_callbacks_.size(); i++) {
     size_t original_size = key_press_event_callbacks_.size();
     if (key_press_event_callbacks_[i].Run(event))
       return true;
 
     // Check whether the callback that just ran removed itself, in which case
     // the iterator needs to be decremented to properly account for the removal.
     size_t current_size = key_press_event_callbacks_.size();
     if (current_size != original_size) {
       DCHECK_EQ(original_size - 1, current_size);
       --i;
     }
   }
 
   return false;
 }
 
 InputEventAckState RenderWidgetHostImpl::FilterInputEvent(
     const blink::WebInputEvent& event, const ui::LatencyInfo& latency_info) {
   // Don't ignore touch cancel events, since they may be sent while input
   // events are being ignored in order to keep the renderer from getting
   // confused about how many touches are active.
-  if (ShouldDropInputEvents() && event.type != WebInputEvent::TouchCancel)
+  if (ShouldDropInputEvents() && event.type() != WebInputEvent::TouchCancel)
     return INPUT_EVENT_ACK_STATE_NO_CONSUMER_EXISTS;
 
   if (!process_->HasConnection())
     return INPUT_EVENT_ACK_STATE_UNKNOWN;
 
   if (delegate_) {
-    if (event.type == WebInputEvent::MouseDown ||
-        event.type == WebInputEvent::TouchStart) {
+    if (event.type() == WebInputEvent::MouseDown ||
+        event.type() == WebInputEvent::TouchStart) {
       delegate_->FocusOwningWebContents(this);
     }
-    if (event.type == WebInputEvent::MouseDown ||
-        event.type == WebInputEvent::GestureScrollBegin ||
-        event.type == WebInputEvent::TouchStart ||
-        event.type == WebInputEvent::RawKeyDown) {
-      delegate_->OnUserInteraction(this, event.type);
+    if (event.type() == WebInputEvent::MouseDown ||
+        event.type() == WebInputEvent::GestureScrollBegin ||
+        event.type() == WebInputEvent::TouchStart ||
+        event.type() == WebInputEvent::RawKeyDown) {
+      delegate_->OnUserInteraction(this, event.type());
     }
   }
 
   return view_ ? view_->FilterInputEvent(event)
                : INPUT_EVENT_ACK_STATE_NOT_CONSUMED;
 }
 
 void RenderWidgetHostImpl::IncrementInFlightEventCount(
     blink::WebInputEvent::Type event_type) {
   increment_in_flight_event_count();
@@ skipping 399 matching lines @@
     // Note: We are using the origin URL provided by the sender here. It may be
     // different from the receiver's.
     file_system_file.url =
         GURL(storage::GetIsolatedFileSystemRootURIString(
                  file_system_url.origin(), filesystem_id, std::string())
                  .append(register_name));
   }
 }
 
 }  // namespace content