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

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>
 
 #include "base/location.h"
 #include "base/logging.h"
 #include "base/message_loop/message_loop.h"
 #include "base/run_loop.h"
 #include "base/single_thread_task_runner.h"
 #include "base/threading/thread_task_runner_handle.h"
 #include "content/browser/renderer_host/input/timeout_monitor.h"
 #include "content/common/input/synthetic_web_input_event_builders.h"
 #include "content/common/input/web_touch_event_traits.h"
 #include "testing/gtest/include/gtest/gtest.h"
 #include "third_party/WebKit/public/platform/WebInputEvent.h"
+#include "ui/events/base_event_utils.h"
 
 using blink::WebGestureEvent;
 using blink::WebInputEvent;
 using blink::WebTouchEvent;
 using blink::WebTouchPoint;
 
 namespace content {
 namespace {
 
 const double kMinSecondsBetweenThrottledTouchmoves = 0.2;
@@ skipping 85 matching lines @@
         if (delta.LengthSquared() > slop_length_dips_ * slop_length_dips_)
           event.movedBeyondSlopRegion = true;
       }
     } else {
       event.movedBeyondSlopRegion = event.type == WebInputEvent::TouchMove;
     }
     queue_->QueueEvent(TouchEventWithLatencyInfo(event, ui::LatencyInfo()));
   }
 
   void SendGestureEvent(WebInputEvent::Type type) {
-    WebGestureEvent event;
-    event.type = type;
+    WebGestureEvent event(type, WebInputEvent::NoModifiers,
+                          ui::EventTimeStampToSeconds(ui::EventTimeForNow()));
     queue_->OnGestureScrollEvent(
         GestureEventWithLatencyInfo(event, ui::LatencyInfo()));
   }
 
   void SendTouchEventAck(InputEventAckState ack_result) {
     DCHECK(!sent_events_ids_.empty());
     queue_->ProcessTouchAck(ack_result, ui::LatencyInfo(),
                             sent_events_ids_.front());
     sent_events_ids_.pop_front();
   }
 
   void SendTouchEventAckWithID(InputEventAckState ack_result,
                                int unique_event_id) {
     queue_->ProcessTouchAck(ack_result, ui::LatencyInfo(), unique_event_id);
     sent_events_ids_.erase(std::remove(sent_events_ids_.begin(),
                                        sent_events_ids_.end(), unique_event_id),
                            sent_events_ids_.end());
   }
 
   void SendGestureEventAck(WebInputEvent::Type type,
                            InputEventAckState ack_result) {
-    blink::WebGestureEvent gesture_event;
-    gesture_event.type = type;
-    GestureEventWithLatencyInfo event(gesture_event, ui::LatencyInfo());
+    GestureEventWithLatencyInfo event(
+        type, blink::WebInputEvent::NoModifiers,
+        ui::EventTimeStampToSeconds(ui::EventTimeForNow()), ui::LatencyInfo());
     queue_->OnGestureEventAck(event, ack_result);
   }
 
   void SetFollowupEvent(const WebTouchEvent& event) {
     followup_touch_event_.reset(new WebTouchEvent(event));
   }
 
   void SetFollowupEvent(const WebGestureEvent& event) {
     followup_gesture_event_.reset(new WebGestureEvent(event));
   }
