Add constructors to WebInputEvents and setters so we can work at cleaning up these public structs.

ui/events/blink/input_handler_proxy_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 "ui/events/blink/input_handler_proxy.h"
 
 #include <memory>
 
 #include "base/bind.h"
 #include "base/macros.h"
@@ skipping 76 matching lines @@
 MATCHER_P(WheelEventsMatch, expected, "") {
   return WheelEventsMatch(arg, expected);
 }
 
 WebGestureEvent CreateFling(base::TimeTicks timestamp,
                             WebGestureDevice source_device,
                             WebFloatPoint velocity,
                             WebPoint point,
                             WebPoint global_point,
                             int modifiers) {
-  WebGestureEvent fling;
-  fling.type = WebInputEvent::GestureFlingStart;
+  WebGestureEvent fling(WebInputEvent::GestureFlingStart, modifiers,
+                        (timestamp - base::TimeTicks()).InSecondsF());
   fling.sourceDevice = source_device;
-  fling.timeStampSeconds = (timestamp - base::TimeTicks()).InSecondsF();
   fling.data.flingStart.velocityX = velocity.x;
   fling.data.flingStart.velocityY = velocity.y;
   fling.x = point.x;
   fling.y = point.y;
   fling.globalX = global_point.x;
   fling.globalY = global_point.y;
-  fling.modifiers = modifiers;
   return fling;
 }
 
 WebGestureEvent CreateFling(WebGestureDevice source_device,
                             WebFloatPoint velocity,
                             WebPoint point,
                             WebPoint global_point,
                             int modifiers) {
   return CreateFling(base::TimeTicks(),
                      source_device,
                      velocity,
                      point,
                      global_point,
                      modifiers);
 }
 
 ScopedWebInputEvent CreateGestureScrollOrPinch(WebInputEvent::Type type,
                                                float deltaYOrScale = 0,
                                                int x = 0,
                                                int y = 0) {
-  WebGestureEvent gesture;
+  WebGestureEvent gesture(type, WebInputEvent::NoModifiers,
+                          WebInputEvent::TimeStampForTesting);
   gesture.sourceDevice = blink::WebGestureDeviceTouchpad;
-  gesture.type = type;
   if (type == WebInputEvent::GestureScrollUpdate) {
     gesture.data.scrollUpdate.deltaY = deltaYOrScale;
   } else if (type == WebInputEvent::GesturePinchUpdate) {
     gesture.data.pinchUpdate.scale = deltaYOrScale;
     gesture.x = x;
     gesture.y = y;
   }
   return WebInputEventTraits::Clone(gesture);
 }
 
@@ skipping 275 matching lines @@
 
   void StartFling(base::TimeTicks timestamp,
                   WebGestureDevice source_device,
                   WebFloatPoint velocity,
                   WebPoint position) {
     expected_disposition_ = InputHandlerProxy::DID_HANDLE;
     VERIFY_AND_RESET_MOCKS();
 
     EXPECT_CALL(mock_input_handler_, ScrollBegin(testing::_, testing::_))
         .WillOnce(testing::Return(kImplThreadScrollState));
-    gesture_.type = WebInputEvent::GestureScrollBegin;
+    gesture_.setType(WebInputEvent::GestureScrollBegin);
     gesture_.sourceDevice = source_device;
     EXPECT_EQ(expected_disposition_,
               input_handler_->HandleInputEvent(gesture_));
 
     VERIFY_AND_RESET_MOCKS();
 
     EXPECT_CALL(mock_input_handler_, FlingScrollBegin())
         .WillOnce(testing::Return(kImplThreadScrollState));
     EXPECT_SET_NEEDS_ANIMATE_INPUT(1);
 
     gesture_ =
         CreateFling(timestamp, source_device, velocity, position, position, 0);
     EXPECT_EQ(expected_disposition_,
               input_handler_->HandleInputEvent(gesture_));
 
     VERIFY_AND_RESET_MOCKS();
   }
 
   void CancelFling(base::TimeTicks timestamp) {
-    gesture_.timeStampSeconds = InSecondsF(timestamp);
-    gesture_.type = WebInputEvent::GestureFlingCancel;
+    gesture_.setTimeStampSeconds(InSecondsF(timestamp));
+    gesture_.setType(WebInputEvent::GestureFlingCancel);
     EXPECT_EQ(expected_disposition_,
               input_handler_->HandleInputEvent(gesture_));
 
     VERIFY_AND_RESET_MOCKS();
   }
 
   void SetSmoothScrollEnabled(bool value) {
     input_handler_->smooth_scroll_enabled_ = value;
   }
 
