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

content/public/test/browser_test_utils.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/public/test/browser_test_utils.h"
 
 #include <stddef.h>
 #include <tuple>
 #include <utility>
 
@@ skipping 62 matching lines @@
 #include "net/test/python_utils.h"
 #include "net/url_request/url_request_context.h"
 #include "net/url_request/url_request_context_getter.h"
 #include "storage/browser/fileapi/file_system_context.h"
 #include "testing/gtest/include/gtest/gtest.h"
 #include "ui/base/clipboard/clipboard.h"
 #include "ui/base/clipboard/scoped_clipboard_writer.h"
 #include "ui/base/resource/resource_bundle.h"
 #include "ui/base/test/test_clipboard.h"
 #include "ui/compositor/test/draw_waiter_for_test.h"
+#include "ui/events/base_event_utils.h"
 #include "ui/events/gesture_detection/gesture_configuration.h"
 #include "ui/events/keycodes/dom/dom_code.h"
 #include "ui/events/keycodes/dom/keycode_converter.h"
 #include "ui/events/latency_info.h"
 #include "ui/resources/grit/webui_resources.h"
 
 #if defined(USE_AURA)
 #include "content/browser/renderer_host/render_widget_host_view_aura.h"
 #include "ui/aura/test/window_event_dispatcher_test_api.h"
 #include "ui/aura/window.h"