@@ skipping 71 matching lines @@
   void CancelTouchPoint(int index) {
     touch_event_.CancelPoint(index);
     SendTouchEvent();
   }
 
   void PrependTouchScrollNotification() {
     queue_->PrependTouchScrollNotification();
   }
 
   void AdvanceTouchTime(double seconds) {
-    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 579 matching lines @@
 // Tests that touch-event's enqueued via a touch ack are properly handled.
 TEST_F(TouchEventQueueTest, AckWithFollowupEvents) {
   // Queue a touch down.
   PressTouchPoint(1, 1);
   EXPECT_EQ(1U, queued_event_count());
   EXPECT_EQ(1U, GetAndResetSentEventCount());
   EXPECT_EQ(0U, GetAndResetAckedEventCount());
 
   // Create a touch event that will be queued synchronously by a touch ack.
   // Note, this will be triggered by all subsequent touch acks.
-  WebTouchEvent followup_event;
-  followup_event.type = WebInputEvent::TouchMove;
+  WebTouchEvent followup_event(
+      WebInputEvent::TouchMove, WebInputEvent::NoModifiers,
+      ui::EventTimeStampToSeconds(ui::EventTimeForNow()));
   followup_event.touchesLength = 1;
   followup_event.touches[0].id = 0;
   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());
@@ skipping 47 matching lines @@
   CancelTouchPoint(0);
   EXPECT_EQ(0U, queued_event_count());
   EXPECT_EQ(1U, GetAndResetSentEventCount());
   EXPECT_EQ(1U, GetAndResetAckedEventCount());
 }
 
 // Tests that followup events triggered by an immediate ack from
 // TouchEventQueue::QueueEvent() are properly handled.
 TEST_F(TouchEventQueueTest, ImmediateAckWithFollowupEvents) {
   // Create a touch event that will be queued synchronously by a touch ack.
-  WebTouchEvent followup_event;
-  followup_event.type = WebInputEvent::TouchStart;
+  WebTouchEvent followup_event(
+      WebInputEvent::TouchStart, WebInputEvent::NoModifiers,
+      ui::EventTimeStampToSeconds(ui::EventTimeForNow()));
   followup_event.touchesLength = 1;
   followup_event.touches[0].id = 1;
   followup_event.touches[0].state = WebTouchPoint::StatePressed;
   SetFollowupEvent(followup_event);
 
   // Now, enqueue a stationary touch that will not be forwarded.  This should be
   // immediately ack'ed with "NO_CONSUMER_EXISTS".  The followup event should
   // then be enqueued and immediately sent to the renderer.
-  WebTouchEvent stationary_event;
+  WebTouchEvent stationary_event(
+      WebInputEvent::TouchMove, WebInputEvent::NoModifiers,
+      ui::EventTimeStampToSeconds(ui::EventTimeForNow()));
+  ;
   stationary_event.touchesLength = 1;
-  stationary_event.type = WebInputEvent::TouchMove;
   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);
 }
