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

third_party/WebKit/Source/web/tests/WebViewTest.cpp

 /*
  * Copyright (C) 2011, 2012 Google Inc. All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions are
  * met:
  *
  *     * Redistributions of source code must retain the above copyright
  * notice, this list of conditions and the following disclaimer.
  *     * Redistributions in binary form must reproduce the above
@@ skipping 1960 matching lines @@
 
   // TODO(bokan): Technically incorrect, event positions should be in viewport
   // space. crbug.com/371902.
   IntPoint center =
       m_webViewHelper.webView()
           ->mainFrameImpl()
           ->frameView()
           ->contentsToScreen(element->layoutObject()->absoluteBoundingBoxRect())
           .center();
 
-  WebGestureEvent event;
-  event.type = type;
+  WebGestureEvent event(type, WebInputEvent::NoModifiers,
+                        WebInputEvent::TimeStampForTesting);
+
   event.sourceDevice = WebGestureDeviceTouchscreen;
   event.x = center.x();
   event.y = center.y();
 
   m_webViewHelper.webView()->handleInputEvent(event);
   runPendingTasks();
   return true;
 }
 
 bool WebViewTest::tapElementById(WebInputEvent::Type type,
@@ skipping 42 matching lines @@
   EXPECT_TRUE(client.contentDetectionRequested());
   EXPECT_FALSE(client.scheduledIntentURL().isValid());
 
   WebURL intentURL = toKURL(m_baseURL);
   client.setContentDetectionResult(intentURL);
   EXPECT_TRUE(tapElementById(WebInputEvent::GestureTap, noListener));
   EXPECT_TRUE(client.scheduledIntentURL() == intentURL);
   EXPECT_TRUE(client.wasInMainFrame());
 
   // Tapping elsewhere should cancel the scheduled intent.
-  WebGestureEvent event;
-  event.type = WebInputEvent::GestureTap;
+  WebGestureEvent event(WebInputEvent::GestureTap, WebInputEvent::NoModifiers,
+                        WebInputEvent::TimeStampForTesting);
   event.sourceDevice = WebGestureDeviceTouchscreen;
   webView->handleInputEvent(event);
   runPendingTasks();
   EXPECT_TRUE(client.pendingIntentsCancelled());
 
   // Explicitly reset to break dependency on locally scoped client.
   m_webViewHelper.reset();
 }
 
 TEST_P(WebViewTest, ContentDetectionInIframe) {
@@ skipping 22 matching lines @@
 
   // Explicitly reset to break dependency on locally scoped client.
   m_webViewHelper.reset();
 }
 
 TEST_P(WebViewTest, ClientTapHandling) {
   TapHandlingWebViewClient client;
   client.reset();
   WebView* webView =
       m_webViewHelper.initializeAndLoad("about:blank", true, 0, &client);
-  WebGestureEvent event;
-  event.type = WebInputEvent::GestureTap;
+  WebGestureEvent event(WebInputEvent::GestureTap, WebInputEvent::NoModifiers,
+                        WebInputEvent::TimeStampForTesting);
   event.sourceDevice = WebGestureDeviceTouchscreen;
   event.x = 3;
   event.y = 8;
   webView->handleInputEvent(event);
   runPendingTasks();
   EXPECT_EQ(3, client.tapX());
   EXPECT_EQ(8, client.tapY());
   client.reset();
-  event.type = WebInputEvent::GestureLongPress;
+  event.setType(WebInputEvent::GestureLongPress);
   event.x = 25;
   event.y = 7;
   webView->handleInputEvent(event);
   runPendingTasks();
   EXPECT_EQ(25, client.longpressX());
   EXPECT_EQ(7, client.longpressY());
 
   // Explicitly reset to break dependency on locally scoped client.
   m_webViewHelper.reset();
 }
 
 TEST_P(WebViewTest, ClientTapHandlingNullWebViewClient) {
   WebViewImpl* webView =
       WebViewImpl::create(nullptr, WebPageVisibilityStateVisible);
   FrameTestHelpers::TestWebFrameClient webFrameClient;
   FrameTestHelpers::TestWebWidgetClient webWidgetClient;
   WebLocalFrame* localFrame =
       WebLocalFrame::create(WebTreeScopeType::Document, &webFrameClient);
   webView->setMainFrame(localFrame);
 
   // TODO(dcheng): The main frame widget currently has a special case.
   // Eliminate this once WebView is no longer a WebWidget.
   blink::WebFrameWidget::create(&webWidgetClient, webView, localFrame);
 
-  WebGestureEvent event;
-  event.type = WebInputEvent::GestureTap;
+  WebGestureEvent event(WebInputEvent::GestureTap, WebInputEvent::NoModifiers,
+                        WebInputEvent::TimeStampForTesting);
   event.sourceDevice = WebGestureDeviceTouchscreen;
   event.x = 3;
   event.y = 8;
   EXPECT_EQ(WebInputEventResult::NotHandled, webView->handleInputEvent(event));
   webView->close();
 }
 
 TEST_P(WebViewTest, LongPressEmptyDiv) {
   URLTestHelpers::registerMockedURLFromBaseURL(
       WebString::fromUTF8(m_baseURL.c_str()),
       WebString::fromUTF8("long_press_empty_div.html"));
 
   WebViewImpl* webView = m_webViewHelper.initializeAndLoad(
       m_baseURL + "long_press_empty_div.html", true);
   webView->settingsImpl()->setAlwaysShowContextMenuOnTouch(false);
   webView->resize(WebSize(500, 300));
   webView->updateAllLifecyclePhases();
   runPendingTasks();
 
-  WebGestureEvent event;
-  event.type = WebInputEvent::GestureLongPress;
+  WebGestureEvent event(WebInputEvent::GestureLongPress,
+                        WebInputEvent::NoModifiers,
+                        WebInputEvent::TimeStampForTesting);
   event.sourceDevice = WebGestureDeviceTouchscreen;
   event.x = 250;
   event.y = 150;
 
   EXPECT_EQ(WebInputEventResult::NotHandled, webView->handleInputEvent(event));
 }
 
 TEST_P(WebViewTest, LongPressEmptyDivAlwaysShow) {
   URLTestHelpers::registerMockedURLFromBaseURL(
       WebString::fromUTF8(m_baseURL.c_str()),
       WebString::fromUTF8("long_press_empty_div.html"));
 
   WebViewImpl* webView = m_webViewHelper.initializeAndLoad(
       m_baseURL + "long_press_empty_div.html", true);
   webView->settingsImpl()->setAlwaysShowContextMenuOnTouch(true);
   webView->resize(WebSize(500, 300));
   webView->updateAllLifecyclePhases();
   runPendingTasks();
 
-  WebGestureEvent event;
-  event.type = WebInputEvent::GestureLongPress;
+  WebGestureEvent event(WebInputEvent::GestureLongPress,
+                        WebInputEvent::NoModifiers,
+                        WebInputEvent::TimeStampForTesting);
   event.sourceDevice = WebGestureDeviceTouchscreen;
   event.x = 250;
   event.y = 150;
 
   EXPECT_EQ(WebInputEventResult::HandledSystem,
             webView->handleInputEvent(event));
 }
 
 TEST_P(WebViewTest, LongPressObject) {
   URLTestHelpers::registerMockedURLFromBaseURL(
       WebString::fromUTF8(m_baseURL.c_str()),
       WebString::fromUTF8("long_press_object.html"));
 
   WebViewImpl* webView = m_webViewHelper.initializeAndLoad(
       m_baseURL + "long_press_object.html", true);
   webView->settingsImpl()->setAlwaysShowContextMenuOnTouch(true);
   webView->resize(WebSize(500, 300));
   webView->updateAllLifecyclePhases();
   runPendingTasks();
 
-  WebGestureEvent event;
-  event.type = WebInputEvent::GestureLongPress;
+  WebGestureEvent event(WebInputEvent::GestureLongPress,
+                        WebInputEvent::NoModifiers,
+                        WebInputEvent::TimeStampForTesting);
   event.sourceDevice = WebGestureDeviceTouchscreen;
   event.x = 10;
   event.y = 10;
 
   EXPECT_NE(WebInputEventResult::HandledSystem,
             webView->handleInputEvent(event));
 
   HTMLElement* element =
       toHTMLElement(webView->mainFrame()->document().getElementById("obj"));
   EXPECT_FALSE(element->canStartSelection());
 }
 
 TEST_P(WebViewTest, LongPressObjectFallback) {
   URLTestHelpers::registerMockedURLFromBaseURL(
       WebString::fromUTF8(m_baseURL.c_str()),
       WebString::fromUTF8("long_press_object_fallback.html"));
 
   WebViewImpl* webView = m_webViewHelper.initializeAndLoad(
       m_baseURL + "long_press_object_fallback.html", true);
   webView->settingsImpl()->setAlwaysShowContextMenuOnTouch(true);
   webView->resize(WebSize(500, 300));
   webView->updateAllLifecyclePhases();
   runPendingTasks();
 
-  WebGestureEvent event;
-  event.type = WebInputEvent::GestureLongPress;
+  WebGestureEvent event(WebInputEvent::GestureLongPress,
+                        WebInputEvent::NoModifiers,
+                        WebInputEvent::TimeStampForTesting);
   event.sourceDevice = WebGestureDeviceTouchscreen;
   event.x = 10;
   event.y = 10;
 
   EXPECT_EQ(WebInputEventResult::HandledSystem,
             webView->handleInputEvent(event));
 
   HTMLElement* element =
       toHTMLElement(webView->mainFrame()->document().getElementById("obj"));
   EXPECT_TRUE(element->canStartSelection());
 }
 
 TEST_P(WebViewTest, LongPressImage) {
   URLTestHelpers::registerMockedURLFromBaseURL(
       WebString::fromUTF8(m_baseURL.c_str()),
       WebString::fromUTF8("long_press_image.html"));
 
   WebViewImpl* webView = m_webViewHelper.initializeAndLoad(
       m_baseURL + "long_press_image.html", true);
   webView->settingsImpl()->setAlwaysShowContextMenuOnTouch(false);
   webView->resize(WebSize(500, 300));
   webView->updateAllLifecyclePhases();
   runPendingTasks();
 
-  WebGestureEvent event;
-  event.type = WebInputEvent::GestureLongPress;
+  WebGestureEvent event(WebInputEvent::GestureLongPress,
+                        WebInputEvent::NoModifiers,
+                        WebInputEvent::TimeStampForTesting);
   event.sourceDevice = WebGestureDeviceTouchscreen;
   event.x = 10;
   event.y = 10;
 
   EXPECT_EQ(WebInputEventResult::HandledSystem,
             webView->handleInputEvent(event));
 }
 
 TEST_P(WebViewTest, LongPressVideo) {
   URLTestHelpers::registerMockedURLFromBaseURL(
       WebString::fromUTF8(m_baseURL.c_str()),
       WebString::fromUTF8("long_press_video.html"));
 
   WebViewImpl* webView = m_webViewHelper.initializeAndLoad(
       m_baseURL + "long_press_video.html", true);
   webView->settingsImpl()->setAlwaysShowContextMenuOnTouch(false);
   webView->resize(WebSize(500, 300));
   webView->updateAllLifecyclePhases();
   runPendingTasks();
 
-  WebGestureEvent event;
-  event.type = WebInputEvent::GestureLongPress;
+  WebGestureEvent event(WebInputEvent::GestureLongPress,
+                        WebInputEvent::NoModifiers,
+                        WebInputEvent::TimeStampForTesting);
   event.sourceDevice = WebGestureDeviceTouchscreen;
   event.x = 10;
   event.y = 10;
 
   EXPECT_EQ(WebInputEventResult::HandledSystem,
             webView->handleInputEvent(event));
 }
 
 TEST_P(WebViewTest, LongPressLink) {
   URLTestHelpers::registerMockedURLFromBaseURL(
       WebString::fromUTF8(m_baseURL.c_str()),
       WebString::fromUTF8("long_press_link.html"));
 
   WebViewImpl* webView = m_webViewHelper.initializeAndLoad(
       m_baseURL + "long_press_link.html", true);
   webView->settingsImpl()->setAlwaysShowContextMenuOnTouch(false);
   webView->resize(WebSize(500, 300));
   webView->updateAllLifecyclePhases();
   runPendingTasks();
 
-  WebGestureEvent event;
-  event.type = WebInputEvent::GestureLongPress;
+  WebGestureEvent event(WebInputEvent::GestureLongPress,
+                        WebInputEvent::NoModifiers,
+                        WebInputEvent::TimeStampForTesting);
   event.sourceDevice = WebGestureDeviceTouchscreen;
   event.x = 500;
   event.y = 300;
 
   EXPECT_EQ(WebInputEventResult::HandledSystem,
             webView->handleInputEvent(event));
 }
 
 TEST_P(WebViewTest, showContextMenuOnLongPressingLinks) {
   URLTestHelpers::registerMockedURLFromBaseURL(
@@ skipping 27 matching lines @@
       WebString::fromUTF8(m_baseURL.c_str()),
       WebString::fromUTF8("long_press_empty_editable_selection.html"));
 
   WebViewImpl* webView = m_webViewHelper.initializeAndLoad(
       m_baseURL + "long_press_empty_editable_selection.html", true);
   webView->settingsImpl()->setAlwaysShowContextMenuOnTouch(false);
   webView->resize(WebSize(500, 300));
   webView->updateAllLifecyclePhases();
   runPendingTasks();
 
-  WebGestureEvent event;
-  event.type = WebInputEvent::GestureLongPress;
+  WebGestureEvent event(WebInputEvent::GestureLongPress,
+                        WebInputEvent::NoModifiers,
+                        WebInputEvent::TimeStampForTesting);
   event.sourceDevice = WebGestureDeviceTouchscreen;
   event.x = 10;
   event.y = 10;
 
   EXPECT_EQ(WebInputEventResult::HandledSystem,
             webView->handleInputEvent(event));
 }
 
 TEST_P(WebViewTest, LongPressEmptyNonEditableSelection) {
   URLTestHelpers::registerMockedURLFromBaseURL(
       WebString::fromUTF8(m_baseURL.c_str()),
       WebString::fromUTF8("long_press_image.html"));
 
   WebViewImpl* webView = m_webViewHelper.initializeAndLoad(
       m_baseURL + "long_press_image.html", true);
   webView->resize(WebSize(500, 500));
   webView->updateAllLifecyclePhases();
   runPendingTasks();
 
-  WebGestureEvent event;
-  event.type = WebInputEvent::GestureLongPress;
+  WebGestureEvent event(WebInputEvent::GestureLongPress,
+                        WebInputEvent::NoModifiers,
+                        WebInputEvent::TimeStampForTesting);
   event.sourceDevice = WebGestureDeviceTouchscreen;
   event.x = 300;
   event.y = 300;
   WebLocalFrameImpl* frame = webView->mainFrameImpl();
 
   EXPECT_EQ(WebInputEventResult::HandledSystem,
             webView->handleInputEvent(event));
   EXPECT_TRUE(frame->selectionAsText().isEmpty());
 }
 
@@ skipping 33 matching lines @@
 
   WebString blanklinestextbox = WebString::fromUTF8("blanklinestextbox");
   WebLocalFrameImpl* frame = webView->mainFrameImpl();
 
   // Long-press on carriage returns.
   EXPECT_TRUE(
       tapElementById(WebInputEvent::GestureLongPress, blanklinestextbox));
   EXPECT_TRUE(frame->selectionAsText().isEmpty());
 
   // Double-tap on carriage returns.
-  WebGestureEvent event;
-  event.type = WebInputEvent::GestureTap;
+  WebGestureEvent event(WebInputEvent::GestureTap, WebInputEvent::NoModifiers,
+                        WebInputEvent::TimeStampForTesting);
   event.sourceDevice = WebGestureDeviceTouchscreen;
   event.x = 100;
   event.y = 25;
   event.data.tap.tapCount = 2;
 
   webView->handleInputEvent(event);
   EXPECT_TRUE(frame->selectionAsText().isEmpty());
 
   HTMLTextAreaElement* textAreaElement = toHTMLTextAreaElement(
       webView->mainFrame()->document().getElementById(blanklinestextbox));
@@ skipping 53 matching lines @@
       WebString::fromUTF8(m_baseURL.c_str()), WebString::fromUTF8("form.html"));
   WebViewImpl* webView =
       m_webViewHelper.initializeAndLoad(m_baseURL + "form.html", true);
 
   webView->setInitialFocus(false);
   runPendingTasks();
 
   // We suspend caret blinking when pressing with mouse right button.
   // Note that we do not send MouseUp event here since it will be consumed
   // by the context menu once it shows up.
-  WebMouseEvent mouseEvent;
+  WebMouseEvent mouseEvent(WebInputEvent::MouseDown, WebInputEvent::NoModifiers,
+                           WebInputEvent::TimeStampForTesting);
+
   mouseEvent.button = WebMouseEvent::Button::Right;
   mouseEvent.x = 1;
   mouseEvent.y = 1;
   mouseEvent.clickCount = 1;
-  mouseEvent.type = WebInputEvent::MouseDown;
   webView->handleInputEvent(mouseEvent);
   runPendingTasks();
 
   WebLocalFrameImpl* mainFrame = webView->mainFrameImpl();
   EXPECT_TRUE(mainFrame->frame()->selection().isCaretBlinkingSuspended());
 
   // Caret blinking is still suspended after showing context menu.
   webView->showContextMenu();
   EXPECT_TRUE(mainFrame->frame()->selection().isCaretBlinkingSuspended());
 
@@ skipping 28 matching lines @@
   URLTestHelpers::registerMockedURLFromBaseURL(
       WebString::fromUTF8(m_baseURL.c_str()),
       WebString::fromUTF8("content-width-1000.html"));
 
   WebViewImpl* webView = m_webViewHelper.initializeAndLoad(
       m_baseURL + "content-width-1000.html", true);
   webView->resize(WebSize(100, 100));
   webView->updateAllLifecyclePhases();
   runPendingTasks();
 
-  WebKeyboardEvent keyEvent;
+  WebKeyboardEvent keyEvent(WebInputEvent::RawKeyDown,
+                            WebInputEvent::NoModifiers,
+                            WebInputEvent::TimeStampForTesting);
 
   // RawKeyDown pagedown should be handled.
   keyEvent.windowsKeyCode = VKEY_NEXT;
-  keyEvent.type = WebInputEvent::RawKeyDown;
   EXPECT_EQ(WebInputEventResult::HandledSystem,
             webView->handleInputEvent(keyEvent));
-  keyEvent.type = WebInputEvent::KeyUp;
+  keyEvent.setType(WebInputEvent::KeyUp);
   webView->handleInputEvent(keyEvent);
 
   // Coalesced KeyDown arrow-down should be handled.
   keyEvent.windowsKeyCode = VKEY_DOWN;
-  keyEvent.type = WebInputEvent::KeyDown;
+  keyEvent.setType(WebInputEvent::KeyDown);
   EXPECT_EQ(WebInputEventResult::HandledSystem,
             webView->handleInputEvent(keyEvent));
-  keyEvent.type = WebInputEvent::KeyUp;
+  keyEvent.setType(WebInputEvent::KeyUp);
   webView->handleInputEvent(keyEvent);
 
   // Ctrl-Home should be handled...
   keyEvent.windowsKeyCode = VKEY_HOME;
-  keyEvent.modifiers = WebInputEvent::ControlKey;
-  keyEvent.type = WebInputEvent::RawKeyDown;
+  keyEvent.setModifiers(WebInputEvent::ControlKey);
+  keyEvent.setType(WebInputEvent::RawKeyDown);
   EXPECT_EQ(WebInputEventResult::NotHandled,
             webView->handleInputEvent(keyEvent));
-  keyEvent.type = WebInputEvent::KeyUp;
+  keyEvent.setType(WebInputEvent::KeyUp);
   webView->handleInputEvent(keyEvent);
 
   // But Ctrl-Down should not.
   keyEvent.windowsKeyCode = VKEY_DOWN;
-  keyEvent.modifiers = WebInputEvent::ControlKey;
-  keyEvent.type = WebInputEvent::RawKeyDown;
+  keyEvent.setModifiers(WebInputEvent::ControlKey);
+  keyEvent.setType(WebInputEvent::RawKeyDown);
   EXPECT_EQ(WebInputEventResult::NotHandled,
             webView->handleInputEvent(keyEvent));
-  keyEvent.type = WebInputEvent::KeyUp;
+  keyEvent.setType(WebInputEvent::KeyUp);
   webView->handleInputEvent(keyEvent);
 
   // Shift, meta, and alt should not be handled.
   keyEvent.windowsKeyCode = VKEY_NEXT;
-  keyEvent.modifiers = WebInputEvent::ShiftKey;
-  keyEvent.type = WebInputEvent::RawKeyDown;
+  keyEvent.setModifiers(WebInputEvent::ShiftKey);
+  keyEvent.setType(WebInputEvent::RawKeyDown);
   EXPECT_EQ(WebInputEventResult::NotHandled,
             webView->handleInputEvent(keyEvent));
-  keyEvent.type = WebInputEvent::KeyUp;
+  keyEvent.setType(WebInputEvent::KeyUp);
   webView->handleInputEvent(keyEvent);
 
   keyEvent.windowsKeyCode = VKEY_NEXT;
-  keyEvent.modifiers = WebInputEvent::MetaKey;
-  keyEvent.type = WebInputEvent::RawKeyDown;
+  keyEvent.setModifiers(WebInputEvent::MetaKey);
+  keyEvent.setType(WebInputEvent::RawKeyDown);
   EXPECT_EQ(WebInputEventResult::NotHandled,
             webView->handleInputEvent(keyEvent));
-  keyEvent.type = WebInputEvent::KeyUp;
+  keyEvent.setType(WebInputEvent::KeyUp);
   webView->handleInputEvent(keyEvent);
 
   keyEvent.windowsKeyCode = VKEY_NEXT;
-  keyEvent.modifiers = WebInputEvent::AltKey;
-  keyEvent.type = WebInputEvent::RawKeyDown;
+  keyEvent.setModifiers(WebInputEvent::AltKey);
+  keyEvent.setType(WebInputEvent::RawKeyDown);
   EXPECT_EQ(WebInputEventResult::NotHandled,
             webView->handleInputEvent(keyEvent));
-  keyEvent.type = WebInputEvent::KeyUp;
+  keyEvent.setType(WebInputEvent::KeyUp);
   webView->handleInputEvent(keyEvent);
 
   // System-key labeled Alt-Down (as in Windows) should do nothing,
   // but non-system-key labeled Alt-Down (as in Mac) should be handled
   // as a page-down.
   keyEvent.windowsKeyCode = VKEY_DOWN;
-  keyEvent.modifiers = WebInputEvent::AltKey;
+  keyEvent.setModifiers(WebInputEvent::AltKey);
   keyEvent.isSystemKey = true;
-  keyEvent.type = WebInputEvent::RawKeyDown;
+  keyEvent.setType(WebInputEvent::RawKeyDown);
   EXPECT_EQ(WebInputEventResult::NotHandled,
             webView->handleInputEvent(keyEvent));
-  keyEvent.type = WebInputEvent::KeyUp;
+  keyEvent.setType(WebInputEvent::KeyUp);
   webView->handleInputEvent(keyEvent);
 
   keyEvent.windowsKeyCode = VKEY_DOWN;
-  keyEvent.modifiers = WebInputEvent::AltKey;
+  keyEvent.setModifiers(WebInputEvent::AltKey);
   keyEvent.isSystemKey = false;
-  keyEvent.type = WebInputEvent::RawKeyDown;
+  keyEvent.setType(WebInputEvent::RawKeyDown);
   EXPECT_EQ(WebInputEventResult::HandledSystem,
             webView->handleInputEvent(keyEvent));
-  keyEvent.type = WebInputEvent::KeyUp;
+  keyEvent.setType(WebInputEvent::KeyUp);
   webView->handleInputEvent(keyEvent);
 }
 
 static void configueCompositingWebView(WebSettings* settings) {
   settings->setAcceleratedCompositingEnabled(true);
   settings->setPreferCompositingToLCDTextEnabled(true);
 }
 
 TEST_P(WebViewTest, ShowPressOnTransformedLink) {
   std::unique_ptr<FrameTestHelpers::TestWebViewClient>
       fakeCompositingWebViewClient =
           WTF::makeUnique<FrameTestHelpers::TestWebViewClient>();
   FrameTestHelpers::WebViewHelper webViewHelper;
   WebViewImpl* webViewImpl = webViewHelper.initialize(
       true, nullptr, fakeCompositingWebViewClient.get(), nullptr,
       &configueCompositingWebView);
 
   int pageWidth = 640;
   int pageHeight = 480;
   webViewImpl->resize(WebSize(pageWidth, pageHeight));
 
   WebURL baseURL = URLTestHelpers::toKURL("http://example.com/");
   FrameTestHelpers::loadHTMLString(
       webViewImpl->mainFrame(),
       "<a href='http://www.test.com' style='position: absolute; left: 20px; "
       "top: 20px; width: 200px; transform:translateZ(0);'>A link to "
       "highlight</a>",
       baseURL);
 
-  WebGestureEvent event;
-  event.type = WebInputEvent::GestureShowPress;
+  WebGestureEvent event(WebInputEvent::GestureShowPress,
+                        WebInputEvent::NoModifiers,
+                        WebInputEvent::TimeStampForTesting);
   event.sourceDevice = WebGestureDeviceTouchscreen;
   event.x = 20;
   event.y = 20;
 
   // Just make sure we don't hit any asserts.
   webViewImpl->handleInputEvent(event);
 }
 
 class MockAutofillClient : public WebAutofillClient {
  public:
@@ skipping 103 matching lines @@
     frame->setEditableSelectionOffsets(6, 6);
     WebInputMethodController* activeInputMethodController =
         frame->frameWidget()->getActiveWebInputMethodController();
     EXPECT_TRUE(activeInputMethodController->setComposition(
         "fghij", emptyUnderlines, 0, 5));
     frame->setEditableSelectionOffsets(11, 11);
     verifySelectionAndComposition(webView, 11, 11, 6, 11, "initial case");
 
     // Press Backspace and verify composition didn't get cancelled. This is to
     // verify the fix for crbug.com/429916.
-    WebKeyboardEvent keyEvent;
+    WebKeyboardEvent keyEvent(WebInputEvent::RawKeyDown,
+                              WebInputEvent::NoModifiers,
+                              WebInputEvent::TimeStampForTesting);
     keyEvent.domKey = Platform::current()->domKeyEnumFromString("\b");
     keyEvent.windowsKeyCode = VKEY_BACK;
-    keyEvent.type = WebInputEvent::RawKeyDown;
     webView->handleInputEvent(keyEvent);
 
     frame->setEditableSelectionOffsets(6, 6);
     EXPECT_TRUE(activeInputMethodController->setComposition(
         "fghi", emptyUnderlines, 0, 4));
     frame->setEditableSelectionOffsets(10, 10);
     verifySelectionAndComposition(webView, 10, 10, 6, 10,
                                   "after pressing Backspace");
 
-    keyEvent.type = WebInputEvent::KeyUp;
+    keyEvent.setType(WebInputEvent::KeyUp);
     webView->handleInputEvent(keyEvent);
 
     webView->advanceFocus(false);
   }
 
   frame->setAutofillClient(0);
 }
 
 TEST_P(WebViewTest, FinishComposingTextTriggersAutofillTextChange) {
   URLTestHelpers::registerMockedURLFromBaseURL(
@@ skipping 170 matching lines @@
 
   WebElement element =
       webView->mainFrame()->document().getElementById("message");
   EXPECT_STREQ("DOMFocusOutDOMFocusIn", element.textContent().utf8().data());
 }
 
 static void openDateTimeChooser(WebView* webView,
                                 HTMLInputElement* inputElement) {
   inputElement->focus();
 
-  WebKeyboardEvent keyEvent;
+  WebKeyboardEvent keyEvent(WebInputEvent::RawKeyDown,
+                            WebInputEvent::NoModifiers,
+                            WebInputEvent::TimeStampForTesting);
   keyEvent.domKey = Platform::current()->domKeyEnumFromString(" ");
   keyEvent.windowsKeyCode = VKEY_SPACE;
-  keyEvent.type = WebInputEvent::RawKeyDown;
   webView->handleInputEvent(keyEvent);
 
-  keyEvent.type = WebInputEvent::KeyUp;
+  keyEvent.setType(WebInputEvent::KeyUp);
   webView->handleInputEvent(keyEvent);
 }
 
 // TODO(crbug.com/605112) This test is crashing on Android (Nexus 4) bot.
 #if OS(ANDROID)
 TEST_P(WebViewTest, DISABLED_ChooseValueFromDateTimeChooser) {
 #else
 TEST_P(WebViewTest, ChooseValueFromDateTimeChooser) {
 #endif
   bool originalMultipleFieldsFlag =
@@ skipping 554 matching lines @@
       WebString::fromUTF8(m_baseURL.c_str()), WebString::fromUTF8("form.html"));
   MockAutofillClient client;
   WebViewImpl* webView =
       m_webViewHelper.initializeAndLoad(m_baseURL + "form.html", true);
   WebLocalFrameImpl* frame = webView->mainFrameImpl();
   frame->setAutofillClient(&client);
   webView->setInitialFocus(false);
 
   EXPECT_EQ(0, client.getUserGestureNotificationsCount());
 
-  WebKeyboardEvent keyEvent;
+  WebKeyboardEvent keyEvent(WebInputEvent::RawKeyDown,
+                            WebInputEvent::NoModifiers,
+                            WebInputEvent::TimeStampForTesting);
   keyEvent.domKey = Platform::current()->domKeyEnumFromString(" ");
   keyEvent.windowsKeyCode = VKEY_SPACE;
-  keyEvent.type = WebInputEvent::RawKeyDown;
   webView->handleInputEvent(keyEvent);
-  keyEvent.type = WebInputEvent::KeyUp;
+  keyEvent.setType(WebInputEvent::KeyUp);
   webView->handleInputEvent(keyEvent);
 
   EXPECT_EQ(1, client.getUserGestureNotificationsCount());
   frame->setAutofillClient(0);
 }
 
 TEST_P(WebViewTest, FirstUserGestureObservedMouseEvent) {
   URLTestHelpers::registerMockedURLFromBaseURL(
       WebString::fromUTF8(m_baseURL.c_str()), WebString::fromUTF8("form.html"));
   MockAutofillClient client;
   WebViewImpl* webView =
       m_webViewHelper.initializeAndLoad(m_baseURL + "form.html", true);
   WebLocalFrameImpl* frame = webView->mainFrameImpl();
   frame->setAutofillClient(&client);
   webView->setInitialFocus(false);
 
   EXPECT_EQ(0, client.getUserGestureNotificationsCount());
 
-  WebMouseEvent mouseEvent;
+  WebMouseEvent mouseEvent(WebInputEvent::MouseDown, WebInputEvent::NoModifiers,
+                           WebInputEvent::TimeStampForTesting);
   mouseEvent.button = WebMouseEvent::Button::Left;
   mouseEvent.x = 1;
   mouseEvent.y = 1;
   mouseEvent.clickCount = 1;
-  mouseEvent.type = WebInputEvent::MouseDown;
   webView->handleInputEvent(mouseEvent);
-  mouseEvent.type = WebInputEvent::MouseUp;
+  mouseEvent.setType(WebInputEvent::MouseUp);
   webView->handleInputEvent(mouseEvent);
 
   EXPECT_EQ(1, client.getUserGestureNotificationsCount());
   frame->setAutofillClient(0);
 }
 
 TEST_P(WebViewTest, FirstUserGestureObservedGestureTap) {
   URLTestHelpers::registerMockedURLFromBaseURL(
       WebString::fromUTF8(m_baseURL.c_str()),
       WebString::fromUTF8("longpress_selection.html"));
@@ skipping 646 matching lines @@
       .translate(50, 55)
       .scale(1. / 2.f);
   EXPECT_EQ(expectedMatrix,
             webViewImpl->getDeviceEmulationTransformForTesting());
   // visibleContentRect doesn't change.
   EXPECT_EQ(IntRect(50, 55, 50, 75),
             *devToolsEmulator->visibleContentRectForPainting());
 }
 
 }  // namespace blink