Collapse the API surface on WebInputEvent via accessor functions.

third_party/WebKit/Source/core/input/ScrollManager.cpp

 // 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 "core/input/ScrollManager.h"
 
 #include "core/dom/DOMNodeIds.h"
 #include "core/events/GestureEvent.h"
 #include "core/frame/BrowserControls.h"
 #include "core/frame/FrameHost.h"
@@ skipping 222 matching lines @@
       gestureEvent.sourceDevice == WebGestureDeviceTouchscreen;
   scrollStateData->delta_consumed_for_scroll_sequence =
       m_deltaConsumedForScrollSequence;
   ScrollState* scrollState = ScrollState::create(std::move(scrollStateData));
   customizedScroll(*m_scrollGestureHandlingNode.get(), *scrollState);
   return WebInputEventResult::HandledSystem;
 }
 
 WebInputEventResult ScrollManager::handleGestureScrollUpdate(
     const WebGestureEvent& gestureEvent) {
-  DCHECK_EQ(gestureEvent.type, WebInputEvent::GestureScrollUpdate);
+  DCHECK_EQ(gestureEvent.type(), WebInputEvent::GestureScrollUpdate);
 
   Node* node = m_scrollGestureHandlingNode.get();
   if (!node || !node->layoutObject())
     return WebInputEventResult::NotHandled;
 
   // Negate the deltas since the gesture event stores finger movement and
   // scrolling occurs in the direction opposite the finger's movement
   // direction. e.g. Finger moving up has negative event delta but causes the
   // page to scroll down causing positive scroll delta.
   FloatSize delta(-gestureEvent.deltaXInRootFrame(),
@@ skipping 124 matching lines @@
   return m_frame->document()->rootScrollerController().scrollsViewport(element);
 }
 
 WebInputEventResult ScrollManager::handleGestureScrollEvent(
     const WebGestureEvent& gestureEvent) {
   if (!m_frame->view())
     return WebInputEventResult::NotHandled;
 
   Node* eventTarget = nullptr;
   Scrollbar* scrollbar = nullptr;
-  if (gestureEvent.type != WebInputEvent::GestureScrollBegin) {
+  if (gestureEvent.type() != WebInputEvent::GestureScrollBegin) {
     scrollbar = m_scrollbarHandlingScrollGesture.get();
     eventTarget = m_scrollGestureHandlingNode.get();
   }
 
   if (!eventTarget) {
     Document* document = m_frame->document();
     if (document->layoutViewItem().isNull())
       return WebInputEventResult::NotHandled;
 
     FrameView* view = m_frame->view();
@@ skipping 34 matching lines @@
       DispatchEventResult gestureDomEventResult =
           eventTarget->dispatchEvent(gestureDomEvent);
       if (gestureDomEventResult != DispatchEventResult::NotCanceled) {
         DCHECK(gestureDomEventResult !=
                DispatchEventResult::CanceledByEventHandler);
         return EventHandlingUtil::toWebInputEventResult(gestureDomEventResult);
       }
     }
   }
 
-  switch (gestureEvent.type) {
+  switch (gestureEvent.type()) {
     case WebInputEvent::GestureScrollBegin:
       return handleGestureScrollBegin(gestureEvent);
     case WebInputEvent::GestureScrollUpdate:
       return handleGestureScrollUpdate(gestureEvent);
     case WebInputEvent::GestureScrollEnd:
       return handleGestureScrollEnd(gestureEvent);
     case WebInputEvent::GestureFlingStart:
     case WebInputEvent::GesturePinchBegin:
     case WebInputEvent::GesturePinchEnd:
     case WebInputEvent::GesturePinchUpdate:
       return WebInputEventResult::NotHandled;
     default:
       NOTREACHED();
       return WebInputEventResult::NotHandled;
   }
 }
 
 bool ScrollManager::isScrollbarHandlingGestures() const {
   return m_scrollbarHandlingScrollGesture.get();
 }
 
 bool ScrollManager::handleScrollGestureOnResizer(
     Node* eventTarget,
     const WebGestureEvent& gestureEvent) {
   if (gestureEvent.sourceDevice != WebGestureDeviceTouchscreen)
     return false;
 
-  if (gestureEvent.type == WebInputEvent::GestureScrollBegin) {
+  if (gestureEvent.type() == WebInputEvent::GestureScrollBegin) {
     PaintLayer* layer = eventTarget->layoutObject()
                             ? eventTarget->layoutObject()->enclosingLayer()
                             : nullptr;
     IntPoint p = m_frame->view()->rootFrameToContents(
         flooredIntPoint(gestureEvent.positionInRootFrame()));
     if (layer && layer->getScrollableArea() &&
         layer->getScrollableArea()->isPointInResizeControl(p,
                                                            ResizerForTouch)) {
       m_resizeScrollableArea = layer->getScrollableArea();
       m_resizeScrollableArea->setInResizeMode(true);
       m_offsetFromResizeCorner =
           LayoutSize(m_resizeScrollableArea->offsetFromResizeCorner(p));
       return true;
     }
-  } else if (gestureEvent.type == WebInputEvent::GestureScrollUpdate) {
+  } else if (gestureEvent.type() == WebInputEvent::GestureScrollUpdate) {
     if (m_resizeScrollableArea && m_resizeScrollableArea->inResizeMode()) {
       IntPoint pos = roundedIntPoint(gestureEvent.positionInRootFrame());
       pos.move(gestureEvent.deltaXInRootFrame(),
                gestureEvent.deltaYInRootFrame());
       m_resizeScrollableArea->resize(pos, m_offsetFromResizeCorner);
       return true;
     }
-  } else if (gestureEvent.type == WebInputEvent::GestureScrollEnd) {
+  } else if (gestureEvent.type() == WebInputEvent::GestureScrollEnd) {
     if (m_resizeScrollableArea && m_resizeScrollableArea->inResizeMode()) {
       m_resizeScrollableArea->setInResizeMode(false);
       m_resizeScrollableArea = nullptr;
       return false;
     }
   }
 
   return false;
 }
 
@@ skipping 34 matching lines @@
     if (scrollbar->gestureEvent(targetedEvent.event(), &shouldUpdateCapture)) {
       if (shouldUpdateCapture)
         m_scrollbarHandlingScrollGesture = scrollbar;
       return true;
     }
   }
   return false;
 }
 
 }  // namespace blink