@@ skipping 297 matching lines @@
 // turns into a scroll gesture sequence.
 TEST_F(TouchEventQueueTest, TouchTimeoutWithFollowupGesture) {
   SetUpForTimeoutTesting();
 
   // Queue a TouchStart.
   PressTouchPoint(0, 1);
   EXPECT_TRUE(IsTimeoutRunning());
   EXPECT_EQ(1U, GetAndResetSentEventCount());
 
   // The cancelled sequence may turn into a scroll gesture.
-  WebGestureEvent followup_scroll;
-  followup_scroll.type = WebInputEvent::GestureScrollBegin;
+  WebGestureEvent followup_scroll(
+      WebInputEvent::GestureScrollBegin, WebInputEvent::NoModifiers,
+      ui::EventTimeStampToSeconds(ui::EventTimeForNow()));
   SetFollowupEvent(followup_scroll);
 
   // Delay the ack.
   RunTasksAndWait(DefaultTouchTimeoutDelay() * 2);
 
   // The timeout should have fired, disabling touch forwarding until both acks
   // are received, acking the timed out event.
   EXPECT_FALSE(IsTimeoutRunning());
   EXPECT_EQ(0U, GetAndResetSentEventCount());
   EXPECT_EQ(1U, GetAndResetAckedEventCount());
@@ skipping 33 matching lines @@
 // significantly delayed.
 TEST_F(TouchEventQueueTest, TouchTimeoutWithFollowupGestureAndDelayedAck) {
   SetUpForTimeoutTesting();
 
   // Queue a TouchStart.
   PressTouchPoint(0, 1);
   EXPECT_TRUE(IsTimeoutRunning());
   EXPECT_EQ(1U, GetAndResetSentEventCount());
 
   // The cancelled sequence may turn into a scroll gesture.
-  WebGestureEvent followup_scroll;
-  followup_scroll.type = WebInputEvent::GestureScrollBegin;
+  WebGestureEvent followup_scroll(
+      WebInputEvent::GestureScrollBegin, WebInputEvent::NoModifiers,
+      ui::EventTimeStampToSeconds(ui::EventTimeForNow()));
   SetFollowupEvent(followup_scroll);
 
   // Delay the ack.
   RunTasksAndWait(DefaultTouchTimeoutDelay() * 2);
 
   // The timeout should have fired, disabling touch forwarding until both acks
   // are received and acking the timed out event.
   EXPECT_FALSE(IsTimeoutRunning());
   EXPECT_EQ(0U, GetAndResetSentEventCount());
   EXPECT_EQ(1U, GetAndResetAckedEventCount());
@@ skipping 262 matching lines @@
 
 // Tests that secondary touch points can be forwarded after scrolling begins
 // while first touch point has no consumer.
 TEST_F(TouchEventQueueTest, NoForwardingAfterScrollWithNoTouchConsumers) {
   // Queue a TouchStart.
   PressTouchPoint(0, 0);
   SendTouchEventAck(INPUT_EVENT_ACK_STATE_NO_CONSUMER_EXISTS);
   ASSERT_EQ(1U, GetAndResetSentEventCount());
   ASSERT_EQ(1U, GetAndResetAckedEventCount());
 
-  WebGestureEvent followup_scroll;
-  followup_scroll.type = WebInputEvent::GestureScrollBegin;
+  WebGestureEvent followup_scroll(WebInputEvent::GestureScrollBegin,
+                                  WebInputEvent::NoModifiers,
+                                  WebInputEvent::TimeStampForTesting);
   SetFollowupEvent(followup_scroll);
   MoveTouchPoint(0, 20, 5);
   EXPECT_EQ(0U, GetAndResetSentEventCount());
   EXPECT_EQ(1U, GetAndResetAckedEventCount());
   EXPECT_EQ(INPUT_EVENT_ACK_STATE_NO_CONSUMER_EXISTS, acked_event_state());
 
   // The secondary pointer press should be forwarded.
   PressTouchPoint(20, 0);
   SendTouchEventAck(INPUT_EVENT_ACK_STATE_CONSUMED);
   EXPECT_EQ(1U, GetAndResetSentEventCount());
@@ skipping 39 matching lines @@
 // scroll sequences that transitions between scrolls consumed and unconsumed.
 TEST_F(TouchEventQueueTest, AsyncTouchThrottledAfterScroll) {
   // Process a TouchStart
   PressTouchPoint(0, 1);
   EXPECT_EQ(1U, GetAndResetSentEventCount());
   SendTouchEventAck(INPUT_EVENT_ACK_STATE_NOT_CONSUMED);
   EXPECT_EQ(1U, GetAndResetAckedEventCount());
 
   // Now send the first touch move and associated GestureScrollBegin.
   MoveTouchPoint(0, 0, 5);
-  WebGestureEvent followup_scroll;
-  followup_scroll.type = WebInputEvent::GestureScrollBegin;
+  WebGestureEvent followup_scroll(WebInputEvent::GestureScrollBegin,
+                                  WebInputEvent::NoModifiers,
+                                  WebInputEvent::TimeStampForTesting);
   SetFollowupEvent(followup_scroll);
   SendTouchEventAck(INPUT_EVENT_ACK_STATE_NOT_CONSUMED);
   EXPECT_EQ(1U, GetAndResetSentEventCount());
   EXPECT_EQ(1U, GetAndResetAckedEventCount());
   SendGestureEventAck(WebInputEvent::GestureScrollBegin,
                       INPUT_EVENT_ACK_STATE_NOT_CONSUMED);
 
   // Send the second touch move and associated GestureScrollUpdate, but don't
   // ACK the gesture event yet.
   MoveTouchPoint(0, 0, 50);
-  followup_scroll.type = WebInputEvent::GestureScrollUpdate;
+  followup_scroll.setType(WebInputEvent::GestureScrollUpdate);
   SetFollowupEvent(followup_scroll);
   SendTouchEventAck(INPUT_EVENT_ACK_STATE_NOT_CONSUMED);
   EXPECT_EQ(1U, GetAndResetSentEventCount());
   EXPECT_EQ(1U, GetAndResetAckedEventCount());
 
   // Now queue a second touchmove and verify it's not (yet) dispatched.
   MoveTouchPoint(0, 0, 100);
   SetFollowupEvent(followup_scroll);
   EXPECT_TRUE(HasPendingAsyncTouchMove());
   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);
-  followup_scroll.type = WebInputEvent::GestureScrollEnd;
+  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_NE(WebInputEvent::Blocking, all_sent_events()[0].dispatchType);
   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());
@@ skipping 12 matching lines @@
   SendGestureEventAck(WebInputEvent::GestureScrollUpdate,
                       INPUT_EVENT_ACK_STATE_NOT_CONSUMED);
 
   // Start a new touch sequence and verify that throttling has been reset.
   // Touch moves after the start of scrolling will again be throttled.
   PressTouchPoint(0, 0);
   EXPECT_EQ(1U, GetAndResetSentEventCount());
   SendTouchEventAck(INPUT_EVENT_ACK_STATE_NOT_CONSUMED);
   EXPECT_EQ(1U, GetAndResetAckedEventCount());
   MoveTouchPoint(0, 0, 5);
-  followup_scroll.type = WebInputEvent::GestureScrollBegin;
+  followup_scroll.setType(WebInputEvent::GestureScrollBegin);
   SetFollowupEvent(followup_scroll);
   SendTouchEventAck(INPUT_EVENT_ACK_STATE_NOT_CONSUMED);
   EXPECT_EQ(1U, GetAndResetSentEventCount());
   EXPECT_EQ(1U, GetAndResetAckedEventCount());
 
   MoveTouchPoint(0, 0, 6);
-  followup_scroll.type = WebInputEvent::GestureScrollUpdate;
+  followup_scroll.setType(WebInputEvent::GestureScrollUpdate);
   SetFollowupEvent(followup_scroll);
   SendTouchEventAck(INPUT_EVENT_ACK_STATE_NOT_CONSUMED);
   EXPECT_FALSE(HasPendingAsyncTouchMove());
   EXPECT_EQ(1U, GetAndResetSentEventCount());
   EXPECT_EQ(1U, GetAndResetAckedEventCount());
 
   MoveTouchPoint(0, 0, 10);
   EXPECT_TRUE(HasPendingAsyncTouchMove());
   EXPECT_EQ(0U, queued_event_count());
   EXPECT_EQ(0U, GetAndResetSentEventCount());
@@ skipping 94 matching lines @@
 }
 
 TEST_F(TouchEventQueueTest, AsyncTouchFlushedByTouchEnd) {
   PressTouchPoint(0, 0);
   SendTouchEventAck(INPUT_EVENT_ACK_STATE_NOT_CONSUMED);
   EXPECT_EQ(1U, GetAndResetSentEventCount());
   EXPECT_EQ(1U, GetAndResetAckedEventCount());
 
   // Initiate async touchmove dispatch after the start of a scroll sequence.
   MoveTouchPoint(0, 0, 5);
-  WebGestureEvent followup_scroll;
-  followup_scroll.type = WebInputEvent::GestureScrollBegin;
+  WebGestureEvent followup_scroll(WebInputEvent::GestureScrollBegin,
+                                  WebInputEvent::NoModifiers,
+                                  WebInputEvent::TimeStampForTesting);
   SetFollowupEvent(followup_scroll);
   SendTouchEventAck(INPUT_EVENT_ACK_STATE_NOT_CONSUMED);
   EXPECT_EQ(1U, GetAndResetSentEventCount());
   EXPECT_EQ(1U, GetAndResetAckedEventCount());
 
   MoveTouchPoint(0, 0, 10);
-  followup_scroll.type = WebInputEvent::GestureScrollUpdate;
+  followup_scroll.setType(WebInputEvent::GestureScrollUpdate);
   SetFollowupEvent(followup_scroll);
   SendTouchEventAck(INPUT_EVENT_ACK_STATE_NOT_CONSUMED);
   EXPECT_EQ(1U, GetAndResetSentEventCount());
   EXPECT_EQ(1U, GetAndResetAckedEventCount());
 
   // Now queue a second touchmove and verify it's not (yet) dispatched.
   MoveTouchPoint(0, 0, 100);
   EXPECT_TRUE(HasPendingAsyncTouchMove());
   EXPECT_EQ(0U, queued_event_count());
   EXPECT_EQ(0U, GetAndResetSentEventCount());
@@ skipping 33 matching lines @@
   EXPECT_EQ(1U, GetAndResetSentEventCount());
   EXPECT_TRUE(IsTimeoutRunning());
   SendTouchEventAck(INPUT_EVENT_ACK_STATE_NOT_CONSUMED);
   EXPECT_EQ(1U, GetAndResetAckedEventCount());
   EXPECT_FALSE(IsTimeoutRunning());
 
   // The start of a scroll gesture should trigger async touch event dispatch.
   MoveTouchPoint(0, 1, 1);
   EXPECT_EQ(1U, GetAndResetSentEventCount());
   EXPECT_TRUE(IsTimeoutRunning());
-  WebGestureEvent followup_scroll;
-  followup_scroll.type = WebInputEvent::GestureScrollBegin;
+  WebGestureEvent followup_scroll(WebInputEvent::GestureScrollBegin,
+                                  WebInputEvent::NoModifiers,
+                                  WebInputEvent::TimeStampForTesting);
   SetFollowupEvent(followup_scroll);
   SendTouchEventAck(INPUT_EVENT_ACK_STATE_NOT_CONSUMED);
   EXPECT_FALSE(IsTimeoutRunning());
   EXPECT_EQ(1U, GetAndResetAckedEventCount());
 
   SendGestureEventAck(WebInputEvent::GestureScrollUpdate,
                       INPUT_EVENT_ACK_STATE_CONSUMED);
 
   // An async touch should fire after the throttling interval has expired, but
   // it should not start the touch ack timeout.
@@ skipping 53 matching lines @@
 // touch event, that follow-up touch will be forwarded appropriately.
 TEST_F(TouchEventQueueTest, AsyncTouchWithTouchCancelAfterAck) {
   PressTouchPoint(0, 0);
   EXPECT_EQ(1U, GetAndResetSentEventCount());
   SendTouchEventAck(INPUT_EVENT_ACK_STATE_NOT_CONSUMED);
   EXPECT_EQ(1U, GetAndResetAckedEventCount());
 
   // The start of a scroll gesture should trigger async touch event dispatch.
   MoveTouchPoint(0, 1, 1);
   EXPECT_EQ(1U, GetAndResetSentEventCount());
-  WebGestureEvent followup_scroll;
-  followup_scroll.type = WebInputEvent::GestureScrollBegin;
+  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 ack'ed immediately, but not forwarded.
   // However, because the ack triggers a touchcancel, both the pending touch and
   // the queued touchcancel should be flushed.
-  WebTouchEvent followup_cancel;
-  followup_cancel.type = WebInputEvent::TouchCancel;
+  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_NE(WebInputEvent::Blocking, all_sent_events()[0].dispatchType);
   EXPECT_EQ(WebInputEvent::TouchCancel, all_sent_events()[1].type);
   EXPECT_NE(WebInputEvent::Blocking, all_sent_events()[1].dispatchType);
@@ skipping 15 matching lines @@
 // 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;
-  followup_scroll.type = WebInputEvent::GestureScrollBegin;
+  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());
@@ skipping 18 matching lines @@
 // starts.
 TEST_F(TouchEventQueueTest, SendNextThrottledAsyncTouchMoveAfterAck) {
   // Process a TouchStart
   PressTouchPoint(0, 1);
   EXPECT_EQ(1U, GetAndResetSentEventCount());
   SendTouchEventAck(INPUT_EVENT_ACK_STATE_NOT_CONSUMED);
   EXPECT_EQ(1U, GetAndResetAckedEventCount());
 
   // Initiate async touchmove dispatch after the start of a scroll sequence.
   MoveTouchPoint(0, 0, 5);
-  WebGestureEvent followup_scroll;
-  followup_scroll.type = WebInputEvent::GestureScrollBegin;
+  WebGestureEvent followup_scroll(WebInputEvent::GestureScrollBegin,
+                                  WebInputEvent::NoModifiers,
+                                  WebInputEvent::TimeStampForTesting);
   SetFollowupEvent(followup_scroll);
   SendTouchEventAck(INPUT_EVENT_ACK_STATE_NOT_CONSUMED);
   EXPECT_EQ(1U, GetAndResetSentEventCount());
   EXPECT_EQ(1U, GetAndResetAckedEventCount());
 
   MoveTouchPoint(0, 0, 10);
-  followup_scroll.type = WebInputEvent::GestureScrollUpdate;
+  followup_scroll.setType(WebInputEvent::GestureScrollUpdate);
   SetFollowupEvent(followup_scroll);
   SendTouchEventAck(INPUT_EVENT_ACK_STATE_NOT_CONSUMED);
   EXPECT_FALSE(HasPendingAsyncTouchMove());
   EXPECT_EQ(1U, GetAndResetSentEventCount());
   EXPECT_EQ(1U, GetAndResetAckedEventCount());
 
   // We set the next touch event time to be after the throttled interval.
   AdvanceTouchTime(kMinSecondsBetweenThrottledTouchmoves + 0.1);
   // Dispatch the touch move event when sufficient time has passed.
   MoveTouchPoint(0, 0, 40);
@@ skipping 32 matching lines @@
 // starts.
 TEST_F(TouchEventQueueTest, SendNextAsyncTouchMoveAfterAckAndTimeExpire) {
   // Process a TouchStart
   PressTouchPoint(0, 1);
   EXPECT_EQ(1U, GetAndResetSentEventCount());
   SendTouchEventAck(INPUT_EVENT_ACK_STATE_NOT_CONSUMED);
   EXPECT_EQ(1U, GetAndResetAckedEventCount());
 
   // Initiate async touchmove dispatch after the start of a scroll sequence.
   MoveTouchPoint(0, 0, 5);
-  WebGestureEvent followup_scroll;
-  followup_scroll.type = WebInputEvent::GestureScrollBegin;
+  WebGestureEvent followup_scroll(WebInputEvent::GestureScrollBegin,
+                                  WebInputEvent::NoModifiers,
+                                  WebInputEvent::TimeStampForTesting);
   SetFollowupEvent(followup_scroll);
   SendTouchEventAck(INPUT_EVENT_ACK_STATE_NOT_CONSUMED);
   EXPECT_EQ(1U, GetAndResetSentEventCount());
   EXPECT_EQ(1U, GetAndResetAckedEventCount());
 
   MoveTouchPoint(0, 0, 10);
-  followup_scroll.type = WebInputEvent::GestureScrollUpdate;
+  followup_scroll.setType(WebInputEvent::GestureScrollUpdate);
   SetFollowupEvent(followup_scroll);
   SendTouchEventAck(INPUT_EVENT_ACK_STATE_NOT_CONSUMED);
   EXPECT_FALSE(HasPendingAsyncTouchMove());
   EXPECT_EQ(1U, GetAndResetSentEventCount());
   EXPECT_EQ(1U, GetAndResetAckedEventCount());
 
   // Dispatch the touch move event when sufficient time has passed.
   AdvanceTouchTime(kMinSecondsBetweenThrottledTouchmoves + 0.1);
   MoveTouchPoint(0, 0, 40);
   EXPECT_FALSE(HasPendingAsyncTouchMove());
@@ skipping 29 matching lines @@
 
 TEST_F(TouchEventQueueTest, AsyncTouchFlushedByNonTouchMove) {
   // Process a TouchStart
   PressTouchPoint(0, 1);
   EXPECT_EQ(1U, GetAndResetSentEventCount());
   SendTouchEventAck(INPUT_EVENT_ACK_STATE_NOT_CONSUMED);
   EXPECT_EQ(1U, GetAndResetAckedEventCount());
 
   // Initiate async touchmove dispatch after the start of a scroll sequence.
   MoveTouchPoint(0, 0, 5);
-  WebGestureEvent followup_scroll;
-  followup_scroll.type = WebInputEvent::GestureScrollBegin;
+  WebGestureEvent followup_scroll(WebInputEvent::GestureScrollBegin,
+                                  WebInputEvent::NoModifiers,
+                                  WebInputEvent::TimeStampForTesting);
   SetFollowupEvent(followup_scroll);
   SendTouchEventAck(INPUT_EVENT_ACK_STATE_NOT_CONSUMED);
   EXPECT_EQ(1U, GetAndResetSentEventCount());
   EXPECT_EQ(1U, GetAndResetAckedEventCount());
 
   MoveTouchPoint(0, 0, 10);
-  followup_scroll.type = WebInputEvent::GestureScrollUpdate;
+  followup_scroll.setType(WebInputEvent::GestureScrollUpdate);
   SetFollowupEvent(followup_scroll);
   SendTouchEventAck(INPUT_EVENT_ACK_STATE_NOT_CONSUMED);
   EXPECT_FALSE(HasPendingAsyncTouchMove());
   EXPECT_EQ(1U, GetAndResetSentEventCount());
   EXPECT_EQ(1U, GetAndResetAckedEventCount());
 
   // Dispatch the touch move when sufficient time has passed.
   AdvanceTouchTime(kMinSecondsBetweenThrottledTouchmoves + 0.1);
   MoveTouchPoint(0, 0, 40);
   EXPECT_FALSE(HasPendingAsyncTouchMove());
@@ skipping 85 matching lines @@
 // starts.
 TEST_F(TouchEventQueueTest, DoNotIncreaseIfClientConsumeAsyncTouchMove) {
   // Process a TouchStart
   PressTouchPoint(0, 1);
   EXPECT_EQ(1U, GetAndResetSentEventCount());
   SendTouchEventAck(INPUT_EVENT_ACK_STATE_NOT_CONSUMED);
   EXPECT_EQ(1U, GetAndResetAckedEventCount());
 
   // Initiate async touchmove dispatch after the start of a scroll sequence.
   MoveTouchPoint(0, 0, 5);
-  WebGestureEvent followup_scroll;
-  followup_scroll.type = WebInputEvent::GestureScrollBegin;
+  WebGestureEvent followup_scroll(WebInputEvent::GestureScrollBegin,
+                                  WebInputEvent::NoModifiers,
+                                  WebInputEvent::TimeStampForTesting);
   SetFollowupEvent(followup_scroll);
   SendTouchEventAck(INPUT_EVENT_ACK_STATE_NOT_CONSUMED);
   EXPECT_EQ(1U, GetAndResetSentEventCount());
   EXPECT_EQ(1U, GetAndResetAckedEventCount());
 
   MoveTouchPoint(0, 0, 10);
-  followup_scroll.type = WebInputEvent::GestureScrollUpdate;
+  followup_scroll.setType(WebInputEvent::GestureScrollUpdate);
   SetFollowupEvent(followup_scroll);
   SendTouchEventAck(INPUT_EVENT_ACK_STATE_NOT_CONSUMED);
   EXPECT_FALSE(HasPendingAsyncTouchMove());
   EXPECT_EQ(1U, GetAndResetSentEventCount());
   EXPECT_EQ(1U, GetAndResetAckedEventCount());
 
   // Dispatch the touch move event when sufficient time has passed.
   AdvanceTouchTime(kMinSecondsBetweenThrottledTouchmoves + 0.1);
   MoveTouchPoint(0, 0, 40);
   EXPECT_FALSE(HasPendingAsyncTouchMove());
@@ skipping 45 matching lines @@
 
   // Even if the first touchmove event was consumed, subsequent unconsumed
   // touchmove events should trigger scrolling.
   MoveTouchPoint(0, 60, 5);
   SendTouchEventAck(INPUT_EVENT_ACK_STATE_CONSUMED);
   EXPECT_EQ(0U, queued_event_count());
   EXPECT_EQ(WebInputEvent::Blocking, sent_event().dispatchType);
   EXPECT_EQ(1U, GetAndResetSentEventCount());
 
   MoveTouchPoint(0, 20, 5);
-  WebGestureEvent followup_scroll;
-  followup_scroll.type = WebInputEvent::GestureScrollUpdate;
+  WebGestureEvent followup_scroll(WebInputEvent::GestureScrollUpdate,
+                                  WebInputEvent::NoModifiers,
+                                  WebInputEvent::TimeStampForTesting);
   SetFollowupEvent(followup_scroll);
   SendTouchEventAck(INPUT_EVENT_ACK_STATE_NOT_CONSUMED);
   SendGestureEventAck(WebInputEvent::GestureScrollUpdate,
                       INPUT_EVENT_ACK_STATE_CONSUMED);
   EXPECT_EQ(0U, queued_event_count());
   EXPECT_EQ(WebInputEvent::Blocking, sent_event().dispatchType);
   EXPECT_EQ(1U, GetAndResetSentEventCount());
 
   // Touch move event is throttled.
   MoveTouchPoint(0, 60, 5);
@@ skipping 358 matching lines @@
   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_FALSE(sent_event().touchStartOrFirstTouchMove);
 }
 
 }  // namespace content