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

content/browser/site_per_process_browsertest.cc

 // Copyright (c) 2012 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/site_per_process_browsertest.h"
 
 #include <stddef.h>
 #include <stdint.h>
 
 #include <algorithm>
@@ skipping 50 matching lines @@
 #include "ipc/ipc.mojom.h"
 #include "ipc/ipc_security_test_util.h"
 #include "net/dns/mock_host_resolver.h"
 #include "net/test/embedded_test_server/embedded_test_server.h"
 #include "testing/gtest/include/gtest/gtest.h"
 #include "third_party/WebKit/public/platform/WebInputEvent.h"
 #include "third_party/WebKit/public/platform/WebInsecureRequestPolicy.h"
 #include "third_party/WebKit/public/web/WebSandboxFlags.h"
 #include "ui/display/display_switches.h"
 #include "ui/display/screen.h"
+#include "ui/events/base_event_utils.h"
 #include "ui/events/event.h"
 #include "ui/events/event_utils.h"
 #include "ui/events/latency_info.h"
 #include "ui/gfx/geometry/point.h"
 #include "ui/native_theme/native_theme_switches.h"
 
 #if defined(USE_AURA)
 #include "content/browser/renderer_host/render_widget_host_view_aura.h"
 #endif
 
@@ skipping 52 matching lines @@
       "window.domAutomationController.send("
       "    !!window.open('" + url.spec() + "', '" + name + "'));",
       &success));
   EXPECT_TRUE(success);
 }
 
 // Helper function to generate a click on the given RenderWidgetHost.  The
 // mouse event is forwarded directly to the RenderWidgetHost without any
 // hit-testing.
 void SimulateMouseClick(RenderWidgetHost* rwh, int x, int y) {
-  blink::WebMouseEvent mouse_event;
-  mouse_event.type = blink::WebInputEvent::MouseDown;
+  blink::WebMouseEvent mouse_event(blink::WebInputEvent::MouseDown,
+                                   blink::WebInputEvent::NoModifiers,
+                                   blink::WebInputEvent::TimeStampForTesting);
   mouse_event.button = blink::WebPointerProperties::Button::Left;
   mouse_event.x = x;
   mouse_event.y = y;
   rwh->ForwardMouseEvent(mouse_event);
 }
 
 // Retrieve document.origin for the frame |ftn|.
 std::string GetDocumentOrigin(FrameTreeNode* ftn) {
   std::string origin;
   EXPECT_TRUE(ExecuteScriptAndExtractString(
@@ skipping 93 matching lines @@
   RenderWidgetHostViewBase* root_view = static_cast<RenderWidgetHostViewBase*>(
       root->current_frame_host()->GetRenderWidgetHost()->GetView());
   RenderWidgetHostViewBase* rwhv_child = static_cast<RenderWidgetHostViewBase*>(
       child_node->current_frame_host()->GetRenderWidgetHost()->GetView());
 
   SurfaceHitTestReadyNotifier notifier(
       static_cast<RenderWidgetHostViewChildFrame*>(rwhv_child));
   notifier.WaitForSurfaceReady();
 
   // Target input event to child frame.
-  blink::WebMouseEvent child_event;
-  child_event.type = blink::WebInputEvent::MouseDown;
+  blink::WebMouseEvent child_event(blink::WebInputEvent::MouseDown,
+                                   blink::WebInputEvent::NoModifiers,
+                                   blink::WebInputEvent::TimeStampForTesting);
   child_event.button = blink::WebPointerProperties::Button::Left;
   child_event.x = 75;
   child_event.y = 75;
   child_event.clickCount = 1;
   main_frame_monitor.ResetEventReceived();
   child_frame_monitor.ResetEventReceived();
   router->RouteMouseEvent(root_view, &child_event, ui::LatencyInfo());
 
   EXPECT_TRUE(child_frame_monitor.EventWasReceived());
   EXPECT_EQ(23, child_frame_monitor.event().x);
   EXPECT_EQ(23, child_frame_monitor.event().y);
   EXPECT_FALSE(main_frame_monitor.EventWasReceived());
 
   child_frame_monitor.ResetEventReceived();
   main_frame_monitor.ResetEventReceived();
 
   // Target input event to main frame.
-  blink::WebMouseEvent main_event;
-  main_event.type = blink::WebInputEvent::MouseDown;
+  blink::WebMouseEvent main_event(blink::WebInputEvent::MouseDown,
+                                  blink::WebInputEvent::NoModifiers,
+                                  blink::WebInputEvent::TimeStampForTesting);
   main_event.button = blink::WebPointerProperties::Button::Left;
   main_event.x = 1;
   main_event.y = 1;
   main_event.clickCount = 1;
   // Ladies and gentlemen, THIS is the main_event!
   router->RouteMouseEvent(root_view, &main_event, ui::LatencyInfo());
 
   EXPECT_FALSE(child_frame_monitor.EventWasReceived());
   EXPECT_TRUE(main_frame_monitor.EventWasReceived());
   EXPECT_EQ(1, main_frame_monitor.event().x);
@@ skipping 704 matching lines @@
   gfx::Rect bounds = rwhv_nested->GetViewBounds();
   EXPECT_EQ(bounds.x() - rwhv_root->GetViewBounds().x(), 397);
   EXPECT_EQ(bounds.y() - rwhv_root->GetViewBounds().y(), 112);
 
   scoped_refptr<FrameRectChangedMessageFilter> filter =
       new FrameRectChangedMessageFilter();
   root->current_frame_host()->GetProcess()->AddFilter(filter.get());
 
   // Scroll the parent frame downward to verify that the child rect gets updated
   // correctly.
-  blink::WebMouseWheelEvent scroll_event;
-  scroll_event.type = blink::WebInputEvent::MouseWheel;
+  blink::WebMouseWheelEvent scroll_event(
+      blink::WebInputEvent::MouseWheel, blink::WebInputEvent::NoModifiers,
+      blink::WebInputEvent::TimeStampForTesting);
   scroll_event.x = 387;
   scroll_event.y = 110;
   scroll_event.deltaX = 0.0f;
   scroll_event.deltaY = -30.0f;
   rwhv_root->ProcessMouseWheelEvent(scroll_event, ui::LatencyInfo());
 
   filter->Wait();
 
   // The precise amount of scroll for the first view position update is not
   // deterministic, so this simply verifies that the OOPIF moved from its
@@ skipping 65 matching lines @@
       static_cast<RenderWidgetHostViewChildFrame*>(rwhv_nested));
   notifier.WaitForSurfaceReady();
 
   // Save the original offset as a point of reference.
   filter->Wait();
   gfx::Rect update_rect = filter->last_rect();
   int initial_y = update_rect.y();
   filter->Reset();
 
   // Scroll the parent frame downward.
-  blink::WebMouseWheelEvent scroll_event;
-  scroll_event.type = blink::WebInputEvent::MouseWheel;
+  blink::WebMouseWheelEvent scroll_event(
+      blink::WebInputEvent::MouseWheel, blink::WebInputEvent::NoModifiers,
+      blink::WebInputEvent::TimeStampForTesting);
   scroll_event.x = 1;
   scroll_event.y = 1;
   scroll_event.deltaX = 0.0f;
   scroll_event.deltaY = -5.0f;
   rwhv_parent->ProcessMouseWheelEvent(scroll_event, ui::LatencyInfo());
 
   // Ensure that the view position is propagated to the child properly.
   filter->Wait();
   update_rect = filter->last_rect();
   EXPECT_LT(update_rect.y(), initial_y);
@@ skipping 27 matching lines @@
   // gestures.
   scroll_event.deltaY = -5.0f;
   rwhv_parent->ProcessMouseWheelEvent(scroll_event, ui::LatencyInfo());
 
   // Ensure ensuing offset change is received, and then reset the filter.
   filter->Wait();
   filter->Reset();
 
   // Scroll down the nested iframe via gesture. This requires 3 separate input
   // events.
-  blink::WebGestureEvent gesture_event;
-  gesture_event.type = blink::WebGestureEvent::GestureScrollBegin;
+  blink::WebGestureEvent gesture_event(
+      blink::WebGestureEvent::GestureScrollBegin,
+      blink::WebInputEvent::NoModifiers,
+      blink::WebInputEvent::TimeStampForTesting);
   gesture_event.sourceDevice = blink::WebGestureDeviceTouchpad;
   gesture_event.x = 1;
   gesture_event.y = 1;
   rwhv_nested->GetRenderWidgetHost()->ForwardGestureEvent(gesture_event);
 
-  gesture_event.type = blink::WebGestureEvent::GestureScrollUpdate;
+  gesture_event.setType(blink::WebGestureEvent::GestureScrollUpdate);
   gesture_event.data.scrollUpdate.deltaX = 0.0f;
   gesture_event.data.scrollUpdate.deltaY = 6.0f;
   gesture_event.data.scrollUpdate.velocityX = 0;
   gesture_event.data.scrollUpdate.velocityY = 0;
   rwhv_nested->GetRenderWidgetHost()->ForwardGestureEvent(gesture_event);
 
-  gesture_event.type = blink::WebGestureEvent::GestureScrollEnd;
+  gesture_event.setType(blink::WebGestureEvent::GestureScrollEnd);
   rwhv_nested->GetRenderWidgetHost()->ForwardGestureEvent(gesture_event);
 
   filter->Wait();
   update_rect = filter->last_rect();
   // As above, if this loop does not terminate then it indicates an issue
   // with scroll bubbling.
   while (update_rect.y() > initial_y) {
     base::RunLoop run_loop;
     base::ThreadTaskRunnerHandle::Get()->PostDelayedTask(
         FROM_HERE, run_loop.QuitClosure(), TestTimeouts::tiny_timeout());
@@ skipping 152 matching lines @@
       static_cast<RenderWidgetHostViewBase*>(
           nested_iframe_node->current_frame_host()
               ->GetRenderWidgetHost()
               ->GetView());
 
   SurfaceHitTestReadyNotifier notifier(
       static_cast<RenderWidgetHostViewChildFrame*>(rwhv_nested));
   notifier.WaitForSurfaceReady();
 
   // Target input event to nested frame.
-  blink::WebMouseEvent nested_event;
-  nested_event.type = blink::WebInputEvent::MouseDown;
+  blink::WebMouseEvent nested_event(blink::WebInputEvent::MouseDown,
+                                    blink::WebInputEvent::NoModifiers,
+                                    blink::WebInputEvent::TimeStampForTesting);
   nested_event.button = blink::WebPointerProperties::Button::Left;
   nested_event.x = 125;
   nested_event.y = 125;
   nested_event.clickCount = 1;
   nested_frame_monitor.ResetEventReceived();
   main_frame_monitor.ResetEventReceived();
   router->RouteMouseEvent(root_view, &nested_event, ui::LatencyInfo());
 
   EXPECT_TRUE(nested_frame_monitor.EventWasReceived());
   EXPECT_EQ(21, nested_frame_monitor.event().x);
@@ skipping 39 matching lines @@
   RenderWidgetHostViewBase* root_view = static_cast<RenderWidgetHostViewBase*>(
       root->current_frame_host()->GetRenderWidgetHost()->GetView());
   RenderWidgetHostViewBase* rwhv_child = static_cast<RenderWidgetHostViewBase*>(
       child_node->current_frame_host()->GetRenderWidgetHost()->GetView());
 
   SurfaceHitTestReadyNotifier notifier(
       static_cast<RenderWidgetHostViewChildFrame*>(rwhv_child));
   notifier.WaitForSurfaceReady();
 
   // Target input event to child frame.
-  blink::WebMouseEvent child_event;
-  child_event.type = blink::WebInputEvent::MouseDown;
+  blink::WebMouseEvent child_event(blink::WebInputEvent::MouseDown,
+                                   blink::WebInputEvent::NoModifiers,
+                                   blink::WebInputEvent::TimeStampForTesting);
   child_event.button = blink::WebPointerProperties::Button::Left;
   child_event.x = 75;
   child_event.y = 75;
   child_event.clickCount = 1;
   main_frame_monitor.ResetEventReceived();
   child_frame_monitor.ResetEventReceived();
   router->RouteMouseEvent(root_view, &child_event, ui::LatencyInfo());
 
   EXPECT_TRUE(main_frame_monitor.EventWasReceived());
   EXPECT_EQ(75, main_frame_monitor.event().x);
@@ skipping 64 matching lines @@
       b_node->current_frame_host()->GetRenderWidgetHost());
   RenderWidgetHostMouseEventMonitor c_frame_monitor(
       c_node->current_frame_host()->GetRenderWidgetHost());
   RenderWidgetHostMouseEventMonitor d_frame_monitor(
       d_node->current_frame_host()->GetRenderWidgetHost());
 
   gfx::Point point_in_a_frame(2, 2);
   gfx::Point point_in_b_frame(313, 147);
   gfx::Point point_in_d_frame(471, 207);
 
-  blink::WebMouseEvent mouse_event;
-  mouse_event.type = blink::WebInputEvent::MouseMove;
+  blink::WebMouseEvent mouse_event(blink::WebInputEvent::MouseMove,
+                                   blink::WebInputEvent::NoModifiers,
+                                   blink::WebInputEvent::TimeStampForTesting);
   mouse_event.x = point_in_a_frame.x();
   mouse_event.y = point_in_a_frame.y();
 
   // Send an initial MouseMove to the root view, which shouldn't affect the
   // other renderers.
   web_contents()->GetInputEventRouter()->RouteMouseEvent(rwhv_a, &mouse_event,
                                                          ui::LatencyInfo());
   EXPECT_TRUE(a_frame_monitor.EventWasReceived());
   a_frame_monitor.ResetEventReceived();
   EXPECT_FALSE(b_frame_monitor.EventWasReceived());
@@ skipping 67 matching lines @@
   RenderWidgetHostViewBase* root_view = static_cast<RenderWidgetHostViewBase*>(
       root->current_frame_host()->GetRenderWidgetHost()->GetView());
   RenderWidgetHostViewBase* rwhv_child = static_cast<RenderWidgetHostViewBase*>(
       child_node->current_frame_host()->GetRenderWidgetHost()->GetView());
 
   SurfaceHitTestReadyNotifier notifier(
       static_cast<RenderWidgetHostViewChildFrame*>(rwhv_child));
   notifier.WaitForSurfaceReady();
 
   // Target MouseDown to child frame.
-  blink::WebMouseEvent mouse_event;
-  mouse_event.type = blink::WebInputEvent::MouseDown;
+  blink::WebMouseEvent mouse_event(blink::WebInputEvent::MouseDown,
+                                   blink::WebInputEvent::NoModifiers,
+                                   blink::WebInputEvent::TimeStampForTesting);
   mouse_event.button = blink::WebPointerProperties::Button::Left;
   mouse_event.x = 75;
   mouse_event.y = 75;
   mouse_event.clickCount = 1;
   main_frame_monitor.ResetEventReceived();
   child_frame_monitor.ResetEventReceived();
   router->RouteMouseEvent(root_view, &mouse_event, ui::LatencyInfo());
 
   EXPECT_FALSE(main_frame_monitor.EventWasReceived());
   EXPECT_TRUE(child_frame_monitor.EventWasReceived());
 
   // Target MouseMove to main frame. This should still be routed to the
   // child frame because it is now capturing mouse input.
-  mouse_event.type = blink::WebInputEvent::MouseMove;
-  mouse_event.modifiers = blink::WebInputEvent::LeftButtonDown;
+  mouse_event.setType(blink::WebInputEvent::MouseMove);
+  mouse_event.setModifiers(blink::WebInputEvent::LeftButtonDown);
   mouse_event.x = 1;
   mouse_event.y = 1;
   // Note that this event is sent twice, with the monitors cleared after
   // the first time, because the first MouseMove to the child frame
   // causes a MouseMove to be sent to the main frame also, which we
   // need to ignore.
   router->RouteMouseEvent(root_view, &mouse_event, ui::LatencyInfo());
   main_frame_monitor.ResetEventReceived();
   child_frame_monitor.ResetEventReceived();
   mouse_event.x = 1;
   mouse_event.y = 2;
   router->RouteMouseEvent(root_view, &mouse_event, ui::LatencyInfo());
 
   EXPECT_FALSE(main_frame_monitor.EventWasReceived());
   EXPECT_TRUE(child_frame_monitor.EventWasReceived());
 
   // A MouseUp to the child frame should cancel the mouse capture.
-  mouse_event.type = blink::WebInputEvent::MouseUp;
-  mouse_event.modifiers = 0;
+  mouse_event.setType(blink::WebInputEvent::MouseUp);
+  mouse_event.setModifiers(blink::WebInputEvent::NoModifiers);
   mouse_event.x = 75;
   mouse_event.y = 75;
   main_frame_monitor.ResetEventReceived();
   child_frame_monitor.ResetEventReceived();
   router->RouteMouseEvent(root_view, &mouse_event, ui::LatencyInfo());
 
   EXPECT_FALSE(main_frame_monitor.EventWasReceived());
   EXPECT_TRUE(child_frame_monitor.EventWasReceived());
 
   // Subsequent MouseMove events targeted to the main frame should be routed
   // to that frame.
-  mouse_event.type = blink::WebInputEvent::MouseMove;
+  mouse_event.setType(blink::WebInputEvent::MouseMove);
   mouse_event.x = 1;
   mouse_event.y = 3;
   // Sending the MouseMove twice for the same reason as above.
   router->RouteMouseEvent(root_view, &mouse_event, ui::LatencyInfo());
   main_frame_monitor.ResetEventReceived();
   child_frame_monitor.ResetEventReceived();
   mouse_event.x = 1;
   mouse_event.y = 4;
   router->RouteMouseEvent(root_view, &mouse_event, ui::LatencyInfo());
 
   EXPECT_TRUE(main_frame_monitor.EventWasReceived());
   EXPECT_FALSE(child_frame_monitor.EventWasReceived());
 
   // Target MouseDown to the main frame to cause it to capture input.
-  mouse_event.type = blink::WebInputEvent::MouseDown;
+  mouse_event.setType(blink::WebInputEvent::MouseDown);
   mouse_event.x = 1;
   mouse_event.y = 1;
   main_frame_monitor.ResetEventReceived();
   child_frame_monitor.ResetEventReceived();
   router->RouteMouseEvent(root_view, &mouse_event, ui::LatencyInfo());
 
   EXPECT_TRUE(main_frame_monitor.EventWasReceived());
   EXPECT_FALSE(child_frame_monitor.EventWasReceived());
 
   // Sending a MouseMove to the child frame should still result in the main
   // frame receiving the event.
-  mouse_event.type = blink::WebInputEvent::MouseMove;
-  mouse_event.modifiers = blink::WebInputEvent::LeftButtonDown;
+  mouse_event.setType(blink::WebInputEvent::MouseMove);
+  mouse_event.setModifiers(blink::WebInputEvent::LeftButtonDown);
   mouse_event.x = 75;
   mouse_event.y = 75;
   main_frame_monitor.ResetEventReceived();
   child_frame_monitor.ResetEventReceived();
   router->RouteMouseEvent(root_view, &mouse_event, ui::LatencyInfo());
 
   EXPECT_TRUE(main_frame_monitor.EventWasReceived());
   EXPECT_FALSE(child_frame_monitor.EventWasReceived());
 }
 
@@ skipping 3642 matching lines @@
 
   FrameTreeNode* child_node = root->child_at(0);
   EXPECT_NE(shell()->web_contents()->GetSiteInstance(),
             child_node->current_frame_host()->GetSiteInstance());
 
   scoped_refptr<CursorMessageFilter> filter = new CursorMessageFilter();
   child_node->current_frame_host()->GetProcess()->AddFilter(filter.get());
 
   // Send a MouseMove to the subframe. The frame contains text, and moving the
   // mouse over it should cause the renderer to send a mouse cursor update.
-  blink::WebMouseEvent mouse_event;
-  mouse_event.type = blink::WebInputEvent::MouseMove;
+  blink::WebMouseEvent mouse_event(blink::WebInputEvent::MouseMove,
+                                   blink::WebInputEvent::NoModifiers,
+                                   blink::WebInputEvent::TimeStampForTesting);
   mouse_event.x = 60;
   mouse_event.y = 60;
   RenderWidgetHost* rwh_child =
       root->child_at(0)->current_frame_host()->GetRenderWidgetHost();
   RenderWidgetHostViewBase* root_view = static_cast<RenderWidgetHostViewBase*>(
       root->current_frame_host()->GetRenderWidgetHost()->GetView());
   web_contents()->GetInputEventRouter()->RouteMouseEvent(
       root_view, &mouse_event, ui::LatencyInfo());
 
   // CursorMessageFilter::Wait() implicitly tests whether we receive a
@@ skipping 506 matching lines @@
   ContextMenuObserverDelegate context_menu_delegate;
   shell->web_contents()->SetDelegate(&context_menu_delegate);
 
   RenderWidgetHostInputEventRouter* router =
       static_cast<WebContentsImpl*>(shell->web_contents())
           ->GetInputEventRouter();
 
   gfx::Point point(75, 75);
 
   // Target right-click event to child frame.
-  blink::WebMouseEvent click_event;
-  click_event.type = blink::WebInputEvent::MouseDown;
+  blink::WebMouseEvent click_event(blink::WebInputEvent::MouseDown,
+                                   blink::WebInputEvent::NoModifiers,
+                                   blink::WebInputEvent::TimeStampForTesting);
   click_event.button = blink::WebPointerProperties::Button::Right;
   click_event.x = point.x();
   click_event.y = point.y();
   click_event.clickCount = 1;
   router->RouteMouseEvent(root_view, &click_event, ui::LatencyInfo());
 
   // We also need a MouseUp event, needed by Windows.
-  click_event.type = blink::WebInputEvent::MouseUp;
+  click_event.setType(blink::WebInputEvent::MouseUp);
   click_event.x = point.x();
   click_event.y = point.y();
   router->RouteMouseEvent(root_view, &click_event, ui::LatencyInfo());
 
   context_menu_delegate.Wait();
 
   ContextMenuParams params = context_menu_delegate.getParams();
 
   EXPECT_EQ(point.x(), params.x);
   EXPECT_EQ(point.y(), params.y);
@@ skipping 125 matching lines @@
   RenderWidgetHostViewBase* rwhv_child = static_cast<RenderWidgetHostViewBase*>(
       child_node->current_frame_host()->GetRenderWidgetHost()->GetView());
 
   EXPECT_NE(shell()->web_contents()->GetSiteInstance(),
             child_node->current_frame_host()->GetSiteInstance());
 
   scoped_refptr<ShowWidgetMessageFilter> filter = new ShowWidgetMessageFilter();
   child_node->current_frame_host()->GetProcess()->AddFilter(filter.get());
 
   // Target left-click event to child frame.
-  blink::WebMouseEvent click_event;
-  click_event.type = blink::WebInputEvent::MouseDown;
+  blink::WebMouseEvent click_event(blink::WebInputEvent::MouseDown,
+                                   blink::WebInputEvent::NoModifiers,
+                                   blink::WebInputEvent::TimeStampForTesting);
   click_event.button = blink::WebPointerProperties::Button::Left;
   click_event.x = 15;
   click_event.y = 15;
   click_event.clickCount = 1;
   rwhv_child->ProcessMouseEvent(click_event, ui::LatencyInfo());
 
   // Dismiss the popup.
   click_event.x = 1;
   click_event.y = 1;
   rwhv_child->ProcessMouseEvent(click_event, ui::LatencyInfo());
@@ skipping 53 matching lines @@
       static_cast<RenderWidgetHostViewBase*>(
           c_node->current_frame_host()->GetRenderWidgetHost()->GetView());
 
   EXPECT_NE(shell()->web_contents()->GetSiteInstance(),
             c_node->current_frame_host()->GetSiteInstance());
 
   scoped_refptr<ShowWidgetMessageFilter> filter = new ShowWidgetMessageFilter();
   c_node->current_frame_host()->GetProcess()->AddFilter(filter.get());
 
   // Target left-click event to child frame.
-  blink::WebMouseEvent click_event;
-  click_event.type = blink::WebInputEvent::MouseDown;
+  blink::WebMouseEvent click_event(blink::WebInputEvent::MouseDown,
+                                   blink::WebInputEvent::NoModifiers,
+                                   blink::WebInputEvent::TimeStampForTesting);
   click_event.button = blink::WebPointerProperties::Button::Left;
   click_event.x = 15;
   click_event.y = 15;
   click_event.clickCount = 1;
   rwhv_c_node->ProcessMouseEvent(click_event, ui::LatencyInfo());
 
   // Prompt the WebContents to dismiss the popup by clicking elsewhere.
   click_event.x = 1;
   click_event.y = 1;
   rwhv_c_node->ProcessMouseEvent(click_event, ui::LatencyInfo());
@@ skipping 1600 matching lines @@
   // Navigate both subframes to a page with a <select> element.
   NavigateFrameToURL(child1, embedded_test_server()->GetURL(
       "b.com", "/site_isolation/page-with-select.html"));
   NavigateFrameToURL(child2, embedded_test_server()->GetURL(
       "c.com", "/site_isolation/page-with-select.html"));
 
   // Open both <select> menus by focusing each item and sending a space key
   // at the focused node. This creates a popup widget in both processes.
   // Wait for and then drop the ViewHostMsg_ShowWidget messages, so that both
   // widgets are left in pending-but-not-shown state.
-  NativeWebKeyboardEvent event;
+  NativeWebKeyboardEvent event(blink::WebKeyboardEvent::Char,
+                               blink::WebInputEvent::NoModifiers,
+                               blink::WebInputEvent::TimeStampForTesting);
   event.text[0] = ' ';
-  event.timeStampSeconds = 100;
-  event.type = blink::WebKeyboardEvent::Char;
 
   scoped_refptr<PendingWidgetMessageFilter> filter1 =
       new PendingWidgetMessageFilter();
   process1->AddFilter(filter1.get());
   EXPECT_TRUE(ExecuteScript(child1, "focusSelectMenu();"));
   child1->current_frame_host()->GetRenderWidgetHost()->ForwardKeyboardEvent(
       event);
   filter1->Wait();
 
   scoped_refptr<PendingWidgetMessageFilter> filter2 =
@@ skipping 1179 matching lines @@
       root->current_frame_host()->GetRenderWidgetHost()->GetView());
 
   RenderWidgetHostInputEventRouter* router =
       static_cast<WebContentsImpl*>(shell()->web_contents())
           ->GetInputEventRouter();
 
   // Create listener for input events.
   RenderWidgetHostMouseEventMonitor event_monitor(
       root->current_frame_host()->GetRenderWidgetHost());
 