@@ skipping 71 matching lines @@
 
   base::WeakPtrFactory<InputHandlerProxyEventQueueTest> weak_ptr_factory_;
 };
 
 TEST_P(InputHandlerProxyTest, MouseWheelNoListener) {
   expected_disposition_ = InputHandlerProxy::DROP_EVENT;
   EXPECT_CALL(mock_input_handler_,
               GetEventListenerProperties(cc::EventListenerClass::kMouseWheel))
       .WillOnce(testing::Return(cc::EventListenerProperties::kNone));
 
-  WebMouseWheelEvent wheel;
-  wheel.type = WebInputEvent::MouseWheel;
-  wheel.modifiers = WebInputEvent::ControlKey;
+  WebMouseWheelEvent wheel(WebInputEvent::MouseWheel, WebInputEvent::ControlKey,
+                           WebInputEvent::TimeStampForTesting);
   EXPECT_EQ(expected_disposition_, input_handler_->HandleInputEvent(wheel));
   VERIFY_AND_RESET_MOCKS();
 }
 
 TEST_P(InputHandlerProxyTest, MouseWheelPassiveListener) {
   expected_disposition_ = InputHandlerProxy::DID_HANDLE_NON_BLOCKING;
   EXPECT_CALL(mock_input_handler_,
               GetEventListenerProperties(cc::EventListenerClass::kMouseWheel))
       .WillOnce(testing::Return(cc::EventListenerProperties::kPassive));
 
-  WebMouseWheelEvent wheel;
-  wheel.type = WebInputEvent::MouseWheel;
-  wheel.modifiers = WebInputEvent::ControlKey;
+  WebMouseWheelEvent wheel(WebInputEvent::MouseWheel, WebInputEvent::ControlKey,
+                           WebInputEvent::TimeStampForTesting);
   EXPECT_EQ(expected_disposition_, input_handler_->HandleInputEvent(wheel));
   VERIFY_AND_RESET_MOCKS();
 }
 
 TEST_P(InputHandlerProxyTest, MouseWheelBlockingListener) {
   expected_disposition_ = InputHandlerProxy::DID_NOT_HANDLE;
   EXPECT_CALL(mock_input_handler_,
               GetEventListenerProperties(cc::EventListenerClass::kMouseWheel))
       .WillOnce(testing::Return(cc::EventListenerProperties::kBlocking));
 
-  WebMouseWheelEvent wheel;
-  wheel.type = WebInputEvent::MouseWheel;
-  wheel.modifiers = WebInputEvent::ControlKey;
+  WebMouseWheelEvent wheel(WebInputEvent::MouseWheel, WebInputEvent::ControlKey,
+                           WebInputEvent::TimeStampForTesting);
   EXPECT_EQ(expected_disposition_, input_handler_->HandleInputEvent(wheel));
   VERIFY_AND_RESET_MOCKS();
 }
 
 TEST_P(InputHandlerProxyTest, GestureScrollStarted) {
   // We shouldn't send any events to the widget for this gesture.
   expected_disposition_ = InputHandlerProxy::DID_HANDLE;
   VERIFY_AND_RESET_MOCKS();
 
   EXPECT_CALL(mock_input_handler_, ScrollBegin(testing::_, testing::_))
       .WillOnce(testing::Return(kImplThreadScrollState));
 
-  gesture_.type = WebInputEvent::GestureScrollBegin;
+  gesture_.setType(WebInputEvent::GestureScrollBegin);
   EXPECT_EQ(expected_disposition_,input_handler_->HandleInputEvent(gesture_));
 
   // The event should not be marked as handled if scrolling is not possible.
   expected_disposition_ = InputHandlerProxy::DROP_EVENT;
   VERIFY_AND_RESET_MOCKS();
 
-  gesture_.type = WebInputEvent::GestureScrollUpdate;
+  gesture_.setType(WebInputEvent::GestureScrollUpdate);
   gesture_.data.scrollUpdate.deltaY =
       -40;  // -Y means scroll down - i.e. in the +Y direction.
   EXPECT_CALL(
       mock_input_handler_,
       ScrollBy(testing::Property(&cc::ScrollState::delta_y, testing::Gt(0))))
       .WillOnce(testing::Return(scroll_result_did_not_scroll_));
   EXPECT_EQ(expected_disposition_, input_handler_->HandleInputEvent(gesture_));
 
   // Mark the event as handled if scroll happens.
   expected_disposition_ = InputHandlerProxy::DID_HANDLE;
   VERIFY_AND_RESET_MOCKS();
 
-  gesture_.type = WebInputEvent::GestureScrollUpdate;
+  gesture_.setType(WebInputEvent::GestureScrollUpdate);
   gesture_.data.scrollUpdate.deltaY =
       -40;  // -Y means scroll down - i.e. in the +Y direction.
   EXPECT_CALL(
       mock_input_handler_,
       ScrollBy(testing::Property(&cc::ScrollState::delta_y, testing::Gt(0))))
       .WillOnce(testing::Return(scroll_result_did_scroll_));
   EXPECT_EQ(expected_disposition_, input_handler_->HandleInputEvent(gesture_));
 
   VERIFY_AND_RESET_MOCKS();
 
-  gesture_.type = WebInputEvent::GestureScrollEnd;
+  gesture_.setType(WebInputEvent::GestureScrollEnd);
   gesture_.data.scrollUpdate.deltaY = 0;
   EXPECT_CALL(mock_input_handler_, ScrollEnd(testing::_));
   EXPECT_EQ(expected_disposition_, input_handler_->HandleInputEvent(gesture_));
 
   VERIFY_AND_RESET_MOCKS();
 }
 
 TEST_P(InputHandlerProxyTest, GestureScrollOnMainThread) {
   // We should send all events to the widget for this gesture.
   expected_disposition_ = InputHandlerProxy::DID_NOT_HANDLE;
   VERIFY_AND_RESET_MOCKS();
 
   EXPECT_CALL(mock_input_handler_, ScrollBegin(::testing::_, ::testing::_))
       .WillOnce(testing::Return(kMainThreadScrollState));
 
-  gesture_.type = WebInputEvent::GestureScrollBegin;
+  gesture_.setType(WebInputEvent::GestureScrollBegin);
   EXPECT_EQ(expected_disposition_, input_handler_->HandleInputEvent(gesture_));
 
   VERIFY_AND_RESET_MOCKS();
 
-  gesture_.type = WebInputEvent::GestureScrollUpdate;
+  gesture_.setType(WebInputEvent::GestureScrollUpdate);
   gesture_.data.scrollUpdate.deltaY = 40;
   EXPECT_EQ(expected_disposition_, input_handler_->HandleInputEvent(gesture_));
 
   VERIFY_AND_RESET_MOCKS();
 
-  gesture_.type = WebInputEvent::GestureScrollEnd;
+  gesture_.setType(WebInputEvent::GestureScrollEnd);
   gesture_.data.scrollUpdate.deltaY = 0;
   EXPECT_CALL(mock_input_handler_, ScrollEnd(testing::_))
       .WillOnce(testing::Return());
   EXPECT_EQ(expected_disposition_, input_handler_->HandleInputEvent(gesture_));
 
   VERIFY_AND_RESET_MOCKS();
 }
 
 TEST_P(InputHandlerProxyTest, GestureScrollIgnored) {
   // We shouldn't handle the GestureScrollBegin.
   // Instead, we should get a DROP_EVENT result, indicating
   // that we could determine that there's nothing that could scroll or otherwise
   // react to this gesture sequence and thus we should drop the whole gesture
   // sequence on the floor, except for the ScrollEnd.
   expected_disposition_ = InputHandlerProxy::DROP_EVENT;
   VERIFY_AND_RESET_MOCKS();
 
   EXPECT_CALL(mock_input_handler_, ScrollBegin(testing::_, testing::_))
       .WillOnce(testing::Return(kScrollIgnoredScrollState));
 
-  gesture_.type = WebInputEvent::GestureScrollBegin;
+  gesture_.setType(WebInputEvent::GestureScrollBegin);
   EXPECT_EQ(expected_disposition_, input_handler_->HandleInputEvent(gesture_));
 
   expected_disposition_ = InputHandlerProxy::DID_NOT_HANDLE;
-  gesture_.type = WebInputEvent::GestureScrollEnd;
+  gesture_.setType(WebInputEvent::GestureScrollEnd);
   EXPECT_CALL(mock_input_handler_, ScrollEnd(testing::_))
       .WillOnce(testing::Return());
   EXPECT_EQ(expected_disposition_, input_handler_->HandleInputEvent(gesture_));
 
   VERIFY_AND_RESET_MOCKS();
 }
 
 TEST_P(InputHandlerProxyTest, GestureScrollByPage) {
   // We should send all events to the widget for this gesture.
   expected_disposition_ = InputHandlerProxy::DID_NOT_HANDLE;
   VERIFY_AND_RESET_MOCKS();
 
-  gesture_.type = WebInputEvent::GestureScrollBegin;
+  gesture_.setType(WebInputEvent::GestureScrollBegin);
   gesture_.data.scrollBegin.deltaHintUnits = WebGestureEvent::ScrollUnits::Page;
   EXPECT_EQ(expected_disposition_, input_handler_->HandleInputEvent(gesture_));
 
   VERIFY_AND_RESET_MOCKS();
 
-  gesture_.type = WebInputEvent::GestureScrollUpdate;
+  gesture_.setType(WebInputEvent::GestureScrollUpdate);
   gesture_.data.scrollUpdate.deltaY = 1;
   gesture_.data.scrollUpdate.deltaUnits = WebGestureEvent::ScrollUnits::Page;
   EXPECT_EQ(expected_disposition_, input_handler_->HandleInputEvent(gesture_));
 
   VERIFY_AND_RESET_MOCKS();
 
-  gesture_.type = WebInputEvent::GestureScrollEnd;
+  gesture_.setType(WebInputEvent::GestureScrollEnd);
   gesture_.data.scrollUpdate.deltaY = 0;
   EXPECT_CALL(mock_input_handler_, ScrollEnd(testing::_))
       .WillOnce(testing::Return());
   EXPECT_EQ(expected_disposition_, input_handler_->HandleInputEvent(gesture_));
 
   VERIFY_AND_RESET_MOCKS();
 }
 
 // Mac does not smooth scroll wheel events (crbug.com/574283).
 #if !defined(OS_MACOSX)
 TEST_P(InputHandlerProxyTest, GestureScrollByCoarsePixels) {
 #else
 TEST_P(InputHandlerProxyTest, DISABLED_GestureScrollByCoarsePixels) {
 #endif
   SetSmoothScrollEnabled(true);
   expected_disposition_ = InputHandlerProxy::DID_HANDLE;
 
-  gesture_.type = WebInputEvent::GestureScrollBegin;
+  gesture_.setType(WebInputEvent::GestureScrollBegin);
   gesture_.data.scrollBegin.deltaHintUnits =
       WebGestureEvent::ScrollUnits::Pixels;
   EXPECT_CALL(mock_input_handler_, ScrollAnimatedBegin(::testing::_))
       .WillOnce(testing::Return(kImplThreadScrollState));
   EXPECT_EQ(expected_disposition_, input_handler_->HandleInputEvent(gesture_));
 
-  gesture_.type = WebInputEvent::GestureScrollUpdate;
+  gesture_.setType(WebInputEvent::GestureScrollUpdate);
   gesture_.data.scrollUpdate.deltaUnits = WebGestureEvent::ScrollUnits::Pixels;
 
   EXPECT_CALL(mock_input_handler_,
               ScrollAnimated(::testing::_, ::testing::_, ::testing::_))
       .WillOnce(testing::Return(kImplThreadScrollState));
   EXPECT_EQ(expected_disposition_, input_handler_->HandleInputEvent(gesture_));
 
   VERIFY_AND_RESET_MOCKS();
 }
 
 TEST_P(InputHandlerProxyTest, GestureScrollBeginThatTargetViewport) {
   // We shouldn't send any events to the widget for this gesture.
   expected_disposition_ = InputHandlerProxy::DID_HANDLE;
   VERIFY_AND_RESET_MOCKS();
 
   EXPECT_CALL(mock_input_handler_, RootScrollBegin(testing::_, testing::_))
       .WillOnce(testing::Return(kImplThreadScrollState));
 
-  gesture_.type = WebInputEvent::GestureScrollBegin;
+  gesture_.setType(WebInputEvent::GestureScrollBegin);
   gesture_.data.scrollBegin.targetViewport = true;
   EXPECT_EQ(expected_disposition_, input_handler_->HandleInputEvent(gesture_));
 
   VERIFY_AND_RESET_MOCKS();
 }
 
 TEST_P(InputHandlerProxyTest, GesturePinch) {
   // We shouldn't send any events to the widget for this gesture.
   expected_disposition_ = InputHandlerProxy::DID_HANDLE;
   VERIFY_AND_RESET_MOCKS();
 
-  gesture_.type = WebInputEvent::GesturePinchBegin;
+  gesture_.setType(WebInputEvent::GesturePinchBegin);
   EXPECT_CALL(mock_input_handler_,
               GetEventListenerProperties(cc::EventListenerClass::kMouseWheel))
       .WillOnce(testing::Return(cc::EventListenerProperties::kNone));
   EXPECT_CALL(mock_input_handler_, PinchGestureBegin());
   EXPECT_EQ(expected_disposition_, input_handler_->HandleInputEvent(gesture_));
 
   VERIFY_AND_RESET_MOCKS();
 
-  gesture_.type = WebInputEvent::GesturePinchUpdate;
+  gesture_.setType(WebInputEvent::GesturePinchUpdate);
   gesture_.data.pinchUpdate.scale = 1.5;
   gesture_.x = 7;
   gesture_.y = 13;
   EXPECT_CALL(mock_input_handler_, PinchGestureUpdate(1.5, gfx::Point(7, 13)));
   EXPECT_EQ(expected_disposition_, input_handler_->HandleInputEvent(gesture_));
 
   VERIFY_AND_RESET_MOCKS();
 
-  gesture_.type = WebInputEvent::GesturePinchUpdate;
+  gesture_.setType(WebInputEvent::GesturePinchUpdate);
   gesture_.data.pinchUpdate.scale = 0.5;
   gesture_.data.pinchUpdate.zoomDisabled = true;
   gesture_.x = 9;
   gesture_.y = 6;
   EXPECT_EQ(InputHandlerProxy::DROP_EVENT,
             input_handler_->HandleInputEvent(gesture_));
   gesture_.data.pinchUpdate.zoomDisabled = false;
 
   VERIFY_AND_RESET_MOCKS();
 
-  gesture_.type = WebInputEvent::GesturePinchUpdate;
+  gesture_.setType(WebInputEvent::GesturePinchUpdate);
   gesture_.data.pinchUpdate.scale = 0.5;
   gesture_.x = 9;
   gesture_.y = 6;
   EXPECT_CALL(mock_input_handler_, PinchGestureUpdate(.5, gfx::Point(9, 6)));
   EXPECT_EQ(expected_disposition_, input_handler_->HandleInputEvent(gesture_));
 
   VERIFY_AND_RESET_MOCKS();
 
-  gesture_.type = WebInputEvent::GesturePinchEnd;
+  gesture_.setType(WebInputEvent::GesturePinchEnd);
   EXPECT_CALL(mock_input_handler_, PinchGestureEnd());
   EXPECT_EQ(expected_disposition_, input_handler_->HandleInputEvent(gesture_));
 
   VERIFY_AND_RESET_MOCKS();
 }
 
 TEST_P(InputHandlerProxyTest, GesturePinchWithWheelHandler) {
   // We will send the synthetic wheel event to the widget.
   expected_disposition_ = InputHandlerProxy::DID_NOT_HANDLE;
   VERIFY_AND_RESET_MOCKS();
 
-  gesture_.type = WebInputEvent::GesturePinchBegin;
+  gesture_.setType(WebInputEvent::GesturePinchBegin);
   EXPECT_CALL(mock_input_handler_,
               GetEventListenerProperties(cc::EventListenerClass::kMouseWheel))
       .WillOnce(testing::Return(cc::EventListenerProperties::kBlocking));
   EXPECT_EQ(expected_disposition_, input_handler_->HandleInputEvent(gesture_));
 
   VERIFY_AND_RESET_MOCKS();
 
-  gesture_.type = WebInputEvent::GesturePinchUpdate;
+  gesture_.setType(WebInputEvent::GesturePinchUpdate);
   gesture_.data.pinchUpdate.scale = 1.5;
   gesture_.x = 7;
   gesture_.y = 13;
   EXPECT_EQ(expected_disposition_, input_handler_->HandleInputEvent(gesture_));
 
   VERIFY_AND_RESET_MOCKS();
 
-  gesture_.type = WebInputEvent::GesturePinchUpdate;
+  gesture_.setType(WebInputEvent::GesturePinchUpdate);
   gesture_.data.pinchUpdate.scale = 0.5;
   gesture_.x = 9;
   gesture_.y = 6;
   EXPECT_EQ(expected_disposition_, input_handler_->HandleInputEvent(gesture_));
 
   VERIFY_AND_RESET_MOCKS();
 
-  gesture_.type = WebInputEvent::GesturePinchEnd;
+  gesture_.setType(WebInputEvent::GesturePinchEnd);
   EXPECT_EQ(expected_disposition_, input_handler_->HandleInputEvent(gesture_));
 }
 
 TEST_P(InputHandlerProxyTest, GesturePinchAfterScrollOnMainThread) {
   // Scrolls will start by being sent to the main thread.
   expected_disposition_ = InputHandlerProxy::DID_NOT_HANDLE;
   VERIFY_AND_RESET_MOCKS();
 
   EXPECT_CALL(mock_input_handler_, ScrollBegin(::testing::_, ::testing::_))
       .WillOnce(testing::Return(kMainThreadScrollState));
 
-  gesture_.type = WebInputEvent::GestureScrollBegin;
+  gesture_.setType(WebInputEvent::GestureScrollBegin);
   EXPECT_EQ(expected_disposition_, input_handler_->HandleInputEvent(gesture_));
 
   VERIFY_AND_RESET_MOCKS();
 
-  gesture_.type = WebInputEvent::GestureScrollUpdate;
+  gesture_.setType(WebInputEvent::GestureScrollUpdate);
   gesture_.data.scrollUpdate.deltaY = 40;
   EXPECT_EQ(expected_disposition_, input_handler_->HandleInputEvent(gesture_));
 
   // However, after the pinch gesture starts, they should go to the impl
   // thread.
   expected_disposition_ = InputHandlerProxy::DID_HANDLE;
   VERIFY_AND_RESET_MOCKS();
 
-  gesture_.type = WebInputEvent::GesturePinchBegin;
+  gesture_.setType(WebInputEvent::GesturePinchBegin);
+  ;
   EXPECT_CALL(mock_input_handler_,
               GetEventListenerProperties(cc::EventListenerClass::kMouseWheel))
       .WillOnce(testing::Return(cc::EventListenerProperties::kNone));
   EXPECT_CALL(mock_input_handler_, PinchGestureBegin());
   EXPECT_EQ(expected_disposition_, input_handler_->HandleInputEvent(gesture_));
 
   VERIFY_AND_RESET_MOCKS();
 
-  gesture_.type = WebInputEvent::GesturePinchUpdate;
+  gesture_.setType(WebInputEvent::GesturePinchUpdate);
   gesture_.data.pinchUpdate.scale = 1.5;
   gesture_.x = 7;
   gesture_.y = 13;
   EXPECT_CALL(mock_input_handler_, PinchGestureUpdate(1.5, gfx::Point(7, 13)));
   EXPECT_EQ(expected_disposition_, input_handler_->HandleInputEvent(gesture_));
 
   VERIFY_AND_RESET_MOCKS();
 
-  gesture_.type = WebInputEvent::GestureScrollUpdate;
+  gesture_.setType(WebInputEvent::GestureScrollUpdate);
   gesture_.data.scrollUpdate.deltaY =
       -40;  // -Y means scroll down - i.e. in the +Y direction.
   EXPECT_CALL(
       mock_input_handler_,
       ScrollBy(testing::Property(&cc::ScrollState::delta_y, testing::Gt(0))))
       .WillOnce(testing::Return(scroll_result_did_scroll_));
   EXPECT_EQ(expected_disposition_, input_handler_->HandleInputEvent(gesture_));
 
   VERIFY_AND_RESET_MOCKS();
 
-  gesture_.type = WebInputEvent::GesturePinchUpdate;
+  gesture_.setType(WebInputEvent::GesturePinchUpdate);
   gesture_.data.pinchUpdate.scale = 0.5;
   gesture_.x = 9;
   gesture_.y = 6;
   EXPECT_CALL(mock_input_handler_, PinchGestureUpdate(.5, gfx::Point(9, 6)));
   EXPECT_EQ(expected_disposition_, input_handler_->HandleInputEvent(gesture_));
 
   VERIFY_AND_RESET_MOCKS();
 
-  gesture_.type = WebInputEvent::GesturePinchEnd;
+  gesture_.setType(WebInputEvent::GesturePinchEnd);
   EXPECT_CALL(mock_input_handler_, PinchGestureEnd());
   EXPECT_EQ(expected_disposition_, input_handler_->HandleInputEvent(gesture_));
 
   // After the pinch gesture ends, they should go to back to the main
   // thread.
   expected_disposition_ = InputHandlerProxy::DID_NOT_HANDLE;
   VERIFY_AND_RESET_MOCKS();
 
-  gesture_.type = WebInputEvent::GestureScrollEnd;
+  gesture_.setType(WebInputEvent::GestureScrollEnd);
   gesture_.data.scrollUpdate.deltaY = 0;
   EXPECT_CALL(mock_input_handler_, ScrollEnd(testing::_))
       .WillOnce(testing::Return());
   EXPECT_EQ(expected_disposition_, input_handler_->HandleInputEvent(gesture_));
 
   VERIFY_AND_RESET_MOCKS();
 }
 
 TEST_P(InputHandlerProxyTest, GestureFlingStartedTouchpad) {
   // We shouldn't send any events to the widget for this gesture.
   expected_disposition_ = InputHandlerProxy::DID_HANDLE;
   VERIFY_AND_RESET_MOCKS();
 
   EXPECT_CALL(mock_input_handler_, ScrollBegin(testing::_, testing::_))
       .WillOnce(testing::Return(kImplThreadScrollState));
   EXPECT_CALL(mock_input_handler_, ScrollEnd(testing::_));
   EXPECT_SET_NEEDS_ANIMATE_INPUT(1);
 
-  gesture_.type = WebInputEvent::GestureFlingStart;
+  gesture_.setType(WebInputEvent::GestureFlingStart);
   gesture_.data.flingStart.velocityX = 10;
   gesture_.sourceDevice = blink::WebGestureDeviceTouchpad;
   EXPECT_EQ(expected_disposition_, input_handler_->HandleInputEvent(gesture_));
 
   VERIFY_AND_RESET_MOCKS();
 
   // Verify that a GestureFlingCancel during an animation cancels it.
-  gesture_.type = WebInputEvent::GestureFlingCancel;
+  gesture_.setType(WebInputEvent::GestureFlingCancel);
   gesture_.sourceDevice = blink::WebGestureDeviceTouchpad;
   EXPECT_EQ(expected_disposition_, input_handler_->HandleInputEvent(gesture_));
 }
 
 TEST_P(InputHandlerProxyTest, GestureFlingOnMainThreadTouchpad) {
   // We should send all events to the widget for this gesture.
   expected_disposition_ = InputHandlerProxy::DID_NOT_HANDLE;
   VERIFY_AND_RESET_MOCKS();
 
   EXPECT_CALL(mock_input_handler_, ScrollBegin(testing::_, testing::_))
       .WillOnce(testing::Return(kMainThreadScrollState));
 
-  gesture_.type = WebInputEvent::GestureFlingStart;
+  gesture_.setType(WebInputEvent::GestureFlingStart);
   gesture_.sourceDevice = blink::WebGestureDeviceTouchpad;
   EXPECT_EQ(expected_disposition_, input_handler_->HandleInputEvent(gesture_));
 
   // Since we returned ScrollStatusOnMainThread from scrollBegin, ensure the
   // input handler knows it's scrolling off the impl thread
   ASSERT_FALSE(input_handler_->gesture_scroll_on_impl_thread_for_testing());
 
   VERIFY_AND_RESET_MOCKS();
 
   // Even if we didn't start a fling ourselves, we still need to send the cancel
   // event to the widget.
-  gesture_.type = WebInputEvent::GestureFlingCancel;
+  gesture_.setType(WebInputEvent::GestureFlingCancel);
   gesture_.sourceDevice = blink::WebGestureDeviceTouchpad;
   EXPECT_EQ(expected_disposition_, input_handler_->HandleInputEvent(gesture_));
 }
 
 TEST_P(InputHandlerProxyTest, GestureFlingIgnoredTouchpad) {
   expected_disposition_ = InputHandlerProxy::DID_NOT_HANDLE;
   VERIFY_AND_RESET_MOCKS();
 
   EXPECT_CALL(mock_input_handler_, ScrollBegin(testing::_, testing::_))
       .WillOnce(testing::Return(kScrollIgnoredScrollState));
 
-  gesture_.type = WebInputEvent::GestureFlingStart;
+  gesture_.setType(WebInputEvent::GestureFlingStart);
   gesture_.sourceDevice = blink::WebGestureDeviceTouchpad;
   EXPECT_EQ(expected_disposition_, input_handler_->HandleInputEvent(gesture_));
 
   expected_disposition_ = InputHandlerProxy::DROP_EVENT;
   VERIFY_AND_RESET_MOCKS();
 
   // Since the previous fling was ignored, we should also be dropping the next
   // fling_cancel.
-  gesture_.type = WebInputEvent::GestureFlingCancel;
+  gesture_.setType(WebInputEvent::GestureFlingCancel);
   gesture_.sourceDevice = blink::WebGestureDeviceTouchpad;
   EXPECT_EQ(expected_disposition_, input_handler_->HandleInputEvent(gesture_));
 }
 
 TEST_P(InputHandlerProxyTest, GestureFlingAnimatesTouchpad) {
   // We shouldn't send any events to the widget for this gesture.
   expected_disposition_ = InputHandlerProxy::DID_HANDLE;
   VERIFY_AND_RESET_MOCKS();
 
   // On the fling start, we should schedule an animation but not actually start
   // scrolling.
-  gesture_.type = WebInputEvent::GestureFlingStart;
+  gesture_.setType(WebInputEvent::GestureFlingStart);
   WebFloatPoint fling_delta = WebFloatPoint(1000, 0);
   WebPoint fling_point = WebPoint(7, 13);
   WebPoint fling_global_point = WebPoint(17, 23);
   // Note that for trackpad, wheel events with the Control modifier are
   // special (reserved for zoom), so don't set that here.
   int modifiers = WebInputEvent::ShiftKey | WebInputEvent::AltKey;
   gesture_ = CreateFling(blink::WebGestureDeviceTouchpad,
                          fling_delta,
                          fling_point,
                          fling_global_point,
@@ skipping 81 matching lines @@
   EXPECT_SET_NEEDS_ANIMATE_INPUT(0);
   EXPECT_CALL(mock_input_handler_, ScrollBegin(testing::_, testing::_))
       .Times(0);
   time += base::TimeDelta::FromMilliseconds(100);
   Animate(time);
 
   // Since we've transferred the fling to the main thread, we need to pass the
   // next GestureFlingCancel to the main
   // thread as well.
   expected_disposition_ = InputHandlerProxy::DID_NOT_HANDLE;
-  gesture_.type = WebInputEvent::GestureFlingCancel;
+  gesture_.setType(WebInputEvent::GestureFlingCancel);
   EXPECT_EQ(expected_disposition_, input_handler_->HandleInputEvent(gesture_));
 
   VERIFY_AND_RESET_MOCKS();
 }
 
 TEST_P(InputHandlerProxyTest, GestureFlingPassiveListener) {
   // We shouldn't send any events to the widget for this gesture.
   expected_disposition_ = InputHandlerProxy::DID_HANDLE;
   VERIFY_AND_RESET_MOCKS();
 
   // On the fling start, we should schedule an animation but not actually start
   // scrolling.
-  gesture_.type = WebInputEvent::GestureFlingStart;
+  gesture_.setType(WebInputEvent::GestureFlingStart);
   WebFloatPoint fling_delta = WebFloatPoint(1000, 0);
   WebPoint fling_point = WebPoint(7, 13);
   WebPoint fling_global_point = WebPoint(17, 23);
   // Note that for trackpad, wheel events with the Control modifier are
   // special (reserved for zoom), so don't set that here.
   int modifiers = WebInputEvent::ShiftKey | WebInputEvent::AltKey;
   gesture_ = CreateFling(blink::WebGestureDeviceTouchpad, fling_delta,
                          fling_point, fling_global_point, modifiers);
   EXPECT_SET_NEEDS_ANIMATE_INPUT(1);
   EXPECT_CALL(mock_input_handler_, ScrollBegin(testing::_, testing::_))
@@ skipping 21 matching lines @@
   EXPECT_SET_NEEDS_ANIMATE_INPUT(1);
   EXPECT_CALL(mock_input_handler_,
               GetEventListenerProperties(cc::EventListenerClass::kMouseWheel))
       .WillOnce(testing::Return(cc::EventListenerProperties::kPassive));
   EXPECT_CALL(mock_input_handler_, ScrollBegin(testing::_, testing::_))
       .WillOnce(testing::Return(kImplThreadScrollState));
   EXPECT_CALL(
       mock_input_handler_,
       ScrollBy(testing::Property(&cc::ScrollState::delta_x, testing::Lt(0))))
       .WillOnce(testing::Return(scroll_result_did_scroll_));
-  WebMouseWheelEvent expected_wheel;
-  expected_wheel.type = WebInputEvent::MouseWheel;
-  expected_wheel.modifiers = modifiers;
+  WebMouseWheelEvent expected_wheel(WebInputEvent::MouseWheel, modifiers,
+                                    WebInputEvent::TimeStampForTesting);
   expected_wheel.x = fling_point.x;
   expected_wheel.y = fling_point.y;
   expected_wheel.globalX = fling_global_point.x;
   expected_wheel.globalY = fling_global_point.y;
   expected_wheel.deltaX = fling_delta.x / 10;
   expected_wheel.hasPreciseScrollingDeltas = true;
 
   EXPECT_CALL(mock_client_, DispatchNonBlockingEventToMainThread_(
                                 WheelEventsMatch(expected_wheel)))
       .Times(1);
   EXPECT_CALL(mock_input_handler_, ScrollEnd(testing::_)).Times(1);
 
   time += base::TimeDelta::FromMilliseconds(100);
   Animate(time);
 
   VERIFY_AND_RESET_MOCKS();
 
   // Ensure we can cancel the gesture.
   expected_disposition_ = InputHandlerProxy::DID_HANDLE;
-  gesture_.type = WebInputEvent::GestureFlingCancel;
+  gesture_.setType(WebInputEvent::GestureFlingCancel);
   EXPECT_EQ(expected_disposition_, input_handler_->HandleInputEvent(gesture_));
 
   VERIFY_AND_RESET_MOCKS();
 }
 
 TEST_P(InputHandlerProxyTest, GestureFlingTransferResetsTouchpad) {
   // We shouldn't send any events to the widget for this gesture.
   expected_disposition_ = InputHandlerProxy::DID_HANDLE;
   VERIFY_AND_RESET_MOCKS();
 
@@ skipping 92 matching lines @@
       .Times(0);
   time += base::TimeDelta::FromMilliseconds(100);
   Animate(time);
 
   VERIFY_AND_RESET_MOCKS();
 
   // Since we've transferred the fling to the main thread, we need to pass the
   // next GestureFlingCancel to the main
   // thread as well.
   expected_disposition_ = InputHandlerProxy::DID_NOT_HANDLE;
-  gesture_.type = WebInputEvent::GestureFlingCancel;
+  gesture_.setType(WebInputEvent::GestureFlingCancel);
   EXPECT_EQ(expected_disposition_, input_handler_->HandleInputEvent(gesture_));
 
   VERIFY_AND_RESET_MOCKS();
   input_handler_->MainThreadHasStoppedFlinging();
 
   // Start a second gesture fling, this time in the +Y direction with no X.
   fling_delta = WebFloatPoint(0, -1000);
   fling_point = WebPoint(95, 87);
   fling_global_point = WebPoint(32, 71);
   modifiers = WebInputEvent::AltKey;
@@ skipping 69 matching lines @@
   VERIFY_AND_RESET_MOCKS();
 }
 
 TEST_P(InputHandlerProxyTest, GestureFlingStartedTouchscreen) {
   // We shouldn't send any events to the widget for this gesture.
   expected_disposition_ = InputHandlerProxy::DID_HANDLE;
   VERIFY_AND_RESET_MOCKS();
 
   EXPECT_CALL(mock_input_handler_, ScrollBegin(testing::_, testing::_))
       .WillOnce(testing::Return(kImplThreadScrollState));
-  gesture_.type = WebInputEvent::GestureScrollBegin;
+  gesture_.setType(WebInputEvent::GestureScrollBegin);
   gesture_.sourceDevice = blink::WebGestureDeviceTouchscreen;
   EXPECT_EQ(expected_disposition_, input_handler_->HandleInputEvent(gesture_));
 
   VERIFY_AND_RESET_MOCKS();
 
   EXPECT_CALL(mock_input_handler_, FlingScrollBegin())
       .WillOnce(testing::Return(kImplThreadScrollState));
   EXPECT_SET_NEEDS_ANIMATE_INPUT(1);
 
-  gesture_.type = WebInputEvent::GestureFlingStart;
+  gesture_.setType(WebInputEvent::GestureFlingStart);
   gesture_.data.flingStart.velocityX = 10;
   gesture_.sourceDevice = blink::WebGestureDeviceTouchscreen;
   EXPECT_EQ(expected_disposition_, input_handler_->HandleInputEvent(gesture_));
 
   VERIFY_AND_RESET_MOCKS();
 
   EXPECT_CALL(mock_input_handler_, ScrollEnd(testing::_));
 
   // Verify that a GestureFlingCancel during an animation cancels it.
-  gesture_.type = WebInputEvent::GestureFlingCancel;
+  gesture_.setType(WebInputEvent::GestureFlingCancel);
   gesture_.sourceDevice = blink::WebGestureDeviceTouchscreen;
   EXPECT_EQ(expected_disposition_, input_handler_->HandleInputEvent(gesture_));
 
   VERIFY_AND_RESET_MOCKS();
 }
 
 TEST_P(InputHandlerProxyTest, GestureFlingOnMainThreadTouchscreen) {
   // We should send all events to the widget for this gesture.
   expected_disposition_ = InputHandlerProxy::DID_NOT_HANDLE;
   VERIFY_AND_RESET_MOCKS();
 
   EXPECT_CALL(mock_input_handler_, ScrollBegin(testing::_, testing::_))
       .WillOnce(testing::Return(kMainThreadScrollState));
 
-  gesture_.type = WebInputEvent::GestureScrollBegin;
+  gesture_.setType(WebInputEvent::GestureScrollBegin);
   EXPECT_EQ(expected_disposition_, input_handler_->HandleInputEvent(gesture_));
 
   VERIFY_AND_RESET_MOCKS();
 
   EXPECT_CALL(mock_input_handler_, FlingScrollBegin()).Times(0);
 
-  gesture_.type = WebInputEvent::GestureFlingStart;
+  gesture_.setType(WebInputEvent::GestureFlingStart);
   gesture_.sourceDevice = blink::WebGestureDeviceTouchscreen;
   EXPECT_EQ(expected_disposition_, input_handler_->HandleInputEvent(gesture_));
 
   VERIFY_AND_RESET_MOCKS();
 
   // Even if we didn't start a fling ourselves, we still need to send the cancel
   // event to the widget.
-  gesture_.type = WebInputEvent::GestureFlingCancel;
+  gesture_.setType(WebInputEvent::GestureFlingCancel);
   gesture_.sourceDevice = blink::WebGestureDeviceTouchscreen;
   EXPECT_EQ(expected_disposition_, input_handler_->HandleInputEvent(gesture_));
 }
 
 TEST_P(InputHandlerProxyTest, GestureFlingIgnoredTouchscreen) {
   expected_disposition_ = InputHandlerProxy::DID_HANDLE;
   VERIFY_AND_RESET_MOCKS();
 
   EXPECT_CALL(mock_input_handler_, ScrollBegin(testing::_, testing::_))
       .WillOnce(testing::Return(kImplThreadScrollState));
 
-  gesture_.type = WebInputEvent::GestureScrollBegin;
+  gesture_.setType(WebInputEvent::GestureScrollBegin);
   gesture_.sourceDevice = blink::WebGestureDeviceTouchscreen;
   EXPECT_EQ(expected_disposition_, input_handler_->HandleInputEvent(gesture_));
 
   expected_disposition_ = InputHandlerProxy::DROP_EVENT;
   VERIFY_AND_RESET_MOCKS();
 
   // Flings ignored by the InputHandler should be dropped, signalling the end
   // of the touch scroll sequence.
   EXPECT_CALL(mock_input_handler_, FlingScrollBegin())
       .WillOnce(testing::Return(kScrollIgnoredScrollState));
 
-  gesture_.type = WebInputEvent::GestureFlingStart;
+  gesture_.setType(WebInputEvent::GestureFlingStart);
   gesture_.sourceDevice = blink::WebGestureDeviceTouchscreen;
   EXPECT_EQ(expected_disposition_, input_handler_->HandleInputEvent(gesture_));
 
   VERIFY_AND_RESET_MOCKS();
 
   // Subsequent scrolls should behave normally, even without an intervening
   // GestureFlingCancel, as the original GestureFlingStart was dropped.
   expected_disposition_ = InputHandlerProxy::DID_HANDLE;
   EXPECT_CALL(mock_input_handler_, ScrollBegin(testing::_, testing::_))
       .WillOnce(testing::Return(kImplThreadScrollState));
-  gesture_.type = WebInputEvent::GestureScrollBegin;
+  gesture_.setType(WebInputEvent::GestureScrollBegin);
   gesture_.sourceDevice = blink::WebGestureDeviceTouchscreen;
   EXPECT_EQ(expected_disposition_, input_handler_->HandleInputEvent(gesture_));
 
   VERIFY_AND_RESET_MOCKS();
 }
 
 TEST_P(InputHandlerProxyTest, GestureFlingAnimatesTouchscreen) {
   // We shouldn't send any events to the widget for this gesture.
   expected_disposition_ = InputHandlerProxy::DID_HANDLE;
   VERIFY_AND_RESET_MOCKS();
 
   EXPECT_CALL(mock_input_handler_, ScrollBegin(testing::_, testing::_))
       .WillOnce(testing::Return(kImplThreadScrollState));
 
-  gesture_.type = WebInputEvent::GestureScrollBegin;
+  gesture_.setType(WebInputEvent::GestureScrollBegin);
   gesture_.sourceDevice = blink::WebGestureDeviceTouchscreen;
   EXPECT_EQ(expected_disposition_, input_handler_->HandleInputEvent(gesture_));
 
   VERIFY_AND_RESET_MOCKS();
 
   // On the fling start, we should schedule an animation but not actually start
   // scrolling.
   WebFloatPoint fling_delta = WebFloatPoint(100, 0);
   WebPoint fling_point = WebPoint(7, 13);
   WebPoint fling_global_point = WebPoint(17, 23);
@@ skipping 26 matching lines @@
   EXPECT_CALL(
       mock_input_handler_,
       ScrollBy(testing::Property(&cc::ScrollState::delta_x, testing::Lt(0))))
       .WillOnce(testing::Return(scroll_result_did_scroll_));
   time += base::TimeDelta::FromMilliseconds(100);
   Animate(time);
 
   VERIFY_AND_RESET_MOCKS();
 
   EXPECT_CALL(mock_input_handler_, ScrollEnd(testing::_));
-  gesture_.type = WebInputEvent::GestureFlingCancel;
+  gesture_.setType(WebInputEvent::GestureFlingCancel);
   EXPECT_EQ(expected_disposition_, input_handler_->HandleInputEvent(gesture_));
 
   VERIFY_AND_RESET_MOCKS();
 }
 
 TEST_P(InputHandlerProxyTest, GestureFlingWithValidTimestamp) {
   // We shouldn't send any events to the widget for this gesture.
   expected_disposition_ = InputHandlerProxy::DID_HANDLE;
   VERIFY_AND_RESET_MOCKS();
 
   EXPECT_CALL(mock_input_handler_, ScrollBegin(testing::_, testing::_))
       .WillOnce(testing::Return(kImplThreadScrollState));
 
-  gesture_.type = WebInputEvent::GestureScrollBegin;
+  gesture_.setType(WebInputEvent::GestureScrollBegin);
   gesture_.sourceDevice = blink::WebGestureDeviceTouchscreen;
   EXPECT_EQ(expected_disposition_, input_handler_->HandleInputEvent(gesture_));
 
   VERIFY_AND_RESET_MOCKS();
 
   // On the fling start, we should schedule an animation but not actually start
   // scrolling.
   base::TimeDelta dt = base::TimeDelta::FromMilliseconds(10);
   base::TimeTicks time = base::TimeTicks() + dt;
   WebFloatPoint fling_delta = WebFloatPoint(100, 0);
@@ skipping 21 matching lines @@
   EXPECT_CALL(
       mock_input_handler_,
       ScrollBy(testing::Property(&cc::ScrollState::delta_x, testing::Lt(0))))
       .WillOnce(testing::Return(scroll_result_did_scroll_));
   time += dt;
   Animate(time);
 
   VERIFY_AND_RESET_MOCKS();
 
   EXPECT_CALL(mock_input_handler_, ScrollEnd(testing::_));
-  gesture_.type = WebInputEvent::GestureFlingCancel;
+  gesture_.setType(WebInputEvent::GestureFlingCancel);
   EXPECT_EQ(expected_disposition_, input_handler_->HandleInputEvent(gesture_));
 
   VERIFY_AND_RESET_MOCKS();
 }
 
 TEST_P(InputHandlerProxyTest, GestureFlingWithInvalidTimestamp) {
   // We shouldn't send any events to the widget for this gesture.
   expected_disposition_ = InputHandlerProxy::DID_HANDLE;
   VERIFY_AND_RESET_MOCKS();
 
   EXPECT_CALL(mock_input_handler_, ScrollBegin(testing::_, testing::_))
       .WillOnce(testing::Return(kImplThreadScrollState));
 
-  gesture_.type = WebInputEvent::GestureScrollBegin;
+  gesture_.setType(WebInputEvent::GestureScrollBegin);
   gesture_.sourceDevice = blink::WebGestureDeviceTouchscreen;
   EXPECT_EQ(expected_disposition_, input_handler_->HandleInputEvent(gesture_));
 
   VERIFY_AND_RESET_MOCKS();
 
   // On the fling start, we should schedule an animation but not actually start
   // scrolling.
   base::TimeDelta start_time_offset = base::TimeDelta::FromMilliseconds(10);
-  gesture_.type = WebInputEvent::GestureFlingStart;
+  gesture_.setType(WebInputEvent::GestureFlingStart);
   WebFloatPoint fling_delta = WebFloatPoint(100, 0);
   WebPoint fling_point = WebPoint(7, 13);
   WebPoint fling_global_point = WebPoint(17, 23);
   int modifiers = WebInputEvent::ControlKey;
-  gesture_.timeStampSeconds = start_time_offset.InSecondsF();
+  gesture_.setTimeStampSeconds(start_time_offset.InSecondsF());
   gesture_.data.flingStart.velocityX = fling_delta.x;
   gesture_.data.flingStart.velocityY = fling_delta.y;
   gesture_.sourceDevice = blink::WebGestureDeviceTouchscreen;
   gesture_.x = fling_point.x;
   gesture_.y = fling_point.y;
   gesture_.globalX = fling_global_point.x;
   gesture_.globalY = fling_global_point.y;
-  gesture_.modifiers = modifiers;
+  gesture_.setModifiers(modifiers);
   EXPECT_SET_NEEDS_ANIMATE_INPUT(1);
   EXPECT_CALL(mock_input_handler_, FlingScrollBegin())
       .WillOnce(testing::Return(kImplThreadScrollState));
   EXPECT_EQ(expected_disposition_, input_handler_->HandleInputEvent(gesture_));
 
   VERIFY_AND_RESET_MOCKS();
   // Event though a time stamp was provided for the fling event, it will be
   // ignored as its too far in the past relative to the first animate call's
   // timestamp.
   EXPECT_SET_NEEDS_ANIMATE_INPUT(1);
   base::TimeTicks time =
       base::TimeTicks() + start_time_offset + base::TimeDelta::FromSeconds(1);
   Animate(time);
 
   VERIFY_AND_RESET_MOCKS();
 
   // Further animation ticks should update the fling as usual.
   EXPECT_SET_NEEDS_ANIMATE_INPUT(1);
   EXPECT_CALL(
       mock_input_handler_,
       ScrollBy(testing::Property(&cc::ScrollState::delta_x, testing::Lt(0))))
       .WillOnce(testing::Return(scroll_result_did_scroll_));
   time += base::TimeDelta::FromMilliseconds(10);
   Animate(time);
 
   VERIFY_AND_RESET_MOCKS();
 
   EXPECT_CALL(mock_input_handler_, ScrollEnd(testing::_));
-  gesture_.type = WebInputEvent::GestureFlingCancel;
+  gesture_.setType(WebInputEvent::GestureFlingCancel);
   EXPECT_EQ(expected_disposition_, input_handler_->HandleInputEvent(gesture_));
 
   VERIFY_AND_RESET_MOCKS();
 }
 
 TEST_P(InputHandlerProxyTest, GestureScrollOnImplThreadFlagClearedAfterFling) {
   // We shouldn't send any events to the widget for this gesture.
   expected_disposition_ = InputHandlerProxy::DID_HANDLE;
   VERIFY_AND_RESET_MOCKS();
 
   EXPECT_CALL(mock_input_handler_, ScrollBegin(testing::_, testing::_))
       .WillOnce(testing::Return(kImplThreadScrollState));
 
-  gesture_.type = WebInputEvent::GestureScrollBegin;
+  gesture_.setType(WebInputEvent::GestureScrollBegin);
   EXPECT_EQ(expected_disposition_, input_handler_->HandleInputEvent(gesture_));
 
   // After sending a GestureScrollBegin, the member variable
   // |gesture_scroll_on_impl_thread_| should be true.
   EXPECT_TRUE(input_handler_->gesture_scroll_on_impl_thread_for_testing());
 
   expected_disposition_ = InputHandlerProxy::DID_HANDLE;
   VERIFY_AND_RESET_MOCKS();
 
   // On the fling start, we should schedule an animation but not actually start
@@ skipping 33 matching lines @@
   EXPECT_CALL(
       mock_input_handler_,
       ScrollBy(testing::Property(&cc::ScrollState::delta_x, testing::Lt(0))))
       .WillOnce(testing::Return(scroll_result_did_scroll_));
   time += base::TimeDelta::FromMilliseconds(100);
   Animate(time);
 
   VERIFY_AND_RESET_MOCKS();
 
   EXPECT_CALL(mock_input_handler_, ScrollEnd(testing::_));
-  gesture_.type = WebInputEvent::GestureFlingCancel;
+  gesture_.setType(WebInputEvent::GestureFlingCancel);
   EXPECT_EQ(expected_disposition_, input_handler_->HandleInputEvent(gesture_));
 
   // |gesture_scroll_on_impl_thread_| should be false once
   // the fling has finished (note no GestureScrollEnd has been sent).
   EXPECT_TRUE(!input_handler_->gesture_scroll_on_impl_thread_for_testing());
 
   VERIFY_AND_RESET_MOCKS();
 }
 
 TEST_P(InputHandlerProxyTest,
        BeginScrollWhenGestureScrollOnImplThreadFlagIsSet) {
   // We shouldn't send any events to the widget for this gesture.
   expected_disposition_ = InputHandlerProxy::DID_HANDLE;
   VERIFY_AND_RESET_MOCKS();
 
   EXPECT_CALL(mock_input_handler_, ScrollBegin(testing::_, testing::_))
       .WillOnce(testing::Return(kImplThreadScrollState));
 
-  gesture_.type = WebInputEvent::GestureScrollBegin;
+  gesture_.setType(WebInputEvent::GestureScrollBegin);
   EXPECT_EQ(expected_disposition_, input_handler_->HandleInputEvent(gesture_));
 
   // After sending a GestureScrollBegin, the member variable
   // |gesture_scroll_on_impl_thread_| should be true.
   EXPECT_TRUE(input_handler_->gesture_scroll_on_impl_thread_for_testing());
 
   expected_disposition_ = InputHandlerProxy::DID_HANDLE;
   VERIFY_AND_RESET_MOCKS();
 
   // On the fling start, we should schedule an animation but not actually start
@@ skipping 14 matching lines @@
   EXPECT_TRUE(input_handler_->gesture_scroll_on_impl_thread_for_testing());
 
   VERIFY_AND_RESET_MOCKS();
 
   // gesture_scroll_on_impl_thread_ is still true when this scroll begins. As a
   // result, this scroll begin will cancel the previous fling.
   EXPECT_CALL(mock_input_handler_, ScrollEnd(testing::_));
   EXPECT_CALL(mock_input_handler_, ScrollBegin(testing::_, testing::_))
       .WillOnce(testing::Return(kImplThreadScrollState));
 
-  gesture_.type = WebInputEvent::GestureScrollBegin;
+  gesture_.setType(WebInputEvent::GestureScrollBegin);
   EXPECT_EQ(expected_disposition_, input_handler_->HandleInputEvent(gesture_));
 
   // After sending a GestureScrollBegin, the member variable
   // |gesture_scroll_on_impl_thread_| should be true.
   EXPECT_TRUE(input_handler_->gesture_scroll_on_impl_thread_for_testing());
   VERIFY_AND_RESET_MOCKS();
 }
 
 TEST_P(InputHandlerProxyTest, GestureFlingStopsAtContentEdge) {
   // We shouldn't send any events to the widget for this gesture.
   expected_disposition_ = InputHandlerProxy::DID_HANDLE;
   VERIFY_AND_RESET_MOCKS();
 
   // On the fling start, we should schedule an animation but not actually start
   // scrolling.
-  gesture_.type = WebInputEvent::GestureFlingStart;
+  gesture_.setType(WebInputEvent::GestureFlingStart);
   WebFloatPoint fling_delta = WebFloatPoint(100, 100);
   gesture_.data.flingStart.velocityX = fling_delta.x;
   gesture_.data.flingStart.velocityY = fling_delta.y;
   EXPECT_CALL(mock_input_handler_, ScrollBegin(testing::_, testing::_))
       .WillOnce(testing::Return(kImplThreadScrollState));
   EXPECT_CALL(mock_input_handler_, ScrollEnd(testing::_));
   EXPECT_SET_NEEDS_ANIMATE_INPUT(1);
   EXPECT_EQ(expected_disposition_, input_handler_->HandleInputEvent(gesture_));
   VERIFY_AND_RESET_MOCKS();
 
@@ skipping 66 matching lines @@
 }
 
 TEST_P(InputHandlerProxyTest, GestureFlingNotCancelledBySmallTimeDelta) {
   // We shouldn't send any events to the widget for this gesture.
   expected_disposition_ = InputHandlerProxy::DID_HANDLE;
   VERIFY_AND_RESET_MOCKS();
 
   EXPECT_CALL(mock_input_handler_, ScrollBegin(testing::_, testing::_))
       .WillOnce(testing::Return(kImplThreadScrollState));
 
-  gesture_.type = WebInputEvent::GestureScrollBegin;
+  gesture_.setType(WebInputEvent::GestureScrollBegin);
   gesture_.sourceDevice = blink::WebGestureDeviceTouchscreen;
   EXPECT_EQ(expected_disposition_, input_handler_->HandleInputEvent(gesture_));
 
   VERIFY_AND_RESET_MOCKS();
 
   // On the fling start, we should schedule an animation but not actually start
   // scrolling.
   base::TimeDelta dt = base::TimeDelta::FromMilliseconds(10);
   base::TimeTicks time = base::TimeTicks() + dt;
   WebFloatPoint fling_delta = WebFloatPoint(100, 0);
@@ skipping 59 matching lines @@
   cc::InputHandlerScrollResult overscroll;
   overscroll.did_scroll = true;
   overscroll.did_overscroll_root = true;
 
   // We shouldn't send any events to the widget for this gesture.
   expected_disposition_ = InputHandlerProxy::DID_HANDLE;
   VERIFY_AND_RESET_MOCKS();
 
   EXPECT_CALL(mock_input_handler_, ScrollBegin(testing::_, testing::_))
       .WillOnce(testing::Return(kImplThreadScrollState));
-  gesture_.type = WebInputEvent::GestureScrollBegin;
+  gesture_.setType(WebInputEvent::GestureScrollBegin);
   gesture_.sourceDevice = blink::WebGestureDeviceTouchscreen;
   EXPECT_EQ(expected_disposition_, input_handler_->HandleInputEvent(gesture_));
   VERIFY_AND_RESET_MOCKS();
 
   // On the fling start, we should schedule an animation but not actually start
   // scrolling.
-  gesture_.type = WebInputEvent::GestureFlingStart;
+  gesture_.setType(WebInputEvent::GestureFlingStart);
   WebFloatPoint fling_delta = WebFloatPoint(100, 100);
   gesture_.data.flingStart.velocityX = fling_delta.x;
   gesture_.data.flingStart.velocityY = fling_delta.y;
   EXPECT_CALL(mock_input_handler_, FlingScrollBegin())
       .WillOnce(testing::Return(kImplThreadScrollState));
   EXPECT_SET_NEEDS_ANIMATE_INPUT(1);
   EXPECT_EQ(expected_disposition_, input_handler_->HandleInputEvent(gesture_));
   VERIFY_AND_RESET_MOCKS();
 
   // The first animate doesn't cause any scrolling.
@@ skipping 82 matching lines @@
       .WillOnce(testing::Return(cc::EventListenerProperties::kNone));
   EXPECT_CALL(
       mock_input_handler_,
       GetEventListenerProperties(cc::EventListenerClass::kTouchEndOrCancel))
       .WillOnce(testing::Return(cc::EventListenerProperties::kNone));
   EXPECT_CALL(mock_input_handler_, EventListenerTypeForTouchStartAt(testing::_))
       .Times(2)
       .WillRepeatedly(testing::Return(
           cc::InputHandler::TouchStartEventListenerType::NO_HANDLER));
 
-  WebTouchEvent touch;
-  touch.type = WebInputEvent::TouchStart;
+  WebTouchEvent touch(WebInputEvent::TouchStart, WebInputEvent::NoModifiers,
+                      WebInputEvent::TimeStampForTesting);
 
   touch.touchesLength = 3;
   touch.touches[0] = CreateWebTouchPoint(WebTouchPoint::StateStationary, 0, 0);
   touch.touches[1] = CreateWebTouchPoint(WebTouchPoint::StatePressed, 10, 10);
   touch.touches[2] = CreateWebTouchPoint(WebTouchPoint::StatePressed, -10, 10);
   EXPECT_EQ(expected_disposition_, input_handler_->HandleInputEvent(touch));
 
   VERIFY_AND_RESET_MOCKS();
 }
 
 TEST_P(InputHandlerProxyTest, MultiTouchPointHitTestPositive) {
   // One of the touch points is on a touch-region. So the event should be sent
   // to the main thread.
   expected_disposition_ = InputHandlerProxy::DID_NOT_HANDLE;
   VERIFY_AND_RESET_MOCKS();
 
   EXPECT_CALL(mock_input_handler_,
               EventListenerTypeForTouchStartAt(
                   testing::Property(&gfx::Point::x, testing::Eq(0))))
       .WillOnce(testing::Return(
           cc::InputHandler::TouchStartEventListenerType::NO_HANDLER));
   EXPECT_CALL(mock_input_handler_,
               EventListenerTypeForTouchStartAt(
                   testing::Property(&gfx::Point::x, testing::Gt(0))))
       .WillOnce(testing::Return(cc::InputHandler::TouchStartEventListenerType::
                                     HANDLER_ON_SCROLLING_LAYER));
   // Since the second touch point hits a touch-region, there should be no
   // hit-testing for the third touch point.
 
-  WebTouchEvent touch;
-  touch.type = WebInputEvent::TouchStart;
+  WebTouchEvent touch(WebInputEvent::TouchStart, WebInputEvent::NoModifiers,
+                      WebInputEvent::TimeStampForTesting);
 
   touch.touchesLength = 3;
   touch.touches[0] = CreateWebTouchPoint(WebTouchPoint::StatePressed, 0, 0);
   touch.touches[1] = CreateWebTouchPoint(WebTouchPoint::StatePressed, 10, 10);
   touch.touches[2] = CreateWebTouchPoint(WebTouchPoint::StatePressed, -10, 10);
   EXPECT_EQ(expected_disposition_, input_handler_->HandleInputEvent(touch));
 
   VERIFY_AND_RESET_MOCKS();
 }
 
 TEST_P(InputHandlerProxyTest, MultiTouchPointHitTestPassivePositive) {
   // One of the touch points is not on a touch-region. So the event should be
   // sent to the impl thread.
   expected_disposition_ = InputHandlerProxy::DID_HANDLE_NON_BLOCKING;
   VERIFY_AND_RESET_MOCKS();
 
   EXPECT_CALL(
       mock_input_handler_,
       GetEventListenerProperties(cc::EventListenerClass::kTouchStartOrMove))
       .WillRepeatedly(testing::Return(cc::EventListenerProperties::kPassive));
   EXPECT_CALL(mock_input_handler_, EventListenerTypeForTouchStartAt(testing::_))
       .WillRepeatedly(testing::Return(
           cc::InputHandler::TouchStartEventListenerType::NO_HANDLER));
 
-  WebTouchEvent touch;
-  touch.type = WebInputEvent::TouchStart;
+  WebTouchEvent touch(WebInputEvent::TouchStart, WebInputEvent::NoModifiers,
+                      WebInputEvent::TimeStampForTesting);
 
   touch.touchesLength = 3;
   touch.touches[0] = CreateWebTouchPoint(WebTouchPoint::StatePressed, 0, 0);
   touch.touches[1] = CreateWebTouchPoint(WebTouchPoint::StatePressed, 10, 10);
   touch.touches[2] = CreateWebTouchPoint(WebTouchPoint::StatePressed, -10, 10);
   EXPECT_EQ(expected_disposition_, input_handler_->HandleInputEvent(touch));
 
   VERIFY_AND_RESET_MOCKS();
 }
 
 TEST_P(InputHandlerProxyTest, TouchStartPassiveAndTouchEndBlocking) {
   // The touch start is not in a touch-region but there is a touch end handler
   // so to maintain targeting we need to dispatch the touch start as
   // non-blocking but drop all touch moves.
   expected_disposition_ = InputHandlerProxy::DID_HANDLE_NON_BLOCKING;
   VERIFY_AND_RESET_MOCKS();
 
   EXPECT_CALL(
       mock_input_handler_,
       GetEventListenerProperties(cc::EventListenerClass::kTouchStartOrMove))
       .WillOnce(testing::Return(cc::EventListenerProperties::kNone));
   EXPECT_CALL(
       mock_input_handler_,
       GetEventListenerProperties(cc::EventListenerClass::kTouchEndOrCancel))
       .WillOnce(testing::Return(cc::EventListenerProperties::kBlocking));
   EXPECT_CALL(mock_input_handler_, EventListenerTypeForTouchStartAt(testing::_))
       .WillOnce(testing::Return(
           cc::InputHandler::TouchStartEventListenerType::NO_HANDLER));
 
-  WebTouchEvent touch;
-  touch.type = WebInputEvent::TouchStart;
+  WebTouchEvent touch(WebInputEvent::TouchStart, WebInputEvent::NoModifiers,
+                      WebInputEvent::TimeStampForTesting);
   touch.touchesLength = 1;
   touch.touches[0] = CreateWebTouchPoint(WebTouchPoint::StatePressed, 0, 0);
   EXPECT_EQ(expected_disposition_, input_handler_->HandleInputEvent(touch));
 
-  touch.type = WebInputEvent::TouchMove;
+  touch.setType(WebInputEvent::TouchMove);
   touch.touchesLength = 1;
   touch.touches[0] = CreateWebTouchPoint(WebTouchPoint::StatePressed, 10, 10);
   EXPECT_EQ(InputHandlerProxy::DROP_EVENT,
             input_handler_->HandleInputEvent(touch));
   VERIFY_AND_RESET_MOCKS();
 }
 
 TEST_P(InputHandlerProxyTest, GestureFlingCancelledByKeyboardEvent) {
   // We shouldn't send any events to the widget for this gesture.
   expected_disposition_ = InputHandlerProxy::DID_HANDLE;
   VERIFY_AND_RESET_MOCKS();
 
   EXPECT_CALL(mock_input_handler_, ScrollBegin(testing::_, testing::_))
       .WillOnce(testing::Return(kImplThreadScrollState));
-  gesture_.type = WebInputEvent::GestureScrollBegin;
+  gesture_.setType(WebInputEvent::GestureScrollBegin);
   gesture_.sourceDevice = blink::WebGestureDeviceTouchscreen;
   EXPECT_EQ(expected_disposition_, input_handler_->HandleInputEvent(gesture_));
   EXPECT_TRUE(input_handler_->gesture_scroll_on_impl_thread_for_testing());
   VERIFY_AND_RESET_MOCKS();
 
   // Keyboard events received during a scroll should have no effect.
-  WebKeyboardEvent key_event;
-  key_event.type = WebInputEvent::KeyDown;
+  WebKeyboardEvent key_event(WebInputEvent::KeyDown, WebInputEvent::NoModifiers,
+                             WebInputEvent::TimeStampForTesting);
   EXPECT_EQ(InputHandlerProxy::DID_NOT_HANDLE,
             input_handler_->HandleInputEvent(key_event));
   EXPECT_TRUE(input_handler_->gesture_scroll_on_impl_thread_for_testing());
   VERIFY_AND_RESET_MOCKS();
 
   // On the fling start, animation should be scheduled, but no scrolling occurs.
-  gesture_.type = WebInputEvent::GestureFlingStart;
+  gesture_.setType(WebInputEvent::GestureFlingStart);
   WebFloatPoint fling_delta = WebFloatPoint(100, 100);
   gesture_.data.flingStart.velocityX = fling_delta.x;
   gesture_.data.flingStart.velocityY = fling_delta.y;
   EXPECT_CALL(mock_input_handler_, FlingScrollBegin())
       .WillOnce(testing::Return(kImplThreadScrollState));
   EXPECT_SET_NEEDS_ANIMATE_INPUT(1);
   EXPECT_EQ(expected_disposition_, input_handler_->HandleInputEvent(gesture_));
   EXPECT_TRUE(input_handler_->gesture_scroll_on_impl_thread_for_testing());
   VERIFY_AND_RESET_MOCKS();
 
   // Keyboard events received during a fling should cancel the active fling.
   EXPECT_CALL(mock_input_handler_, ScrollEnd(testing::_));
   EXPECT_EQ(InputHandlerProxy::DID_NOT_HANDLE,
             input_handler_->HandleInputEvent(key_event));
   EXPECT_FALSE(input_handler_->gesture_scroll_on_impl_thread_for_testing());
   VERIFY_AND_RESET_MOCKS();
 
   // The call to animate should have no effect, as the fling was cancelled.
   base::TimeTicks time = base::TimeTicks() + base::TimeDelta::FromSeconds(10);
   Animate(time);
   VERIFY_AND_RESET_MOCKS();
 
   // A fling cancel should be dropped, as there is nothing to cancel.
-  gesture_.type = WebInputEvent::GestureFlingCancel;
+  gesture_.setType(WebInputEvent::GestureFlingCancel);
   EXPECT_EQ(InputHandlerProxy::DROP_EVENT,
             input_handler_->HandleInputEvent(gesture_));
   EXPECT_FALSE(input_handler_->gesture_scroll_on_impl_thread_for_testing());
 }
 
 TEST_P(InputHandlerProxyTest, GestureFlingCancelledByWheelEvent) {
   // We shouldn't send any events to the widget for this gesture.
   expected_disposition_ = InputHandlerProxy::DID_HANDLE;
   VERIFY_AND_RESET_MOCKS();
 
   EXPECT_CALL(mock_input_handler_, ScrollBegin(testing::_, testing::_))
       .WillOnce(testing::Return(kImplThreadScrollState));
 
-  gesture_.type = WebInputEvent::GestureScrollBegin;
+  gesture_.setType(WebInputEvent::GestureScrollBegin);
   gesture_.sourceDevice = blink::WebGestureDeviceTouchscreen;
   EXPECT_EQ(expected_disposition_, input_handler_->HandleInputEvent(gesture_));
   EXPECT_TRUE(input_handler_->gesture_scroll_on_impl_thread_for_testing());
   VERIFY_AND_RESET_MOCKS();
 
   // Wheel events received during a scroll shouldn't cancel the fling, but will
   // cause scrolling.
   cc::InputHandlerScrollResult result;
 
   EXPECT_CALL(mock_input_handler_,
               GetEventListenerProperties(cc::EventListenerClass::kMouseWheel))
       .WillOnce(testing::Return(cc::EventListenerProperties::kBlocking));
 
-  WebMouseWheelEvent wheel_event;
-  wheel_event.type = WebInputEvent::MouseWheel;
+  WebMouseWheelEvent wheel_event(WebInputEvent::MouseWheel,
+                                 WebInputEvent::NoModifiers,
+                                 WebInputEvent::TimeStampForTesting);
   input_handler_->HandleInputEvent(wheel_event);
   EXPECT_TRUE(input_handler_->gesture_scroll_on_impl_thread_for_testing());
   VERIFY_AND_RESET_MOCKS();
 
   // On the fling start, animation should be scheduled, but no scrolling occurs.
-  gesture_.type = WebInputEvent::GestureFlingStart;
+  gesture_.setType(WebInputEvent::GestureFlingStart);
   WebFloatPoint fling_delta = WebFloatPoint(100, 100);
   gesture_.data.flingStart.velocityX = fling_delta.x;
   gesture_.data.flingStart.velocityY = fling_delta.y;
   EXPECT_CALL(mock_input_handler_, FlingScrollBegin())
       .WillOnce(testing::Return(kImplThreadScrollState));
   EXPECT_SET_NEEDS_ANIMATE_INPUT(1);
   EXPECT_EQ(expected_disposition_, input_handler_->HandleInputEvent(gesture_));
   EXPECT_TRUE(input_handler_->gesture_scroll_on_impl_thread_for_testing());
   VERIFY_AND_RESET_MOCKS();
 
   // Wheel events received during a fling should cancel the active fling, and
   // cause a scroll.
   EXPECT_CALL(mock_input_handler_, ScrollEnd(testing::_));
 
   EXPECT_CALL(mock_input_handler_,
               GetEventListenerProperties(cc::EventListenerClass::kMouseWheel))
       .WillOnce(testing::Return(cc::EventListenerProperties::kBlocking));
 
 
   input_handler_->HandleInputEvent(wheel_event);
   EXPECT_FALSE(input_handler_->gesture_scroll_on_impl_thread_for_testing());
   VERIFY_AND_RESET_MOCKS();
 
   // The call to animate should have no effect, as the fling was cancelled.
   base::TimeTicks time = base::TimeTicks() + base::TimeDelta::FromSeconds(10);
   Animate(time);
   VERIFY_AND_RESET_MOCKS();
 
   // A fling cancel should be dropped, as there is nothing to cancel.
-  gesture_.type = WebInputEvent::GestureFlingCancel;
+  gesture_.setType(WebInputEvent::GestureFlingCancel);
   EXPECT_EQ(InputHandlerProxy::DROP_EVENT,
             input_handler_->HandleInputEvent(gesture_));
   EXPECT_FALSE(input_handler_->gesture_scroll_on_impl_thread_for_testing());
 }
 
 TEST_P(InputHandlerProxyTest, GestureFlingWithNegativeTimeDelta) {
   // We shouldn't send any events to the widget for this gesture.
   expected_disposition_ = InputHandlerProxy::DID_HANDLE;
   VERIFY_AND_RESET_MOCKS();
 
   EXPECT_CALL(mock_input_handler_, ScrollBegin(testing::_, testing::_))
       .WillOnce(testing::Return(kImplThreadScrollState));
 
-  gesture_.type = WebInputEvent::GestureScrollBegin;
+  gesture_.setType(WebInputEvent::GestureScrollBegin);
   gesture_.sourceDevice = blink::WebGestureDeviceTouchscreen;
   EXPECT_EQ(expected_disposition_, input_handler_->HandleInputEvent(gesture_));
 
   VERIFY_AND_RESET_MOCKS();
 
   // On the fling start, we should schedule an animation but not actually start
   // scrolling.
   base::TimeDelta dt = base::TimeDelta::FromMilliseconds(10);
   base::TimeTicks time = base::TimeTicks() + dt;
   WebFloatPoint fling_delta = WebFloatPoint(100, 0);
@@ skipping 29 matching lines @@
   EXPECT_CALL(
       mock_input_handler_,
       ScrollBy(testing::Property(&cc::ScrollState::delta_x, testing::Lt(0))))
       .WillOnce(testing::Return(scroll_result_did_scroll_));
 
   Animate(time + base::TimeDelta::FromMilliseconds(1));
 
   VERIFY_AND_RESET_MOCKS();
 
   EXPECT_CALL(mock_input_handler_, ScrollEnd(testing::_));
-  gesture_.type = WebInputEvent::GestureFlingCancel;
+  gesture_.setType(WebInputEvent::GestureFlingCancel);
   EXPECT_EQ(expected_disposition_, input_handler_->HandleInputEvent(gesture_));
 
   VERIFY_AND_RESET_MOCKS();
 }
 
 TEST_P(InputHandlerProxyTest, FlingBoost) {
   base::TimeDelta dt = base::TimeDelta::FromMilliseconds(10);
   base::TimeTicks time = base::TimeTicks() + dt;
   base::TimeTicks last_animate_time = time;
   WebFloatPoint fling_delta = WebFloatPoint(1000, 0);
   WebPoint fling_point = WebPoint(7, 13);
   StartFling(
       time, blink::WebGestureDeviceTouchscreen, fling_delta, fling_point);
 
   // Now cancel the fling.  The fling cancellation should be deferred to allow
   // fling boosting events to arrive.
   time += dt;
   CancelFling(time);
 
   // The GestureScrollBegin should be swallowed by the fling if it hits the same
   // scrolling layer.
   EXPECT_CALL(mock_input_handler_,
               IsCurrentlyScrollingLayerAt(testing::_, testing::_))
       .WillOnce(testing::Return(true));
 
   time += dt;
-  gesture_.timeStampSeconds = InSecondsF(time);
-  gesture_.type = WebInputEvent::GestureScrollBegin;
+  gesture_.setTimeStampSeconds(InSecondsF(time));
+  gesture_.setType(WebInputEvent::GestureScrollBegin);
   EXPECT_EQ(expected_disposition_, input_handler_->HandleInputEvent(gesture_));
 
   VERIFY_AND_RESET_MOCKS();
 
   // Animate calls within the deferred cancellation window should continue.
   time += dt;
   float expected_delta =
       (time - last_animate_time).InSecondsF() * -fling_delta.x;
   EXPECT_SET_NEEDS_ANIMATE_INPUT(1);
   EXPECT_CALL(mock_input_handler_,
               ScrollBy(testing::Property(&cc::ScrollState::delta_x,
                                          testing::Eq(expected_delta))))
       .WillOnce(testing::Return(scroll_result_did_scroll_));
   Animate(time);
   last_animate_time = time;
 
   VERIFY_AND_RESET_MOCKS();
 
   // GestureScrollUpdates in the same direction and at sufficient speed should
   // be swallowed by the fling.
   time += dt;
-  gesture_.timeStampSeconds = InSecondsF(time);
-  gesture_.type = WebInputEvent::GestureScrollUpdate;
+  gesture_.setTimeStampSeconds(InSecondsF(time));
+  gesture_.setType(WebInputEvent::GestureScrollUpdate);
   gesture_.data.scrollUpdate.deltaX = fling_delta.x;
   EXPECT_EQ(expected_disposition_, input_handler_->HandleInputEvent(gesture_));
 
   VERIFY_AND_RESET_MOCKS();
 
   // Animate calls within the deferred cancellation window should continue.
   time += dt;
   expected_delta = (time - last_animate_time).InSecondsF() * -fling_delta.x;
   EXPECT_SET_NEEDS_ANIMATE_INPUT(1);
   EXPECT_CALL(mock_input_handler_,
@@ skipping 52 matching lines @@
       .WillOnce(testing::Return(scroll_result_did_scroll_));
   Animate(time);
   last_animate_time = time;
 
   VERIFY_AND_RESET_MOCKS();
 
   // GestureFlingCancel should terminate the fling if no boosting gestures are
   // received within the timeout window.
 
   time += dt;
-  gesture_.timeStampSeconds = InSecondsF(time);
-  gesture_.type = WebInputEvent::GestureFlingCancel;
+  gesture_.setTimeStampSeconds(InSecondsF(time));
+  gesture_.setType(WebInputEvent::GestureFlingCancel);
   EXPECT_EQ(expected_disposition_, input_handler_->HandleInputEvent(gesture_));
 
   VERIFY_AND_RESET_MOCKS();
 
   time += base::TimeDelta::FromMilliseconds(100);
   EXPECT_CALL(mock_input_handler_, ScrollEnd(testing::_));
   Animate(time);
 
   VERIFY_AND_RESET_MOCKS();
 }
@@ skipping 14 matching lines @@
   // If the GestureScrollBegin targets a different layer, the fling should be
   // cancelled and the scroll should be handled as usual.
   EXPECT_CALL(mock_input_handler_,
               IsCurrentlyScrollingLayerAt(testing::_, testing::_))
       .WillOnce(testing::Return(false));
   EXPECT_CALL(mock_input_handler_, ScrollEnd(testing::_));
   EXPECT_CALL(mock_input_handler_, ScrollBegin(testing::_, testing::_))
       .WillOnce(testing::Return(kImplThreadScrollState));
 
   time += dt;
-  gesture_.timeStampSeconds = InSecondsF(time);
-  gesture_.type = WebInputEvent::GestureScrollBegin;
+  gesture_.setTimeStampSeconds(InSecondsF(time));
+  gesture_.setType(WebInputEvent::GestureScrollBegin);
   EXPECT_EQ(expected_disposition_, input_handler_->HandleInputEvent(gesture_));
 
   VERIFY_AND_RESET_MOCKS();
 }
 
 TEST_P(InputHandlerProxyTest, NoFlingBoostIfScrollDelayed) {
   base::TimeDelta dt = base::TimeDelta::FromMilliseconds(10);
   base::TimeTicks time = base::TimeTicks() + dt;
   WebFloatPoint fling_delta = WebFloatPoint(1000, 0);
   WebPoint fling_point = WebPoint(7, 13);
   StartFling(
       time, blink::WebGestureDeviceTouchscreen, fling_delta, fling_point);
 
   // Cancel the fling.  The fling cancellation should be deferred to allow
   // fling boosting events to arrive.
   time += dt;
   CancelFling(time);
 
   // The GestureScrollBegin should be swallowed by the fling if it hits the same
   // scrolling layer.
   EXPECT_CALL(mock_input_handler_,
               IsCurrentlyScrollingLayerAt(testing::_, testing::_))
       .WillOnce(testing::Return(true));
 
   time += dt;
-  gesture_.timeStampSeconds = InSecondsF(time);
-  gesture_.type = WebInputEvent::GestureScrollBegin;
+  gesture_.setTimeStampSeconds(InSecondsF(time));
+  gesture_.setType(WebInputEvent::GestureScrollBegin);
   EXPECT_EQ(expected_disposition_, input_handler_->HandleInputEvent(gesture_));
 
   VERIFY_AND_RESET_MOCKS();
 
   // If no GestureScrollUpdate or GestureFlingStart is received within the
   // timeout window, the fling should be cancelled and scrolling should resume.
   time += base::TimeDelta::FromMilliseconds(100);
   EXPECT_CALL(mock_input_handler_, ScrollEnd(testing::_));
   EXPECT_CALL(mock_input_handler_, ScrollBegin(testing::_, testing::_))
       .WillOnce(testing::Return(kImplThreadScrollState));
@@ skipping 22 matching lines @@
   time += base::TimeDelta::FromMilliseconds(100);
   CancelFling(time);
 
   // The GestureScrollBegin should be swallowed by the fling if it hits the same
   // scrolling layer.
   EXPECT_CALL(mock_input_handler_,
               IsCurrentlyScrollingLayerAt(testing::_, testing::_))
       .WillOnce(testing::Return(true));
 
   time += dt;
-  gesture_.timeStampSeconds = InSecondsF(time);
-  gesture_.type = WebInputEvent::GestureScrollBegin;
+  gesture_.setTimeStampSeconds(InSecondsF(time));
+  gesture_.setType(WebInputEvent::GestureScrollBegin);
   EXPECT_EQ(expected_disposition_, input_handler_->HandleInputEvent(gesture_));
 
   VERIFY_AND_RESET_MOCKS();
 
   // Should exit scroll bosting on GestureScrollUpdate due to long delay
   // since last animate. Cancel old fling and start new scroll.
-  gesture_.type = WebInputEvent::GestureScrollUpdate;
+  gesture_.setType(WebInputEvent::GestureScrollUpdate);
   gesture_.data.scrollUpdate.deltaY = -40;
   EXPECT_CALL(mock_input_handler_, ScrollEnd(testing::_));
   EXPECT_CALL(mock_input_handler_, ScrollBegin(testing::_, testing::_))
       .WillOnce(testing::Return(kImplThreadScrollState));
   EXPECT_CALL(mock_input_handler_, ScrollBy(testing::_))
       .WillOnce(testing::Return(scroll_result_did_scroll_));
   EXPECT_EQ(expected_disposition_, input_handler_->HandleInputEvent(gesture_));
 
   VERIFY_AND_RESET_MOCKS();
 }
@@ skipping 52 matching lines @@
   time += dt;
   CancelFling(time);
 
   // The GestureScrollBegin should be swallowed by the fling if it hits the same
   // scrolling layer.
   EXPECT_CALL(mock_input_handler_,
               IsCurrentlyScrollingLayerAt(testing::_, testing::_))
       .WillOnce(testing::Return(true));
 
   time += dt;
-  gesture_.timeStampSeconds = InSecondsF(time);
-  gesture_.type = WebInputEvent::GestureScrollBegin;
+  gesture_.setTimeStampSeconds(InSecondsF(time));
+  gesture_.setType(WebInputEvent::GestureScrollBegin);
   EXPECT_EQ(expected_disposition_, input_handler_->HandleInputEvent(gesture_));
 
   VERIFY_AND_RESET_MOCKS();
 
   // If the GestureScrollUpdate is in a different direction than the fling,
   // the fling should be cancelled and scrolling should resume.
   time += dt;
-  gesture_.timeStampSeconds = InSecondsF(time);
-  gesture_.type = WebInputEvent::GestureScrollUpdate;
+  gesture_.setTimeStampSeconds(InSecondsF(time));
+  gesture_.setType(WebInputEvent::GestureScrollUpdate);
   gesture_.data.scrollUpdate.deltaX = -fling_delta.x;
   EXPECT_CALL(mock_input_handler_, ScrollEnd(testing::_));
   EXPECT_CALL(mock_input_handler_, ScrollBegin(testing::_, testing::_))
       .WillOnce(testing::Return(kImplThreadScrollState));
   EXPECT_CALL(mock_input_handler_,
               ScrollBy(testing::Property(&cc::ScrollState::delta_x,
                                          testing::Eq(fling_delta.x))))
       .WillOnce(testing::Return(scroll_result_did_scroll_));
   EXPECT_EQ(expected_disposition_, input_handler_->HandleInputEvent(gesture_));
 
@@ skipping 68 matching lines @@
   StartFling(
       time, blink::WebGestureDeviceTouchscreen, fling_delta, fling_point);
 
   // Now cancel the fling.  The fling cancellation should be deferred to allow
   // fling boosting events to arrive.
   time += dt;
   CancelFling(time);
 
   // The GestureScrollBegin should be swallowed by the fling.
   time += dt;
-  gesture_.timeStampSeconds = InSecondsF(time);
-  gesture_.type = WebInputEvent::GestureScrollBegin;
+  gesture_.setTimeStampSeconds(InSecondsF(time));
+  gesture_.setType(WebInputEvent::GestureScrollBegin);
   EXPECT_CALL(mock_input_handler_,
               IsCurrentlyScrollingLayerAt(testing::_, testing::_))
       .WillOnce(testing::Return(true));
   EXPECT_EQ(expected_disposition_, input_handler_->HandleInputEvent(gesture_));
 
   VERIFY_AND_RESET_MOCKS();
 
   // Now animate the fling to completion (in this case, the fling should
   // terminate because the input handler reports a failed scroll). As the fling
   // was cancelled during an active scroll sequence, a synthetic
   // GestureScrollBegin should be processed, resuming the scroll.
   time += dt;
   float expected_delta =
       (time - last_animate_time).InSecondsF() * -fling_delta.x;
   EXPECT_CALL(mock_input_handler_,
               ScrollBy(testing::Property(&cc::ScrollState::delta_x,
                                          testing::Eq(expected_delta))))
       .WillOnce(testing::Return(scroll_result_did_not_scroll_));
   EXPECT_CALL(mock_input_handler_, ScrollEnd(testing::_));
   EXPECT_CALL(mock_input_handler_, ScrollBegin(testing::_, testing::_))
       .WillOnce(testing::Return(kImplThreadScrollState));
   Animate(time);
 
   VERIFY_AND_RESET_MOCKS();
 
   // Subsequent GestureScrollUpdates after the cancelled, boosted fling should
   // cause scrolling as usual.
   time += dt;
   expected_delta = 7.3f;
-  gesture_.timeStampSeconds = InSecondsF(time);
-  gesture_.type = WebInputEvent::GestureScrollUpdate;
+  gesture_.setTimeStampSeconds(InSecondsF(time));
+  gesture_.setType(WebInputEvent::GestureScrollUpdate);
   gesture_.data.scrollUpdate.deltaX = -expected_delta;
   EXPECT_CALL(mock_input_handler_,
               ScrollBy(testing::Property(&cc::ScrollState::delta_x,
                                          testing::Eq(expected_delta))))
       .WillOnce(testing::Return(scroll_result_did_scroll_));
   EXPECT_EQ(expected_disposition_, input_handler_->HandleInputEvent(gesture_));
 
   VERIFY_AND_RESET_MOCKS();
 
   // GestureScrollEnd should terminate the resumed scroll properly.
   time += dt;
-  gesture_.timeStampSeconds = InSecondsF(time);
-  gesture_.type = WebInputEvent::GestureScrollEnd;
+  gesture_.setTimeStampSeconds(InSecondsF(time));
+  gesture_.setType(WebInputEvent::GestureScrollEnd);
   EXPECT_CALL(mock_input_handler_, ScrollEnd(testing::_));
   EXPECT_EQ(expected_disposition_, input_handler_->HandleInputEvent(gesture_));
 
   VERIFY_AND_RESET_MOCKS();
 }
 
 TEST_P(InputHandlerProxyTest, DidReceiveInputEvent_ForFling) {
   testing::StrictMock<MockInputHandlerProxyClientWithDidAnimateForInput>
       mock_client;
   input_handler_.reset(
         new TestInputHandlerProxy(
             &mock_input_handler_, &mock_client));
   if (install_synchronous_handler_) {
     EXPECT_CALL(mock_input_handler_, RequestUpdateForSynchronousInputHandler())
         .Times(1);
     input_handler_->SetOnlySynchronouslyAnimateRootFlings(
         &mock_synchronous_input_handler_);
   }
   mock_input_handler_.set_is_scrolling_root(synchronous_root_scroll_);
 
-  gesture_.type = WebInputEvent::GestureFlingStart;
+  gesture_.setType(WebInputEvent::GestureFlingStart);
   WebFloatPoint fling_delta = WebFloatPoint(100, 100);
   gesture_.data.flingStart.velocityX = fling_delta.x;
   gesture_.data.flingStart.velocityY = fling_delta.y;
   EXPECT_SET_NEEDS_ANIMATE_INPUT(1);
   EXPECT_CALL(mock_input_handler_, ScrollBegin(testing::_, testing::_))
       .WillOnce(testing::Return(kImplThreadScrollState));
   EXPECT_CALL(mock_input_handler_, ScrollEnd(testing::_));
   EXPECT_EQ(InputHandlerProxy::DID_HANDLE,
       input_handler_->HandleInputEvent(gesture_));
   VERIFY_AND_RESET_MOCKS();
@@ skipping 328 matching lines @@
   EXPECT_EQ(WebInputEvent::GesturePinchEnd, event_queue()[6]->event().type);
   testing::Mock::VerifyAndClearExpectations(&mock_input_handler_);
 }
 
 INSTANTIATE_TEST_CASE_P(AnimateInput,
                         InputHandlerProxyTest,
                         testing::ValuesIn(test_types));
 
 }  // namespace test
 }  // namespace ui