@@ skipping 106 matching lines @@
     return false;
   }
 
   return true;
 }
 
 void BuildSimpleWebKeyEvent(blink::WebInputEvent::Type type,
                             ui::DomKey key,
                             ui::DomCode code,
                             ui::KeyboardCode key_code,
-                            int modifiers,
                             NativeWebKeyboardEvent* event) {
   event->domKey = key;
   event->domCode = static_cast<int>(code);
   event->nativeKeyCode = ui::KeycodeConverter::DomCodeToNativeKeycode(code);
   event->windowsKeyCode = key_code;
-  event->type = type;
-  event->modifiers = modifiers;
   event->isSystemKey = false;
-  event->timeStampSeconds =
-      (base::TimeTicks::Now() - base::TimeTicks()).InSecondsF();
   event->skip_in_browser = true;
 
   if (type == blink::WebInputEvent::Char ||
       type == blink::WebInputEvent::RawKeyDown) {
     event->text[0] = key_code;
     event->unmodifiedText[0] = key_code;
   }
 }
 
 void InjectRawKeyEvent(WebContents* web_contents,
                        blink::WebInputEvent::Type type,
                        ui::DomKey key,
                        ui::DomCode code,
                        ui::KeyboardCode key_code,
                        int modifiers) {
-  NativeWebKeyboardEvent event;
-  BuildSimpleWebKeyEvent(type, key, code, key_code, modifiers, &event);
+  NativeWebKeyboardEvent event(type, modifiers, base::TimeTicks::Now());
+  BuildSimpleWebKeyEvent(type, key, code, key_code, &event);
   WebContentsImpl* web_contents_impl =
       static_cast<WebContentsImpl*>(web_contents);
   RenderWidgetHostImpl* main_frame_rwh =
       web_contents_impl->GetMainFrame()->GetRenderWidgetHost();
   web_contents_impl->GetFocusedRenderWidgetHost(main_frame_rwh)
       ->ForwardKeyboardEvent(event);
 }
 
 void GetCookiesCallback(std::string* cookies_out,
                         base::WaitableEvent* event,
@@ skipping 276 matching lines @@
                         blink::WebMouseEvent::Button button) {
   int x = web_contents->GetContainerBounds().width() / 2;
   int y = web_contents->GetContainerBounds().height() / 2;
   SimulateMouseClickAt(web_contents, modifiers, button, gfx::Point(x, y));
 }
 
 void SimulateMouseClickAt(WebContents* web_contents,
                           int modifiers,
                           blink::WebMouseEvent::Button button,
                           const gfx::Point& point) {
-  blink::WebMouseEvent mouse_event;
-  mouse_event.type = blink::WebInputEvent::MouseDown;
+  blink::WebMouseEvent mouse_event(
+      blink::WebInputEvent::MouseDown, modifiers,
+      ui::EventTimeStampToSeconds(ui::EventTimeForNow()));
   mouse_event.button = button;
   mouse_event.x = point.x();
   mouse_event.y = point.y();
-  mouse_event.modifiers = modifiers;
   // Mac needs globalX/globalY for events to plugins.
   gfx::Rect offset = web_contents->GetContainerBounds();
   mouse_event.globalX = point.x() + offset.x();
   mouse_event.globalY = point.y() + offset.y();
   mouse_event.clickCount = 1;
   web_contents->GetRenderViewHost()->GetWidget()->ForwardMouseEvent(
       mouse_event);
-  mouse_event.type = blink::WebInputEvent::MouseUp;
+  mouse_event.setType(blink::WebInputEvent::MouseUp);
   web_contents->GetRenderViewHost()->GetWidget()->ForwardMouseEvent(
       mouse_event);
 }
 
 void SimulateMouseEvent(WebContents* web_contents,
                         blink::WebInputEvent::Type type,
                         const gfx::Point& point) {
-  blink::WebMouseEvent mouse_event;
-  mouse_event.type = type;
+  blink::WebMouseEvent mouse_event(
+      type, blink::WebInputEvent::NoModifiers,
+      ui::EventTimeStampToSeconds(ui::EventTimeForNow()));
   mouse_event.x = point.x();
   mouse_event.y = point.y();
   web_contents->GetRenderViewHost()->GetWidget()->ForwardMouseEvent(
       mouse_event);
 }
 
 void SimulateMouseWheelEvent(WebContents* web_contents,
                              const gfx::Point& point,
                              const gfx::Vector2d& delta) {
-  blink::WebMouseWheelEvent wheel_event;
-  wheel_event.type = blink::WebInputEvent::MouseWheel;
+  blink::WebMouseWheelEvent wheel_event(
+      blink::WebInputEvent::MouseWheel, blink::WebInputEvent::NoModifiers,
+      ui::EventTimeStampToSeconds(ui::EventTimeForNow()));
+
   wheel_event.x = point.x();
   wheel_event.y = point.y();
   wheel_event.deltaX = delta.x();
   wheel_event.deltaY = delta.y();
   RenderWidgetHostImpl* widget_host = RenderWidgetHostImpl::From(
       web_contents->GetRenderViewHost()->GetWidget());
   widget_host->ForwardWheelEvent(wheel_event);
 }
 
 void SimulateGestureScrollSequence(WebContents* web_contents,
                                    const gfx::Point& point,
                                    const gfx::Vector2dF& delta) {
   RenderWidgetHostImpl* widget_host = RenderWidgetHostImpl::From(
       web_contents->GetRenderViewHost()->GetWidget());
 
-  blink::WebGestureEvent scroll_begin;
-  scroll_begin.type = blink::WebGestureEvent::GestureScrollBegin;
+  blink::WebGestureEvent scroll_begin(
+      blink::WebGestureEvent::GestureScrollBegin,
+      blink::WebInputEvent::NoModifiers,
+      ui::EventTimeStampToSeconds(ui::EventTimeForNow()));
   scroll_begin.sourceDevice = blink::WebGestureDeviceTouchpad;
   scroll_begin.x = point.x();
   scroll_begin.y = point.y();
   widget_host->ForwardGestureEvent(scroll_begin);
 
-  blink::WebGestureEvent scroll_update;
-  scroll_update.type = blink::WebGestureEvent::GestureScrollUpdate;
+  blink::WebGestureEvent scroll_update(
+      blink::WebGestureEvent::GestureScrollUpdate,
+      blink::WebInputEvent::NoModifiers,
+      ui::EventTimeStampToSeconds(ui::EventTimeForNow()));
   scroll_update.sourceDevice = blink::WebGestureDeviceTouchpad;
   scroll_update.x = point.x();
   scroll_update.y = point.y();
   scroll_update.data.scrollUpdate.deltaX = delta.x();
   scroll_update.data.scrollUpdate.deltaY = delta.y();
   scroll_update.data.scrollUpdate.velocityX = 0;
   scroll_update.data.scrollUpdate.velocityY = 0;
   widget_host->ForwardGestureEvent(scroll_update);
 
-  blink::WebGestureEvent scroll_end;
-  scroll_end.type = blink::WebGestureEvent::GestureScrollEnd;
+  blink::WebGestureEvent scroll_end(
+      blink::WebGestureEvent::GestureScrollEnd,
+      blink::WebInputEvent::NoModifiers,
+      ui::EventTimeStampToSeconds(ui::EventTimeForNow()));
   scroll_end.sourceDevice = blink::WebGestureDeviceTouchpad;
   scroll_end.x = point.x() + delta.x();
   scroll_end.y = point.y() + delta.y();
   widget_host->ForwardGestureEvent(scroll_end);
 }
 
 void SimulateGestureFlingSequence(WebContents* web_contents,
                                   const gfx::Point& point,
                                   const gfx::Vector2dF& velocity) {
   RenderWidgetHostImpl* widget_host = RenderWidgetHostImpl::From(
       web_contents->GetRenderViewHost()->GetWidget());
 
-  blink::WebGestureEvent scroll_begin;
-  scroll_begin.type = blink::WebGestureEvent::GestureScrollBegin;
+  blink::WebGestureEvent scroll_begin(
+      blink::WebGestureEvent::GestureScrollBegin,
+      blink::WebInputEvent::NoModifiers,
+      ui::EventTimeStampToSeconds(ui::EventTimeForNow()));
   scroll_begin.sourceDevice = blink::WebGestureDeviceTouchpad;
   scroll_begin.x = point.x();
   scroll_begin.y = point.y();
   widget_host->ForwardGestureEvent(scroll_begin);
 
-  blink::WebGestureEvent scroll_end;
-  scroll_end.type = blink::WebGestureEvent::GestureScrollEnd;
+  blink::WebGestureEvent scroll_end(
+      blink::WebGestureEvent::GestureScrollEnd,
+      blink::WebInputEvent::NoModifiers,
+      ui::EventTimeStampToSeconds(ui::EventTimeForNow()));
   scroll_end.sourceDevice = blink::WebGestureDeviceTouchpad;
   scroll_end.x = point.x();
   scroll_end.y = point.y();
   widget_host->ForwardGestureEvent(scroll_end);
 
-  blink::WebGestureEvent fling_start;
-  fling_start.type = blink::WebGestureEvent::GestureFlingStart;
+  blink::WebGestureEvent fling_start(
+      blink::WebGestureEvent::GestureFlingStart,
+      blink::WebInputEvent::NoModifiers,
+      ui::EventTimeStampToSeconds(ui::EventTimeForNow()));
   fling_start.sourceDevice = blink::WebGestureDeviceTouchpad;
   fling_start.x = point.x();
   fling_start.y = point.y();
   fling_start.data.flingStart.targetViewport = false;
   fling_start.data.flingStart.velocityX = velocity.x();
   fling_start.data.flingStart.velocityY = velocity.y();
   widget_host->ForwardGestureEvent(fling_start);
 }
 
 void SimulateTapAt(WebContents* web_contents, const gfx::Point& point) {
-  blink::WebGestureEvent tap;
-  tap.type = blink::WebGestureEvent::GestureTap;
+  blink::WebGestureEvent tap(
+      blink::WebGestureEvent::GestureTap, blink::WebInputEvent::ControlKey,
+      ui::EventTimeStampToSeconds(ui::EventTimeForNow()));
   tap.sourceDevice = blink::WebGestureDeviceTouchpad;
   tap.x = point.x();
   tap.y = point.y();
-  tap.modifiers = blink::WebInputEvent::ControlKey;
   RenderWidgetHostImpl* widget_host = RenderWidgetHostImpl::From(
       web_contents->GetRenderViewHost()->GetWidget());
   widget_host->ForwardGestureEvent(tap);
 }
 
 void SimulateTapWithModifiersAt(WebContents* web_contents,
                                 unsigned modifiers,
                                 const gfx::Point& point) {
-  blink::WebGestureEvent tap;
-  tap.type = blink::WebGestureEvent::GestureTap;
+  blink::WebGestureEvent tap(
+      blink::WebGestureEvent::GestureTap, modifiers,
+      ui::EventTimeStampToSeconds(ui::EventTimeForNow()));
   tap.sourceDevice = blink::WebGestureDeviceTouchpad;
   tap.x = point.x();
   tap.y = point.y();
-  tap.modifiers = modifiers;
   RenderWidgetHostImpl* widget_host = RenderWidgetHostImpl::From(
       web_contents->GetRenderViewHost()->GetWidget());
   widget_host->ForwardGestureEvent(tap);
 }
 
 #if defined(USE_AURA)
 void SimulateTouchPressAt(WebContents* web_contents, const gfx::Point& point) {
   ui::TouchEvent touch(ui::ET_TOUCH_PRESSED, point, 0, base::TimeTicks());
   static_cast<RenderWidgetHostViewAura*>(
       web_contents->GetRenderWidgetHostView())
@@ skipping 1170 matching lines @@
   IPC::IpcSecurityTestUtil::PwnMessageReceived(
       process->GetChannel(),
       FileSystemHostMsg_Write(request_id, file_path, blob_uuid, position));
 
   // If this started an async operation, wait for it to complete.
   if (waiter.did_start_update())
     waiter.WaitForEndUpdate();
 }
 
 }  // namespace content