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

content/browser/renderer_host/render_widget_host_unittest.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 <stddef.h>
 #include <stdint.h>
 
 #include <memory>
 #include <tuple>
 
@@ skipping 14 matching lines @@
 #include "content/common/input_messages.h"
 #include "content/common/resize_params.h"
 #include "content/common/view_messages.h"
 #include "content/public/common/content_switches.h"
 #include "content/public/test/mock_render_process_host.h"
 #include "content/public/test/test_browser_context.h"
 #include "content/public/test/test_browser_thread_bundle.h"
 #include "content/test/test_render_view_host.h"
 #include "testing/gtest/include/gtest/gtest.h"
 #include "ui/display/screen.h"
+#include "ui/events/base_event_utils.h"
 #include "ui/events/blink/web_input_event_traits.h"
 #include "ui/events/keycodes/keyboard_codes.h"
 #include "ui/gfx/canvas.h"
 
 #if defined(OS_ANDROID)
 #include "content/browser/renderer_host/context_provider_factory_impl_android.h"
 #include "content/browser/renderer_host/render_widget_host_view_android.h"
 #include "content/test/mock_gpu_channel_establish_factory.h"
 #include "ui/android/screen_android.h"
 #endif
@@ skipping 207 matching lines @@
   }
 
   // Sets the bounds returned by GetViewBounds.
   void set_bounds(const gfx::Rect& bounds) {
     bounds_ = bounds;
   }
 
   const WebTouchEvent& acked_event() const { return acked_event_; }
   int acked_event_count() const { return acked_event_count_; }
   void ClearAckedEvent() {
-    acked_event_.type = blink::WebInputEvent::Undefined;
+    acked_event_.setType(blink::WebInputEvent::Undefined);
     acked_event_count_ = 0;
   }
 
   const WebMouseWheelEvent& unhandled_wheel_event() const {
     return unhandled_wheel_event_;
   }
   int unhandled_wheel_event_count() const {
     return unhandled_wheel_event_count_;
   }
   int gesture_event_type() const { return gesture_event_type_; }
@@ skipping 31 matching lines @@
       return mock_physical_backing_size_;
     return TestRenderWidgetHostView::GetPhysicalBackingSize();
   }
 #if defined(USE_AURA)
   ~TestView() override {
     // Simulate the mouse exit event dispatched when an aura window is
     // destroyed. (MakeWebMouseEventFromAuraEvent translates ET_MOUSE_EXITED
     // into WebInputEvent::MouseMove.)
     WebMouseEvent event =
         SyntheticWebMouseEventBuilder::Build(WebInputEvent::MouseMove);
-    event.timeStampSeconds =
-        (base::TimeTicks::Now() - base::TimeTicks()).InSecondsF();
+    event.setTimeStampSeconds(
+        ui::EventTimeStampToSeconds(ui::EventTimeForNow()));
     rwh_->input_router()->SendMouseEvent(
         MouseEventWithLatencyInfo(event, ui::LatencyInfo()));
   }
 #endif
 
  protected:
   WebMouseWheelEvent unhandled_wheel_event_;
   int unhandled_wheel_event_count_;
   WebTouchEvent acked_event_;
   int acked_event_count_;
@@ skipping 115 matching lines @@
 // RenderWidgetHostTest --------------------------------------------------------
 
 class RenderWidgetHostTest : public testing::Test {
  public:
   RenderWidgetHostTest()
       : process_(NULL),
         handle_key_press_event_(false),
         handle_mouse_event_(false),
         simulated_event_time_delta_seconds_(0) {
     last_simulated_event_time_seconds_ =
-        (base::TimeTicks::Now() - base::TimeTicks()).InSecondsF();
+        ui::EventTimeStampToSeconds(ui::EventTimeForNow());
   }
   ~RenderWidgetHostTest() override {}
 
   bool KeyPressEventCallback(const NativeWebKeyboardEvent& /* event */) {
     return handle_key_press_event_;
   }
   bool MouseEventCallback(const blink::WebMouseEvent& /* event */) {
     return handle_mouse_event_;
   }
 
@@ skipping 76 matching lines @@
   double GetNextSimulatedEventTimeSeconds() {
     last_simulated_event_time_seconds_ += simulated_event_time_delta_seconds_;
     return last_simulated_event_time_seconds_;
   }
 
   void SimulateKeyboardEvent(WebInputEvent::Type type) {
     SimulateKeyboardEvent(type, 0);
   }
 
   void SimulateKeyboardEvent(WebInputEvent::Type type, int modifiers) {
-    WebKeyboardEvent event = SyntheticWebKeyboardEventBuilder::Build(type);
-    event.modifiers = modifiers;
-    NativeWebKeyboardEvent native_event;
-    memcpy(&native_event, &event, sizeof(event));
+    NativeWebKeyboardEvent native_event(type, modifiers, ui::EventTimeForNow());

[majidvp, 2016/12/19 20:09:52]

Shouldn't this be the simulate time i.e., GetNextSimulatedEventTimeSeconds?

[dtapuska, 2016/12/20 19:49:21]

Done.

     host_->ForwardKeyboardEvent(native_event);
   }
 
   void SimulateMouseEvent(WebInputEvent::Type type) {
     host_->ForwardMouseEvent(SyntheticWebMouseEventBuilder::Build(type));
   }
 
   void SimulateMouseEventWithLatencyInfo(WebInputEvent::Type type,
                                          const ui::LatencyInfo& ui_latency) {
     host_->ForwardMouseEventWithLatencyInfo(
@@ skipping 20 matching lines @@
   void SimulateMouseMove(int x, int y, int modifiers) {
     SimulateMouseEvent(WebInputEvent::MouseMove, x, y, modifiers, false);
   }
 
   void SimulateMouseEvent(
       WebInputEvent::Type type, int x, int y, int modifiers, bool pressed) {
     WebMouseEvent event =
         SyntheticWebMouseEventBuilder::Build(type, x, y, modifiers);
     if (pressed)
       event.button = WebMouseEvent::Button::Left;
-    event.timeStampSeconds = GetNextSimulatedEventTimeSeconds();
+    event.setTimeStampSeconds(GetNextSimulatedEventTimeSeconds());
     host_->ForwardMouseEvent(event);
   }
 
   // Inject simple synthetic WebGestureEvent instances.
   void SimulateGestureEvent(WebInputEvent::Type type,
                             WebGestureDevice sourceDevice) {
     host_->ForwardGestureEvent(
         SyntheticWebGestureEventBuilder::Build(type, sourceDevice));
   }
 
@@ skipping 1112 matching lines @@
                                       ui::LatencyInfo());
 
 
   // Tests RWHI::ForwardWheelEventWithLatencyInfo().
   SimulateWheelEventWithLatencyInfo(-5, 0, 0, true, ui::LatencyInfo());
 
   ASSERT_FALSE(host_->input_router()->HasPendingEvents());
 }
 
 }  // namespace content