Collapse the API surface on WebInputEvent via accessor functions.

third_party/WebKit/Source/platform/exported/WebCoalescedInputEvent.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 "public/platform/WebCoalescedInputEvent.h"
 
 #include "public/platform/WebGestureEvent.h"
 #include "public/platform/WebMouseWheelEvent.h"
 
 namespace blink {
 
 namespace {
 
 WebScopedInputEvent makeWebScopedInputEvent(const blink::WebInputEvent& event) {
-  if (blink::WebInputEvent::isGestureEventType(event.type)) {
+  if (blink::WebInputEvent::isGestureEventType(event.type())) {
     return WebScopedInputEvent(new blink::WebGestureEvent(
         static_cast<const blink::WebGestureEvent&>(event)));
   }
-  if (blink::WebInputEvent::isMouseEventType(event.type)) {
+  if (blink::WebInputEvent::isMouseEventType(event.type())) {
     return WebScopedInputEvent(new blink::WebMouseEvent(
         static_cast<const blink::WebMouseEvent&>(event)));
   }
-  if (blink::WebInputEvent::isTouchEventType(event.type)) {
+  if (blink::WebInputEvent::isTouchEventType(event.type())) {
     return WebScopedInputEvent(new blink::WebTouchEvent(
         static_cast<const blink::WebTouchEvent&>(event)));
   }
-  if (event.type == blink::WebInputEvent::MouseWheel) {
+  if (event.type() == blink::WebInputEvent::MouseWheel) {
     return WebScopedInputEvent(new blink::WebMouseWheelEvent(
         static_cast<const blink::WebMouseWheelEvent&>(event)));
   }
-  if (blink::WebInputEvent::isKeyboardEventType(event.type)) {
+  if (blink::WebInputEvent::isKeyboardEventType(event.type())) {
     return WebScopedInputEvent(new blink::WebKeyboardEvent(
         static_cast<const blink::WebKeyboardEvent&>(event)));
   }
   NOTREACHED();
   return WebScopedInputEvent();
 }
 
 struct WebInputEventDelete {
   template <class EventType>
   bool Execute(WebInputEvent* event) const {
     if (!event)
       return false;
-    DCHECK_EQ(sizeof(EventType), event->size);
+    DCHECK_EQ(sizeof(EventType), event->size());
     delete static_cast<EventType*>(event);
     return true;
   }
 };
 
 template <typename Operator, typename ArgIn>
 bool Apply(Operator op, WebInputEvent::Type type, const ArgIn& argIn) {
   if (WebInputEvent::isMouseEventType(type))
     return op.template Execute<WebMouseEvent>(argIn);
   if (type == WebInputEvent::MouseWheel)
     return op.template Execute<WebMouseWheelEvent>(argIn);
   if (WebInputEvent::isKeyboardEventType(type))
     return op.template Execute<WebKeyboardEvent>(argIn);
   if (WebInputEvent::isTouchEventType(type))
     return op.template Execute<WebTouchEvent>(argIn);
   if (WebInputEvent::isGestureEventType(type))
     return op.template Execute<WebGestureEvent>(argIn);
 
   NOTREACHED() << "Unknown webkit event type " << type;
   return false;
 }
 }
 
 void WebInputEventDeleter::operator()(WebInputEvent* event) const {
   if (!event)
     return;
-  Apply(WebInputEventDelete(), event->type, event);
+  Apply(WebInputEventDelete(), event->type(), event);
 }
 
 WebInputEvent* WebCoalescedInputEvent::eventPointer() {
   return m_event.get();
 }
 
 void WebCoalescedInputEvent::addCoalescedEvent(
     const blink::WebInputEvent& event) {
   m_coalescedEvents.push_back(makeWebScopedInputEvent(event));
 }
@@ skipping 32 matching lines @@
 WebCoalescedInputEvent::WebCoalescedInputEvent(
     const WebInputEvent& event,
     const std::vector<const WebInputEvent*>& coalescedEvents)
     : m_event(), m_coalescedEvents(coalescedEvents.size()) {
   m_event = makeWebScopedInputEvent(event);
   for (const auto& coalescedEvent : coalescedEvents)
     m_coalescedEvents.push_back(makeWebScopedInputEvent(*coalescedEvent));
 }
 
 }  // namespace blink