Collapse the API surface on WebInputEvent via accessor functions.

content/browser/renderer_host/input/touch_event_queue_unittest.cc

 // Copyright 2013 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/input/touch_event_queue.h"
 
 #include <stddef.h>
 
 #include <memory>
 #include <utility>
@@ skipping 96 matching lines @@
   void SetUpForTimeoutTesting() {
     SetUpForTimeoutTesting(DefaultTouchTimeoutDelay(),
                            DefaultTouchTimeoutDelay());
   }
 
   void SendTouchEvent(WebTouchEvent event) {
     if (slop_length_dips_) {
       event.movedBeyondSlopRegion = false;
       if (WebTouchEventTraits::IsTouchSequenceStart(event))
         anchor_ = event.touches[0].position;
-      if (event.type == WebInputEvent::TouchMove) {
+      if (event.type() == WebInputEvent::TouchMove) {
         gfx::Vector2dF delta = anchor_ - event.touches[0].position;
         if (delta.LengthSquared() > slop_length_dips_ * slop_length_dips_)
           event.movedBeyondSlopRegion = true;
       }
     } else {
-      event.movedBeyondSlopRegion = event.type == WebInputEvent::TouchMove;
+      event.movedBeyondSlopRegion = event.type() == WebInputEvent::TouchMove;
     }
     queue_->QueueEvent(TouchEventWithLatencyInfo(event, ui::LatencyInfo()));
   }
 
   void SendGestureEvent(WebInputEvent::Type type) {
     WebGestureEvent event(type, WebInputEvent::NoModifiers,
                           ui::EventTimeStampToSeconds(ui::EventTimeForNow()));
     queue_->OnGestureScrollEvent(
         GestureEventWithLatencyInfo(event, ui::LatencyInfo()));
   }
@@ skipping 56 matching lines @@
 
   void ChangeTouchPointRadius(int index, float radius_x, float radius_y) {
     CHECK_GE(index, 0);
     CHECK_LT(index, touch_event_.kTouchesLengthCap);
     WebTouchPoint& point = touch_event_.touches[index];
     point.radiusX = radius_x;
     point.radiusY = radius_y;
     touch_event_.touches[index].state = WebTouchPoint::StateMoved;
     touch_event_.movedBeyondSlopRegion = true;
     WebTouchEventTraits::ResetType(WebInputEvent::TouchMove,
-                                   touch_event_.timeStampSeconds,
+                                   touch_event_.timeStampSeconds(),
                                    &touch_event_);
     SendTouchEvent();
   }
 
   void ChangeTouchPointRotationAngle(int index, float rotation_angle) {
     CHECK_GE(index, 0);
     CHECK_LT(index, touch_event_.kTouchesLengthCap);
     WebTouchPoint& point = touch_event_.touches[index];
     point.rotationAngle = rotation_angle;
     touch_event_.touches[index].state = WebTouchPoint::StateMoved;
     touch_event_.movedBeyondSlopRegion = true;
     WebTouchEventTraits::ResetType(WebInputEvent::TouchMove,
-                                   touch_event_.timeStampSeconds,
+                                   touch_event_.timeStampSeconds(),
                                    &touch_event_);
     SendTouchEvent();
   }
 
   void ChangeTouchPointForce(int index, float force) {
     CHECK_GE(index, 0);
     CHECK_LT(index, touch_event_.kTouchesLengthCap);
     WebTouchPoint& point = touch_event_.touches[index];
     point.force = force;
     touch_event_.touches[index].state = WebTouchPoint::StateMoved;
     touch_event_.movedBeyondSlopRegion = true;
     WebTouchEventTraits::ResetType(WebInputEvent::TouchMove,
-                                   touch_event_.timeStampSeconds,
+                                   touch_event_.timeStampSeconds(),
                                    &touch_event_);
     SendTouchEvent();
   }
 
   void ReleaseTouchPoint(int index) {
     touch_event_.ReleasePoint(index);
     SendTouchEvent();
   }
 
   void CancelTouchPoint(int index) {
     touch_event_.CancelPoint(index);
     SendTouchEvent();
   }
 
   void PrependTouchScrollNotification() {
     queue_->PrependTouchScrollNotification();
   }
 
   void AdvanceTouchTime(double seconds) {
-    touch_event_.setTimeStampSeconds(touch_event_.timeStampSeconds + seconds);
+    touch_event_.setTimeStampSeconds(touch_event_.timeStampSeconds() + seconds);
   }
 
   void ResetTouchEvent() {
     touch_event_ = SyntheticWebTouchEvent();
   }
 
   size_t GetAndResetAckedEventCount() {
     size_t count = acked_event_count_;
     acked_event_count_ = 0;
     return count;
@@ skipping 98 matching lines @@
   // The second touch should not be sent since one is already in queue.
   MoveTouchPoint(0, 5, 5);
   EXPECT_EQ(2U, queued_event_count());
   EXPECT_EQ(0U, GetAndResetSentEventCount());
 
   // Receive an ACK for the first touch-event.
   SendTouchEventAck(INPUT_EVENT_ACK_STATE_CONSUMED);
   EXPECT_EQ(1U, queued_event_count());
   EXPECT_EQ(1U, GetAndResetSentEventCount());
   EXPECT_EQ(1U, GetAndResetAckedEventCount());
-  EXPECT_EQ(WebInputEvent::TouchStart, acked_event().type);
+  EXPECT_EQ(WebInputEvent::TouchStart, acked_event().type());
   EXPECT_EQ(WebInputEvent::Blocking, acked_event().dispatchType);
 
   // Receive an ACK for the second touch-event.
   SendTouchEventAck(INPUT_EVENT_ACK_STATE_CONSUMED);
   EXPECT_EQ(0U, queued_event_count());
   EXPECT_EQ(0U, GetAndResetSentEventCount());
   EXPECT_EQ(1U, GetAndResetAckedEventCount());
-  EXPECT_EQ(WebInputEvent::TouchMove, acked_event().type);
+  EXPECT_EQ(WebInputEvent::TouchMove, acked_event().type());
   EXPECT_EQ(WebInputEvent::Blocking, acked_event().dispatchType);
 }
 
 // Tests that touch-events with multiple points are queued properly.
 TEST_F(TouchEventQueueTest, BasicMultiTouch) {
   const size_t kPointerCount = 10;
   for (float i = 0; i < kPointerCount; ++i)
     PressTouchPoint(i, i);
 
   EXPECT_EQ(1U, GetAndResetSentEventCount());
@@ skipping 221 matching lines @@
   EXPECT_EQ(0U, GetAndResetSentEventCount());
   ReleaseTouchPoint(0);
   EXPECT_EQ(0U, GetAndResetSentEventCount());
   EXPECT_EQ(3U, queued_event_count());
 
   // ACK the press.  Coalesced touch-move events should be sent.
   SendTouchEventAck(INPUT_EVENT_ACK_STATE_CONSUMED);
   EXPECT_EQ(2U, queued_event_count());
   EXPECT_EQ(1U, GetAndResetSentEventCount());
   EXPECT_EQ(1U, GetAndResetAckedEventCount());
-  EXPECT_EQ(WebInputEvent::TouchStart, acked_event().type);
+  EXPECT_EQ(WebInputEvent::TouchStart, acked_event().type());
   EXPECT_EQ(INPUT_EVENT_ACK_STATE_CONSUMED, acked_event_state());
 
   // ACK the moves.
   SendTouchEventAck(INPUT_EVENT_ACK_STATE_CONSUMED);
   EXPECT_EQ(1U, queued_event_count());
   EXPECT_EQ(1U, GetAndResetSentEventCount());
   EXPECT_EQ(10U, GetAndResetAckedEventCount());
-  EXPECT_EQ(WebInputEvent::TouchMove, acked_event().type);
+  EXPECT_EQ(WebInputEvent::TouchMove, acked_event().type());
 
   // ACK the release.
   SendTouchEventAck(INPUT_EVENT_ACK_STATE_CONSUMED);
   EXPECT_EQ(0U, queued_event_count());
   EXPECT_EQ(0U, GetAndResetSentEventCount());
   EXPECT_EQ(1U, GetAndResetAckedEventCount());
-  EXPECT_EQ(WebInputEvent::TouchEnd, acked_event().type);
+  EXPECT_EQ(WebInputEvent::TouchEnd, acked_event().type());
 }
 
 // Tests that an event that has already been sent but hasn't been ack'ed yet
 // doesn't get coalesced with newer events.
 TEST_F(TouchEventQueueTest, SentTouchEventDoesNotCoalesce) {
   // Send a touch-press event.
   PressTouchPoint(1, 1);
   EXPECT_EQ(1U, GetAndResetSentEventCount());
 
   // Send a few touch-move events, followed by a touch-release event. All the
@@ skipping 82 matching lines @@
 
   // The second touch should not be sent since one is already in queue.
   MoveTouchPoint(0, 5, 5);
   EXPECT_EQ(0U, GetAndResetSentEventCount());
   EXPECT_EQ(2U, queued_event_count());
 
   // Receive an ACK for the first touch-event. This should release the queued
   // touch-event, but it should not be sent to the renderer.
   SendTouchEventAck(INPUT_EVENT_ACK_STATE_NO_CONSUMER_EXISTS);
   EXPECT_EQ(0U, queued_event_count());
-  EXPECT_EQ(WebInputEvent::TouchMove, acked_event().type);
+  EXPECT_EQ(WebInputEvent::TouchMove, acked_event().type());
   EXPECT_EQ(2U, GetAndResetAckedEventCount());
   EXPECT_EQ(0U, GetAndResetSentEventCount());
 
   // Send a release event. This should not reach the renderer.
   ReleaseTouchPoint(0);
   EXPECT_EQ(0U, GetAndResetSentEventCount());
-  EXPECT_EQ(WebInputEvent::TouchEnd, acked_event().type);
+  EXPECT_EQ(WebInputEvent::TouchEnd, acked_event().type());
   EXPECT_EQ(1U, GetAndResetAckedEventCount());
 
   // Send a press-event, followed by move and release events, and another press
   // event, before the ACK for the first press event comes back. All of the
   // events should be queued first. After the NO_CONSUMER ack for the first
   // touch-press, all events upto the second touch-press should be flushed.
   PressTouchPoint(10, 10);
   EXPECT_EQ(1U, GetAndResetSentEventCount());
 
   MoveTouchPoint(0, 5, 5);
   MoveTouchPoint(0, 6, 5);
   ReleaseTouchPoint(0);
 
   PressTouchPoint(6, 5);
   EXPECT_EQ(0U, GetAndResetSentEventCount());
   // The queue should hold the first sent touch-press event, the coalesced
   // touch-move event, the touch-end event and the second touch-press event.
   EXPECT_EQ(4U, queued_event_count());
 
   SendTouchEventAck(INPUT_EVENT_ACK_STATE_NO_CONSUMER_EXISTS);
   EXPECT_EQ(1U, GetAndResetSentEventCount());
-  EXPECT_EQ(WebInputEvent::TouchEnd, acked_event().type);
+  EXPECT_EQ(WebInputEvent::TouchEnd, acked_event().type());
   EXPECT_EQ(4U, GetAndResetAckedEventCount());
   EXPECT_EQ(1U, queued_event_count());
 
   // ACK the second press event as NO_CONSUMER too.
   SendTouchEventAck(INPUT_EVENT_ACK_STATE_NO_CONSUMER_EXISTS);
   EXPECT_EQ(0U, GetAndResetSentEventCount());
-  EXPECT_EQ(WebInputEvent::TouchStart, acked_event().type);
+  EXPECT_EQ(WebInputEvent::TouchStart, acked_event().type());
   EXPECT_EQ(1U, GetAndResetAckedEventCount());
   EXPECT_EQ(0U, queued_event_count());
 
   // Send a second press event. Even though the first touch press had
   // NO_CONSUMER, this press event should reach the renderer.
   PressTouchPoint(1, 1);
   EXPECT_EQ(1U, GetAndResetSentEventCount());
   EXPECT_EQ(1U, queued_event_count());
   SendTouchEventAck(INPUT_EVENT_ACK_STATE_CONSUMED);
-  EXPECT_EQ(WebInputEvent::TouchStart, acked_event().type);
+  EXPECT_EQ(WebInputEvent::TouchStart, acked_event().type());
   EXPECT_EQ(1U, GetAndResetAckedEventCount());
 }
 
 TEST_F(TouchEventQueueTest, ConsumerIgnoreMultiFinger) {
   // Interleave three pointer press, move and release events.
   PressTouchPoint(1, 1);
   MoveTouchPoint(0, 5, 5);
   PressTouchPoint(10, 10);
   MoveTouchPoint(1, 15, 15);
   PressTouchPoint(20, 20);
@@ skipping 61 matching lines @@
   followup_event.touches[0].state = WebTouchPoint::StateMoved;
   SetFollowupEvent(followup_event);
 
   // Receive an ACK for the press. This should cause the followup touch-move to
   // be sent to the renderer.
   SendTouchEventAck(INPUT_EVENT_ACK_STATE_CONSUMED);
   EXPECT_EQ(1U, queued_event_count());
   EXPECT_EQ(1U, GetAndResetSentEventCount());
   EXPECT_EQ(1U, GetAndResetAckedEventCount());
   EXPECT_EQ(INPUT_EVENT_ACK_STATE_CONSUMED, acked_event_state());
-  EXPECT_EQ(WebInputEvent::TouchStart, acked_event().type);
+  EXPECT_EQ(WebInputEvent::TouchStart, acked_event().type());
 
   // Queue another event.
   MoveTouchPoint(0, 2, 2);
   EXPECT_EQ(2U, queued_event_count());
 
   // Receive an ACK for the touch-move followup event. This should cause the
   // subsequent touch move event be sent to the renderer.
   SendTouchEventAck(INPUT_EVENT_ACK_STATE_CONSUMED);
   EXPECT_EQ(1U, queued_event_count());
   EXPECT_EQ(1U, GetAndResetSentEventCount());
@@ skipping 58 matching lines @@
   ;
   stationary_event.touchesLength = 1;
   stationary_event.touches[0].id = 1;
   stationary_event.touches[0].state = WebTouchPoint::StateStationary;
   SendTouchEvent(stationary_event);
 
   EXPECT_EQ(1U, queued_event_count());
   EXPECT_EQ(1U, GetAndResetSentEventCount());
   EXPECT_EQ(1U, GetAndResetAckedEventCount());
   EXPECT_EQ(INPUT_EVENT_ACK_STATE_NO_CONSUMER_EXISTS, acked_event_state());
-  EXPECT_EQ(WebInputEvent::TouchMove, acked_event().type);
+  EXPECT_EQ(WebInputEvent::TouchMove, acked_event().type());
 }
 
 // Tests basic TouchEvent forwarding suppression.
 TEST_F(TouchEventQueueTest, NoTouchBasic) {
   // Disable TouchEvent forwarding.
   OnHasTouchEventHandlers(false);
   PressTouchPoint(30, 5);
   EXPECT_EQ(0U, GetAndResetSentEventCount());
   EXPECT_EQ(1U, GetAndResetAckedEventCount());
 
@@ skipping 124 matching lines @@
   // The timeout should have fired, synthetically ack'ing the timed-out event.
   // TouchEvent forwarding is disabled until the ack is received for the
   // timed-out event and the future cancel event.
   EXPECT_FALSE(IsTimeoutRunning());
   EXPECT_EQ(0U, GetAndResetSentEventCount());
   EXPECT_EQ(1U, GetAndResetAckedEventCount());
 
   // Ack'ing the original event should trigger a cancel event.
   SendTouchEventAck(INPUT_EVENT_ACK_STATE_NOT_CONSUMED);
   EXPECT_FALSE(IsTimeoutRunning());
-  EXPECT_EQ(WebInputEvent::TouchCancel, sent_event().type);
+  EXPECT_EQ(WebInputEvent::TouchCancel, sent_event().type());
   EXPECT_NE(WebInputEvent::Blocking, sent_event().dispatchType);
   EXPECT_EQ(0U, GetAndResetAckedEventCount());
   EXPECT_EQ(1U, GetAndResetSentEventCount());
 
   // Touch events should not be forwarded until we receive the cancel acks.
   MoveTouchPoint(0, 1, 1);
   ASSERT_EQ(0U, GetAndResetSentEventCount());
   ASSERT_EQ(1U, GetAndResetAckedEventCount());
 
   ReleaseTouchPoint(0);
   ASSERT_EQ(0U, GetAndResetSentEventCount());
   ASSERT_EQ(1U, GetAndResetAckedEventCount());
 
   // The synthetic TouchCancel ack should not reach the client, but should
   // resume touch forwarding.
   SendTouchEventAck(INPUT_EVENT_ACK_STATE_NOT_CONSUMED);
   EXPECT_EQ(0U, GetAndResetSentEventCount());
   EXPECT_EQ(0U, GetAndResetAckedEventCount());
 
   // Subsequent events should be handled normally.
   PressTouchPoint(0, 1);
-  EXPECT_EQ(WebInputEvent::TouchStart, sent_event().type);
+  EXPECT_EQ(WebInputEvent::TouchStart, sent_event().type());
   EXPECT_EQ(WebInputEvent::Blocking, sent_event().dispatchType);
   EXPECT_EQ(1U, GetAndResetSentEventCount());
   EXPECT_EQ(0U, GetAndResetAckedEventCount());
 }
 
 // Tests that the timeout is never started if the renderer consumes
 // a TouchEvent from the current touch sequence.
 TEST_F(TouchEventQueueTest, NoTouchTimeoutIfRendererIsConsumingGesture) {
   SetUpForTimeoutTesting();
 
@@ skipping 559 matching lines @@
   EXPECT_EQ(1U, GetAndResetAckedEventCount());
 
   // Queuing the final touchend should flush the pending async touchmove. In
   // this case, we will first dispatch an async touchmove and then a touchend.
   // For the async touchmove, we will not send ack again.
   ReleaseTouchPoint(0);
   followup_scroll.setType(WebInputEvent::GestureScrollEnd);
   SetFollowupEvent(followup_scroll);
   EXPECT_FALSE(HasPendingAsyncTouchMove());
   EXPECT_EQ(2U, all_sent_events().size());
-  EXPECT_EQ(WebInputEvent::TouchMove, all_sent_events()[0].type);
+  EXPECT_EQ(WebInputEvent::TouchMove, all_sent_events()[0].type());
   EXPECT_NE(WebInputEvent::Blocking, all_sent_events()[0].dispatchType);
-  EXPECT_EQ(WebInputEvent::TouchEnd, all_sent_events()[1].type);
+  EXPECT_EQ(WebInputEvent::TouchEnd, all_sent_events()[1].type());
   EXPECT_NE(WebInputEvent::Blocking, all_sent_events()[1].dispatchType);
   EXPECT_EQ(2U, GetAndResetSentEventCount());
   EXPECT_EQ(0U, GetAndResetAckedEventCount());
   EXPECT_EQ(1U, queued_event_count());
 
   // Ack the touchend.
   SendTouchEventAck(INPUT_EVENT_ACK_STATE_NOT_CONSUMED);
   SendTouchEventAck(INPUT_EVENT_ACK_STATE_NOT_CONSUMED);
   EXPECT_EQ(0U, queued_event_count());
   EXPECT_EQ(0U, GetAndResetSentEventCount());
@@ skipping 56 matching lines @@
   // this case, we will first dispatch an async touchmove and then a
   // touchstart. For the async touchmove, we will not send ack again.
   MoveTouchPoint(0, 0, 25);
   EXPECT_TRUE(HasPendingAsyncTouchMove());
   EXPECT_EQ(0U, queued_event_count());
   EXPECT_EQ(0U, GetAndResetSentEventCount());
   EXPECT_EQ(1U, GetAndResetAckedEventCount());
   PressTouchPoint(30, 30);
   EXPECT_FALSE(HasPendingAsyncTouchMove());
   EXPECT_EQ(2U, all_sent_events().size());
-  EXPECT_EQ(WebInputEvent::TouchMove, all_sent_events()[0].type);
+  EXPECT_EQ(WebInputEvent::TouchMove, all_sent_events()[0].type());
   EXPECT_NE(WebInputEvent::Blocking, all_sent_events()[0].dispatchType);
-  EXPECT_EQ(WebInputEvent::TouchStart, all_sent_events()[1].type);
+  EXPECT_EQ(WebInputEvent::TouchStart, all_sent_events()[1].type());
   EXPECT_EQ(WebInputEvent::Blocking, all_sent_events()[1].dispatchType);
   EXPECT_EQ(2U, GetAndResetSentEventCount());
   EXPECT_EQ(0U, GetAndResetAckedEventCount());
   EXPECT_EQ(1U, queued_event_count());
 
   // Ack the touchstart.
   SendTouchEventAck(INPUT_EVENT_ACK_STATE_NOT_CONSUMED);
   SendTouchEventAck(INPUT_EVENT_ACK_STATE_NOT_CONSUMED);
   EXPECT_EQ(0U, queued_event_count());
   EXPECT_EQ(0U, GetAndResetSentEventCount());
   EXPECT_EQ(1U, GetAndResetAckedEventCount());
 
   // Send a secondary touchmove.
   MoveTouchPoint(1, 0, 25);
   EXPECT_TRUE(HasPendingAsyncTouchMove());
   EXPECT_EQ(0U, queued_event_count());
   EXPECT_EQ(0U, GetAndResetSentEventCount());
   EXPECT_EQ(1U, GetAndResetAckedEventCount());
 
   // An unconsumed scroll should resume synchronous touch handling.
   SendGestureEventAck(WebInputEvent::GestureScrollUpdate,
                       INPUT_EVENT_ACK_STATE_NOT_CONSUMED);
 
   // The pending touchmove should be coalesced with the next (now synchronous)
   // touchmove.
   MoveTouchPoint(0, 0, 26);
   EXPECT_EQ(WebInputEvent::Blocking, sent_event().dispatchType);
   EXPECT_FALSE(HasPendingAsyncTouchMove());
-  EXPECT_EQ(WebInputEvent::TouchMove, sent_event().type);
+  EXPECT_EQ(WebInputEvent::TouchMove, sent_event().type());
   EXPECT_EQ(WebTouchPoint::StateMoved, sent_event().touches[0].state);
   EXPECT_EQ(WebTouchPoint::StateMoved, sent_event().touches[1].state);
   EXPECT_EQ(1U, queued_event_count());
   EXPECT_EQ(1U, GetAndResetSentEventCount());
   EXPECT_EQ(0U, GetAndResetAckedEventCount());
 
   // Subsequent touches will queue until the preceding, synchronous touches are
   // ack'ed.
   ReleaseTouchPoint(1);
   EXPECT_EQ(2U, queued_event_count());
   ReleaseTouchPoint(0);
   EXPECT_EQ(3U, queued_event_count());
   SendTouchEventAck(INPUT_EVENT_ACK_STATE_NOT_CONSUMED);
   EXPECT_EQ(WebInputEvent::Blocking, sent_event().dispatchType);
-  EXPECT_EQ(WebInputEvent::TouchEnd, sent_event().type);
+  EXPECT_EQ(WebInputEvent::TouchEnd, sent_event().type());
   EXPECT_EQ(2U, queued_event_count());
   EXPECT_EQ(1U, GetAndResetSentEventCount());
   EXPECT_EQ(1U, GetAndResetAckedEventCount());
 
   SendTouchEventAck(INPUT_EVENT_ACK_STATE_NOT_CONSUMED);
   EXPECT_EQ(WebInputEvent::Blocking, sent_event().dispatchType);
-  EXPECT_EQ(WebInputEvent::TouchEnd, sent_event().type);
+  EXPECT_EQ(WebInputEvent::TouchEnd, sent_event().type());
   EXPECT_EQ(1U, queued_event_count());
   EXPECT_EQ(1U, GetAndResetSentEventCount());
   EXPECT_EQ(1U, GetAndResetAckedEventCount());
 
   SendTouchEventAck(INPUT_EVENT_ACK_STATE_NOT_CONSUMED);
   EXPECT_EQ(0U, queued_event_count());
   EXPECT_EQ(0U, GetAndResetSentEventCount());
   EXPECT_EQ(1U, GetAndResetAckedEventCount());
 }
 
@@ skipping 34 matching lines @@
   EXPECT_EQ(0U, queued_event_count());
   EXPECT_EQ(0U, GetAndResetSentEventCount());
   EXPECT_EQ(1U, GetAndResetAckedEventCount());
 
   // Queuing the final touchend should flush the pending, async touchmove. In
   // this case, we will first dispatch an async touchmove and then a touchend.
   // For the async touchmove, we will not send ack again.
   ReleaseTouchPoint(0);
   EXPECT_FALSE(HasPendingAsyncTouchMove());
   EXPECT_EQ(2U, all_sent_events().size());
-  EXPECT_EQ(WebInputEvent::TouchMove, all_sent_events()[0].type);
+  EXPECT_EQ(WebInputEvent::TouchMove, all_sent_events()[0].type());
   EXPECT_NE(WebInputEvent::Blocking, all_sent_events()[0].dispatchType);
   EXPECT_EQ(0, all_sent_events()[0].touches[0].position.x);
   EXPECT_EQ(0, all_sent_events()[0].touches[0].position.y);
-  EXPECT_EQ(WebInputEvent::TouchEnd, all_sent_events()[1].type);
+  EXPECT_EQ(WebInputEvent::TouchEnd, all_sent_events()[1].type());
   EXPECT_NE(WebInputEvent::Blocking, all_sent_events()[1].dispatchType);
   EXPECT_EQ(2U, GetAndResetSentEventCount());
   EXPECT_EQ(0U, GetAndResetAckedEventCount());
 }
 
 // Ensure that async touch dispatch and touch ack timeout interactions work
 // appropriately.
 TEST_F(TouchEventQueueTest, AsyncTouchWithAckTimeout) {
   SetUpForTimeoutTesting();
 
@@ skipping 100 matching lines @@
   // the queued touchcancel should be flushed.
   WebTouchEvent followup_cancel(WebInputEvent::TouchCancel,
                                 WebInputEvent::NoModifiers,
                                 WebInputEvent::TimeStampForTesting);
   followup_cancel.touchesLength = 1;
   followup_cancel.touches[0].state = WebTouchPoint::StateCancelled;
   SetFollowupEvent(followup_cancel);
   MoveTouchPoint(0, 5, 5);
   EXPECT_EQ(1U, queued_event_count());
   EXPECT_EQ(2U, all_sent_events().size());
-  EXPECT_EQ(WebInputEvent::TouchMove, all_sent_events()[0].type);
+  EXPECT_EQ(WebInputEvent::TouchMove, all_sent_events()[0].type());
   EXPECT_NE(WebInputEvent::Blocking, all_sent_events()[0].dispatchType);
-  EXPECT_EQ(WebInputEvent::TouchCancel, all_sent_events()[1].type);
+  EXPECT_EQ(WebInputEvent::TouchCancel, all_sent_events()[1].type());
   EXPECT_NE(WebInputEvent::Blocking, all_sent_events()[1].dispatchType);
   EXPECT_EQ(2U, GetAndResetSentEventCount());
   // Sending the ack is because the async touchmove is not ready for
   // dispatching send the ack immediately.
   EXPECT_EQ(1U, GetAndResetAckedEventCount());
-  EXPECT_EQ(WebInputEvent::TouchMove, acked_event().type);
+  EXPECT_EQ(WebInputEvent::TouchMove, acked_event().type());
 
   SendTouchEventAck(INPUT_EVENT_ACK_STATE_NOT_CONSUMED);
   SendTouchEventAck(INPUT_EVENT_ACK_STATE_NOT_CONSUMED);
   EXPECT_EQ(0U, queued_event_count());
-  EXPECT_EQ(WebInputEvent::TouchCancel, acked_event().type);
+  EXPECT_EQ(WebInputEvent::TouchCancel, acked_event().type());
   EXPECT_EQ(1U, GetAndResetAckedEventCount());
   EXPECT_EQ(0U, GetAndResetSentEventCount());
 }
 
 // Ensure that the async touch is fully reset if the touch sequence restarts
 // without properly terminating.
 TEST_F(TouchEventQueueTest, AsyncTouchWithHardTouchStartReset) {
   PressTouchPoint(0, 0);
   EXPECT_EQ(1U, GetAndResetSentEventCount());
   SendTouchEventAck(INPUT_EVENT_ACK_STATE_NOT_CONSUMED);
   EXPECT_EQ(1U, GetAndResetAckedEventCount());
 
   // Trigger async touchmove dispatch.
   MoveTouchPoint(0, 1, 1);
   EXPECT_EQ(1U, GetAndResetSentEventCount());
   WebGestureEvent followup_scroll(WebInputEvent::GestureScrollBegin,
                                   WebInputEvent::NoModifiers,
                                   WebInputEvent::TimeStampForTesting);
   SetFollowupEvent(followup_scroll);
   SendTouchEventAck(INPUT_EVENT_ACK_STATE_NOT_CONSUMED);
   EXPECT_EQ(1U, GetAndResetAckedEventCount());
   EXPECT_EQ(0U, queued_event_count());
   SendGestureEvent(WebInputEvent::GestureScrollUpdate);
 
   // The async touchmove should be immediately ack'ed but delivery is deferred.
   MoveTouchPoint(0, 2, 2);
   EXPECT_EQ(0U, GetAndResetSentEventCount());
   EXPECT_EQ(1U, GetAndResetAckedEventCount());
   EXPECT_EQ(0U, queued_event_count());
-  EXPECT_EQ(WebInputEvent::TouchMove, acked_event().type);
+  EXPECT_EQ(WebInputEvent::TouchMove, acked_event().type());
 
   // The queue should be robust to hard touch restarts with a new touch
   // sequence. In this case, the deferred async touch should not be flushed
   // by the new touch sequence.
   SendGestureEvent(WebInputEvent::GestureScrollEnd);
   ResetTouchEvent();
 
   PressTouchPoint(0, 0);
-  EXPECT_EQ(WebInputEvent::TouchStart, sent_event().type);
+  EXPECT_EQ(WebInputEvent::TouchStart, sent_event().type());
   EXPECT_EQ(1U, GetAndResetSentEventCount());
   SendTouchEventAck(INPUT_EVENT_ACK_STATE_NOT_CONSUMED);
   EXPECT_EQ(1U, GetAndResetAckedEventCount());
 }
 
 // Ensure that even when the interval expires, we still need to wait for the
 // ack sent back from render to send the next async touchmove once the scroll
 // starts.
 TEST_F(TouchEventQueueTest, SendNextThrottledAsyncTouchMoveAfterAck) {
   // Process a TouchStart
@@ skipping 101 matching lines @@
   MoveTouchPoint(0, 0, 50);
   EXPECT_TRUE(HasPendingAsyncTouchMove());
   EXPECT_EQ(0U, queued_event_count());
   EXPECT_EQ(0U, GetAndResetSentEventCount());
   EXPECT_EQ(1U, GetAndResetAckedEventCount());
 
   // Dispatch the touch move when sufficient time has passed.
   AdvanceTouchTime(kMinSecondsBetweenThrottledTouchmoves + 0.1);
   MoveTouchPoint(0, 0, 50);
   EXPECT_FALSE(HasPendingAsyncTouchMove());
-  EXPECT_EQ(WebInputEvent::TouchMove, sent_event().type);
+  EXPECT_EQ(WebInputEvent::TouchMove, sent_event().type());
   EXPECT_NE(WebInputEvent::Blocking, sent_event().dispatchType);
   EXPECT_EQ(0U, queued_event_count());
   EXPECT_EQ(1U, GetAndResetSentEventCount());
   EXPECT_EQ(1U, GetAndResetAckedEventCount());
   EXPECT_EQ(1U, uncancelable_touch_moves_pending_ack_count());
 }
 
 TEST_F(TouchEventQueueTest, AsyncTouchFlushedByNonTouchMove) {
   // Process a TouchStart
   PressTouchPoint(0, 1);
@@ skipping 41 matching lines @@
     EXPECT_EQ(1U, GetAndResetAckedEventCount());
     EXPECT_EQ(static_cast<size_t>(i + 1),
               uncancelable_touch_moves_pending_ack_count());
 
     // Send touchstart will flush pending_async_touch_move_, and increase the
     // count. In this case, we will first dispatch an async touchmove and
     // then a touchstart. For the async touchmove, we will not send ack again.
     PressTouchPoint(30, 30);
     EXPECT_FALSE(HasPendingAsyncTouchMove());
     EXPECT_EQ(2U, all_sent_events().size());
-    EXPECT_EQ(WebInputEvent::TouchMove, all_sent_events()[0].type);
+    EXPECT_EQ(WebInputEvent::TouchMove, all_sent_events()[0].type());
     EXPECT_NE(WebInputEvent::Blocking, all_sent_events()[0].dispatchType);
     EXPECT_EQ(10 + 10 * i, all_sent_events()[0].touches[0].position.x);
     EXPECT_EQ(10 + 10 * i, all_sent_events()[0].touches[0].position.y);
     EXPECT_EQ(static_cast<size_t>(i + 2),
               uncancelable_touch_moves_pending_ack_count());
-    EXPECT_EQ(WebInputEvent::TouchStart, all_sent_events()[1].type);
+    EXPECT_EQ(WebInputEvent::TouchStart, all_sent_events()[1].type());
     EXPECT_EQ(WebInputEvent::Blocking, all_sent_events()[1].dispatchType);
     EXPECT_EQ(2U, GetAndResetSentEventCount());
     EXPECT_EQ(0U, GetAndResetAckedEventCount());
 
     SendTouchEventAckWithID(INPUT_EVENT_ACK_STATE_NOT_CONSUMED,
                             GetUniqueTouchEventID());
     EXPECT_EQ(0U, queued_event_count());
     EXPECT_FALSE(HasPendingAsyncTouchMove());
     EXPECT_EQ(0U, GetAndResetSentEventCount());
     EXPECT_EQ(1U, GetAndResetAckedEventCount());
@@ skipping 25 matching lines @@
   EXPECT_TRUE(HasPendingAsyncTouchMove());
 
   SendTouchEventAck(INPUT_EVENT_ACK_STATE_NOT_CONSUMED);
 
   // When we receive this ack from render, and the count is 0, so we can
   // dispatch the pending_async_touchmove_.
   SendTouchEventAck(INPUT_EVENT_ACK_STATE_NOT_CONSUMED);
   EXPECT_EQ(1U, uncancelable_touch_moves_pending_ack_count());
   EXPECT_FALSE(HasPendingAsyncTouchMove());
   EXPECT_EQ(0U, queued_event_count());
-  EXPECT_EQ(WebInputEvent::TouchMove, sent_event().type);
+  EXPECT_EQ(WebInputEvent::TouchMove, sent_event().type());
   EXPECT_NE(WebInputEvent::Blocking, sent_event().dispatchType);
   EXPECT_EQ(1U, GetAndResetSentEventCount());
   EXPECT_EQ(0U, GetAndResetAckedEventCount());
 }
 
 // Ensure that even when we receive the ack from render, we still need to wait
 // for the interval expires to send the next async touchmove once the scroll
 // starts.
 TEST_F(TouchEventQueueTest, DoNotIncreaseIfClientConsumeAsyncTouchMove) {
   // Process a TouchStart
@@ skipping 42 matching lines @@
   EXPECT_EQ(0U, GetAndResetSentEventCount());
   EXPECT_EQ(1U, GetAndResetAckedEventCount());
 
   // Dispatch the touch move when sufficient time has passed. Becasue the event
   // is consumed by client already, we would not increase the count and ack to
   // client again.
   AdvanceTouchTime(kMinSecondsBetweenThrottledTouchmoves + 0.1);
   SetSyncAckResult(INPUT_EVENT_ACK_STATE_CONSUMED);
   MoveTouchPoint(0, 0, 50);
   EXPECT_FALSE(HasPendingAsyncTouchMove());
-  EXPECT_EQ(WebInputEvent::TouchMove, sent_event().type);
+  EXPECT_EQ(WebInputEvent::TouchMove, sent_event().type());
   EXPECT_NE(WebInputEvent::Blocking, sent_event().dispatchType);
   EXPECT_EQ(0U, queued_event_count());
   EXPECT_EQ(1U, GetAndResetSentEventCount());
   EXPECT_EQ(1U, GetAndResetAckedEventCount());
   EXPECT_EQ(0U, uncancelable_touch_moves_pending_ack_count());
 }
 
 TEST_F(TouchEventQueueTest, TouchAbsorptionWithConsumedFirstMove) {
   // Queue a TouchStart.
   PressTouchPoint(0, 1);
@@ skipping 140 matching lines @@
   EXPECT_EQ(1U, GetAndResetSentEventCount());
 
   // Receive ACK for the first three touch-events.
   SendTouchEventAck(INPUT_EVENT_ACK_STATE_CONSUMED);
   SendTouchEventAck(INPUT_EVENT_ACK_STATE_CONSUMED);
   SendTouchEventAck(INPUT_EVENT_ACK_STATE_CONSUMED);
   EXPECT_EQ(1U, queued_event_count());
 
   // Test current touches state before sending TouchMoves.
   const WebTouchEvent& event1 = sent_event();
-  EXPECT_EQ(WebInputEvent::TouchStart, event1.type);
+  EXPECT_EQ(WebInputEvent::TouchStart, event1.type());
   EXPECT_EQ(WebTouchPoint::StateStationary, event1.touches[0].state);
   EXPECT_EQ(WebTouchPoint::StateStationary, event1.touches[1].state);
   EXPECT_EQ(WebTouchPoint::StateStationary, event1.touches[2].state);
   EXPECT_EQ(WebTouchPoint::StatePressed, event1.touches[3].state);
 
   // Move x-position for 1st touch, y-position for 2nd touch
   // and do not move other touches.
   MoveTouchPoints(0, 1.1f, 1.f, 1, 2.f, 20.001f);
   MoveTouchPoints(2, 3.f, 3.f, 3, 4.f, 4.f);
   EXPECT_EQ(2U, queued_event_count());
 
   // Receive an ACK for the last TouchPress event.
   SendTouchEventAck(INPUT_EVENT_ACK_STATE_CONSUMED);
 
   // 1st TouchMove is sent. Test for touches state.
   const WebTouchEvent& event2 = sent_event();
-  EXPECT_EQ(WebInputEvent::TouchMove, event2.type);
+  EXPECT_EQ(WebInputEvent::TouchMove, event2.type());
   EXPECT_EQ(WebTouchPoint::StateMoved, event2.touches[0].state);
   EXPECT_EQ(WebTouchPoint::StateMoved, event2.touches[1].state);
   EXPECT_EQ(WebTouchPoint::StateStationary, event2.touches[2].state);
   EXPECT_EQ(WebTouchPoint::StateStationary, event2.touches[3].state);
 
   // Move only 4th touch but not others.
   MoveTouchPoints(0, 1.1f, 1.f, 1, 2.f, 20.001f);
   MoveTouchPoints(2, 3.f, 3.f, 3, 4.1f, 4.1f);
 
   // Receive an ACK for previous (1st) TouchMove.
   SendTouchEventAck(INPUT_EVENT_ACK_STATE_CONSUMED);
 
   // 2nd TouchMove is sent. Test for touches state.
   const WebTouchEvent& event3 = sent_event();
-  EXPECT_EQ(WebInputEvent::TouchMove, event3.type);
+  EXPECT_EQ(WebInputEvent::TouchMove, event3.type());
   EXPECT_EQ(WebTouchPoint::StateStationary, event3.touches[0].state);
   EXPECT_EQ(WebTouchPoint::StateStationary, event3.touches[1].state);
   EXPECT_EQ(WebTouchPoint::StateStationary, event3.touches[2].state);
   EXPECT_EQ(WebTouchPoint::StateMoved, event3.touches[3].state);
 }
 
 // Tests that touch point state is correct in TouchMove events
 // when point properties other than position changed.
 TEST_F(TouchEventQueueTest, PointerStatesWhenOtherThanPositionChanged) {
   PressTouchPoint(1, 1);
   SendTouchEventAck(INPUT_EVENT_ACK_STATE_CONSUMED);
 
   // Default initial radiusX/Y is (1.f, 1.f).
   // Default initial rotationAngle is 1.f.
   // Default initial force is 1.f.
 
   // Change touch point radius only.
   ChangeTouchPointRadius(0, 1.5f, 1.f);
   SendTouchEventAck(INPUT_EVENT_ACK_STATE_CONSUMED);
 
   // TouchMove is sent. Test for pointer state.
   const WebTouchEvent& event1 = sent_event();
-  EXPECT_EQ(WebInputEvent::TouchMove, event1.type);
+  EXPECT_EQ(WebInputEvent::TouchMove, event1.type());
   EXPECT_EQ(WebTouchPoint::StateMoved, event1.touches[0].state);
 
   // Change touch point force.
   ChangeTouchPointForce(0, 0.9f);
   SendTouchEventAck(INPUT_EVENT_ACK_STATE_CONSUMED);
 
   // TouchMove is sent. Test for pointer state.
   const WebTouchEvent& event2 = sent_event();
-  EXPECT_EQ(WebInputEvent::TouchMove, event2.type);
+  EXPECT_EQ(WebInputEvent::TouchMove, event2.type());
   EXPECT_EQ(WebTouchPoint::StateMoved, event2.touches[0].state);
 
   // Change touch point rotationAngle.
   ChangeTouchPointRotationAngle(0, 1.1f);
   SendTouchEventAck(INPUT_EVENT_ACK_STATE_CONSUMED);
 
   // TouchMove is sent. Test for pointer state.
   const WebTouchEvent& event3 = sent_event();
-  EXPECT_EQ(WebInputEvent::TouchMove, event3.type);
+  EXPECT_EQ(WebInputEvent::TouchMove, event3.type());
   EXPECT_EQ(WebTouchPoint::StateMoved, event3.touches[0].state);
 
   EXPECT_EQ(0U, queued_event_count());
   EXPECT_EQ(4U, GetAndResetSentEventCount());
   EXPECT_EQ(4U, GetAndResetAckedEventCount());
 }
 
 // Tests that TouchMoves are filtered when none of the points are changed.
 TEST_F(TouchEventQueueTest, FilterTouchMovesWhenNoPointerChanged) {
   PressTouchPoint(1, 1);
   PressTouchPoint(2, 2);
   SendTouchEventAck(INPUT_EVENT_ACK_STATE_CONSUMED);
   SendTouchEventAck(INPUT_EVENT_ACK_STATE_CONSUMED);
   EXPECT_EQ(0U, queued_event_count());
   EXPECT_EQ(2U, GetAndResetSentEventCount());
   EXPECT_EQ(2U, GetAndResetAckedEventCount());
 
   // Move 1st touch point.
   MoveTouchPoint(0, 10, 10);
   EXPECT_EQ(1U, queued_event_count());
 
   // TouchMove should be allowed and test for touches state.
   const WebTouchEvent& event1 = sent_event();
-  EXPECT_EQ(WebInputEvent::TouchMove, event1.type);
+  EXPECT_EQ(WebInputEvent::TouchMove, event1.type());
   EXPECT_EQ(WebTouchPoint::StateMoved, event1.touches[0].state);
   EXPECT_EQ(WebTouchPoint::StateStationary, event1.touches[1].state);
   EXPECT_EQ(1U, GetAndResetSentEventCount());
   EXPECT_EQ(0U, GetAndResetAckedEventCount());
 
   // Do not really move any touch points, but use previous values.
   MoveTouchPoint(0, 10, 10);
   ChangeTouchPointRadius(1, 1, 1);
   MoveTouchPoint(1, 2, 2);
   EXPECT_EQ(2U, queued_event_count());
   EXPECT_EQ(0U, GetAndResetSentEventCount());
 
   // Receive an ACK for 1st TouchMove.
   SendTouchEventAck(INPUT_EVENT_ACK_STATE_CONSUMED);
 
   // Tries to forward TouchMove but should be filtered
   // when none of the touch points have changed.
   EXPECT_EQ(0U, queued_event_count());
   EXPECT_EQ(0U, GetAndResetSentEventCount());
   EXPECT_EQ(4U, GetAndResetAckedEventCount());
   EXPECT_EQ(INPUT_EVENT_ACK_STATE_NO_CONSUMER_EXISTS, acked_event_state());
 
   // Move 2nd touch point.
   MoveTouchPoint(1, 3, 3);
   SendTouchEventAck(INPUT_EVENT_ACK_STATE_CONSUMED);
   EXPECT_EQ(0U, queued_event_count());
 
   // TouchMove should be allowed and test for touches state.
   const WebTouchEvent& event2 = sent_event();
-  EXPECT_EQ(WebInputEvent::TouchMove, event2.type);
+  EXPECT_EQ(WebInputEvent::TouchMove, event2.type());
   EXPECT_EQ(WebTouchPoint::StateStationary, event2.touches[0].state);
   EXPECT_EQ(WebTouchPoint::StateMoved, event2.touches[1].state);
   EXPECT_EQ(1U, GetAndResetSentEventCount());
   EXPECT_EQ(1U, GetAndResetAckedEventCount());
 }
 
 // Tests that touch-scroll-notification is not pushed into an empty queue.
 TEST_F(TouchEventQueueTest, TouchScrollNotificationOrder_EmptyQueue) {
   PrependTouchScrollNotification();
 
@@ skipping 13 matching lines @@
   // Send the touch-scroll-notification when 3 events are in the queue.
   PrependTouchScrollNotification();
 
   EXPECT_EQ(0U, GetAndResetAckedEventCount());
   EXPECT_EQ(2U, queued_event_count());
 
   // Receive an ACK for the touchstart.
   SendTouchEventAck(INPUT_EVENT_ACK_STATE_CONSUMED);
 
   EXPECT_EQ(1U, GetAndResetAckedEventCount());
-  EXPECT_EQ(WebInputEvent::TouchStart, acked_event().type);
+  EXPECT_EQ(WebInputEvent::TouchStart, acked_event().type());
   EXPECT_EQ(1U, queued_event_count());
 
   // Receive an ACK for the touch-scroll-notification.
   SendTouchEventAck(INPUT_EVENT_ACK_STATE_IGNORED);
 
   EXPECT_EQ(0U, GetAndResetAckedEventCount());
   EXPECT_EQ(0U, queued_event_count());
 
-  EXPECT_EQ(WebInputEvent::TouchStart, all_sent_events()[0].type);
-  EXPECT_EQ(WebInputEvent::TouchScrollStarted, all_sent_events()[1].type);
+  EXPECT_EQ(WebInputEvent::TouchStart, all_sent_events()[0].type());
+  EXPECT_EQ(WebInputEvent::TouchScrollStarted, all_sent_events()[1].type());
   EXPECT_EQ(2U, GetAndResetSentEventCount());
 }
 
 // Tests touch-scroll-notification firing order when the event is placed in the
 // 2nd position in the touch queue between two events.
 TEST_F(TouchEventQueueTest, TouchScrollNotificationOrder_SecondPosition) {
   PressTouchPoint(1, 1);
   MoveTouchPoint(0, 5, 5);
   ReleaseTouchPoint(0);
 
   EXPECT_EQ(0U, GetAndResetAckedEventCount());
   EXPECT_EQ(3U, queued_event_count());
 
   // Send the touch-scroll-notification when 3 events are in the queue.
   PrependTouchScrollNotification();
 
   EXPECT_EQ(0U, GetAndResetAckedEventCount());
   EXPECT_EQ(4U, queued_event_count());
 
   // Receive an ACK for the touchstart.
   SendTouchEventAck(INPUT_EVENT_ACK_STATE_CONSUMED);
 
   EXPECT_EQ(1U, GetAndResetAckedEventCount());
-  EXPECT_EQ(WebInputEvent::TouchStart, acked_event().type);
+  EXPECT_EQ(WebInputEvent::TouchStart, acked_event().type());
   EXPECT_EQ(3U, queued_event_count());
 
   // Receive an ACK for the touch-scroll-notification.
   SendTouchEventAck(INPUT_EVENT_ACK_STATE_IGNORED);
 
   EXPECT_EQ(0U, GetAndResetAckedEventCount());
   EXPECT_EQ(2U, queued_event_count());
 
   // Receive an ACK for the touchmove.
   SendTouchEventAck(INPUT_EVENT_ACK_STATE_CONSUMED);
 
   EXPECT_EQ(1U, GetAndResetAckedEventCount());
-  EXPECT_EQ(WebInputEvent::TouchMove, acked_event().type);
+  EXPECT_EQ(WebInputEvent::TouchMove, acked_event().type());
   EXPECT_EQ(1U, queued_event_count());
 
   // Receive an ACK for the touchend.
   SendTouchEventAck(INPUT_EVENT_ACK_STATE_CONSUMED);
 
   EXPECT_EQ(1U, GetAndResetAckedEventCount());
-  EXPECT_EQ(WebInputEvent::TouchEnd, acked_event().type);
+  EXPECT_EQ(WebInputEvent::TouchEnd, acked_event().type());
   EXPECT_EQ(0U, queued_event_count());
 
-  EXPECT_EQ(WebInputEvent::TouchStart, all_sent_events()[0].type);
-  EXPECT_EQ(WebInputEvent::TouchScrollStarted, all_sent_events()[1].type);
-  EXPECT_EQ(WebInputEvent::TouchMove, all_sent_events()[2].type);
-  EXPECT_EQ(WebInputEvent::TouchEnd, all_sent_events()[3].type);
+  EXPECT_EQ(WebInputEvent::TouchStart, all_sent_events()[0].type());
+  EXPECT_EQ(WebInputEvent::TouchScrollStarted, all_sent_events()[1].type());
+  EXPECT_EQ(WebInputEvent::TouchMove, all_sent_events()[2].type());
+  EXPECT_EQ(WebInputEvent::TouchEnd, all_sent_events()[3].type());
   EXPECT_EQ(4U, GetAndResetSentEventCount());
 }
 
 // Tests that if touchStartOrFirstTouchMove is correctly set up for touch
 // events.
 TEST_F(TouchEventQueueTest, TouchStartOrFirstTouchMove) {
   PressTouchPoint(1, 1);
   SendTouchEventAck(INPUT_EVENT_ACK_STATE_CONSUMED);
-  EXPECT_EQ(WebInputEvent::TouchStart, sent_event().type);
+  EXPECT_EQ(WebInputEvent::TouchStart, sent_event().type());
   EXPECT_TRUE(sent_event().touchStartOrFirstTouchMove);
 
   MoveTouchPoint(0, 5, 5);
   SendTouchEventAck(INPUT_EVENT_ACK_STATE_CONSUMED);
-  EXPECT_EQ(WebInputEvent::TouchMove, sent_event().type);
+  EXPECT_EQ(WebInputEvent::TouchMove, sent_event().type());
   EXPECT_TRUE(sent_event().touchStartOrFirstTouchMove);
 
   MoveTouchPoint(0, 15, 15);
   SendTouchEventAck(INPUT_EVENT_ACK_STATE_CONSUMED);
-  EXPECT_EQ(WebInputEvent::TouchMove, sent_event().type);
+  EXPECT_EQ(WebInputEvent::TouchMove, sent_event().type());
   EXPECT_FALSE(sent_event().touchStartOrFirstTouchMove);
 
   ReleaseTouchPoint(0);
   SendTouchEventAck(INPUT_EVENT_ACK_STATE_CONSUMED);
-  EXPECT_EQ(WebInputEvent::TouchEnd, sent_event().type);
+  EXPECT_EQ(WebInputEvent::TouchEnd, sent_event().type());
   EXPECT_FALSE(sent_event().touchStartOrFirstTouchMove);
 }
 
 }  // namespace content