-  blink::WebMouseEvent mouse_event;
-  mouse_event.type = blink::WebInputEvent::MouseDown;
+  blink::WebMouseEvent mouse_event(blink::WebInputEvent::MouseDown,
+                                   blink::WebInputEvent::NoModifiers,
+                                   blink::WebInputEvent::TimeStampForTesting);
   mouse_event.button = blink::WebPointerProperties::Button::Left;
   mouse_event.x = 75;
   mouse_event.y = 75;
   mouse_event.clickCount = 1;
   event_monitor.ResetEventReceived();
   router->RouteMouseEvent(rwhv, &mouse_event, ui::LatencyInfo());
 
   EXPECT_TRUE(event_monitor.EventWasReceived());
   gfx::Point mouse_down_coords =
       gfx::Point(event_monitor.event().x, event_monitor.event().y);
   event_monitor.ResetEventReceived();
 
-  mouse_event.type = blink::WebInputEvent::MouseUp;
+  mouse_event.setType(blink::WebInputEvent::MouseUp);
   mouse_event.x = 75;
   mouse_event.y = 75;
   router->RouteMouseEvent(rwhv, &mouse_event, ui::LatencyInfo());
 
   EXPECT_TRUE(event_monitor.EventWasReceived());
   EXPECT_EQ(mouse_down_coords,
             gfx::Point(event_monitor.event().x, event_monitor.event().y));
 }
 
 // This tests that we don't hide the RenderViewHost when reusing the
@@ skipping 65 matching lines @@
   rfh->OnSwappedOut();
 
   // Wait for the new a.com navigation to finish.
   back_observer.Wait();
 
   // The RVH for a.com should've been reused, and it should be active.
   EXPECT_TRUE(rvh->is_active());
 }
 
 }  // namespace content