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

content/common/input/event_with_latency_info_unittest.cc

 // Copyright 2015 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/common/input/event_with_latency_info.h"
 
 #include <limits>
 
 #include "testing/gtest/include/gtest/gtest.h"
 #include "third_party/WebKit/public/platform/WebInputEvent.h"
 
 using blink::WebGestureEvent;
 using blink::WebInputEvent;
 using blink::WebMouseEvent;
 using blink::WebMouseWheelEvent;
 using blink::WebTouchEvent;
 using blink::WebTouchPoint;
 using std::numeric_limits;
 
 namespace content {
 namespace {
 
 using EventWithLatencyInfoTest = testing::Test;
 
 TouchEventWithLatencyInfo CreateTouchEvent(WebInputEvent::Type type,
                                            double timestamp,
                                            unsigned touch_count = 1) {
-  TouchEventWithLatencyInfo touch;
+  TouchEventWithLatencyInfo touch(type, WebInputEvent::NoModifiers, timestamp,
+                                  ui::LatencyInfo());
   touch.event.touchesLength = touch_count;
-  touch.event.type = type;
-  touch.event.timeStampSeconds = timestamp;
   return touch;
 }
 
 MouseEventWithLatencyInfo CreateMouseEvent(WebInputEvent::Type type,
                                            double timestamp) {
-  MouseEventWithLatencyInfo mouse;
-  mouse.event.type = type;
-  mouse.event.timeStampSeconds = timestamp;
-  return mouse;
+  return MouseEventWithLatencyInfo(type, WebInputEvent::NoModifiers, timestamp,
+                                   ui::LatencyInfo());
 }
 
-MouseWheelEventWithLatencyInfo CreateMouseWheelEvent(double timestamp,
-                                                     float deltaX = 0.0f,
-                                                     float deltaY = 0.0f) {
-  MouseWheelEventWithLatencyInfo mouse_wheel;
-  mouse_wheel.event.type = WebInputEvent::MouseWheel;
+MouseWheelEventWithLatencyInfo CreateMouseWheelEvent(
+    double timestamp,
+    float deltaX = 0.0f,
+    float deltaY = 0.0f,
+    int modifiers = WebInputEvent::NoModifiers) {
+  MouseWheelEventWithLatencyInfo mouse_wheel(
+      WebInputEvent::MouseWheel, modifiers, timestamp, ui::LatencyInfo());
   mouse_wheel.event.deltaX = deltaX;
   mouse_wheel.event.deltaY = deltaY;
-  mouse_wheel.event.timeStampSeconds = timestamp;
   return mouse_wheel;
 }
 
 GestureEventWithLatencyInfo CreateGestureEvent(WebInputEvent::Type type,
                                                double timestamp,
                                                float x = 0.0f,
                                                float y = 0.0f) {
-  GestureEventWithLatencyInfo gesture;
-  gesture.event.type = type;
+  GestureEventWithLatencyInfo gesture(type, WebInputEvent::NoModifiers,
+                                      timestamp, ui::LatencyInfo());
   gesture.event.x = x;
   gesture.event.y = y;
-  gesture.event.timeStampSeconds = timestamp;
   return gesture;
 }
 
 TEST_F(EventWithLatencyInfoTest, TimestampCoalescingForMouseEvent) {
   MouseEventWithLatencyInfo mouse_0 = CreateMouseEvent(
       WebInputEvent::MouseMove, 5.0);
   MouseEventWithLatencyInfo mouse_1 = CreateMouseEvent(
       WebInputEvent::MouseMove, 10.0);
 
   ASSERT_TRUE(mouse_0.CanCoalesceWith(mouse_1));
@@ skipping 227 matching lines @@
 }
 
 TEST_F(EventWithLatencyInfoTest, WebMouseWheelEventCoalescing) {
   MouseWheelEventWithLatencyInfo mouse_wheel_0 = CreateMouseWheel(1, 1);
   MouseWheelEventWithLatencyInfo mouse_wheel_1 = CreateMouseWheel(2, 2);
   // WebMouseWheelEvent objects with same values except different deltaX and
   // deltaY should coalesce.
   EXPECT_TRUE(CanCoalesce(mouse_wheel_0, mouse_wheel_1));
 
   // WebMouseWheelEvent objects with different modifiers should not coalesce.
-  mouse_wheel_0 = CreateMouseWheel(1, 1);
-  mouse_wheel_1 = CreateMouseWheel(1, 1);
-  mouse_wheel_0.event.modifiers = WebInputEvent::ControlKey;
-  mouse_wheel_1.event.modifiers = WebInputEvent::ShiftKey;
+  mouse_wheel_0 = CreateMouseWheelEvent(2.0, 1, 1, WebInputEvent::ControlKey);
+  mouse_wheel_1 = CreateMouseWheelEvent(2.0, 1, 1, WebInputEvent::ShiftKey);
   EXPECT_FALSE(CanCoalesce(mouse_wheel_0, mouse_wheel_1));
 
   // Coalesce old and new events.
   mouse_wheel_0 = CreateMouseWheel(1, 1);
   mouse_wheel_0.event.x = 1;
   mouse_wheel_0.event.y = 1;
   mouse_wheel_1 = CreateMouseWheel(2, 2);
   mouse_wheel_1.event.x = 2;
   mouse_wheel_1.event.y = 2;
   MouseWheelEventWithLatencyInfo mouse_wheel_1_copy = mouse_wheel_1;
@@ skipping 24 matching lines @@
       mouse_wheel_1_copy.event.wheelTicksY + mouse_wheel_0.event.wheelTicksY,
       mouse_wheel_1.event.wheelTicksY);
   EXPECT_EQ(mouse_wheel_1_copy.event.movementX + mouse_wheel_0.event.movementX,
             mouse_wheel_1.event.movementX);
   EXPECT_EQ(mouse_wheel_1_copy.event.movementY + mouse_wheel_0.event.movementY,
             mouse_wheel_1.event.movementY);
 }
 
 // Coalescing preserves the newer timestamp.
 TEST_F(EventWithLatencyInfoTest, TimestampCoalescing) {
-  MouseWheelEventWithLatencyInfo mouse_wheel_0 = CreateMouseWheel(1, 1);
-  mouse_wheel_0.event.timeStampSeconds = 5.0;
-  MouseWheelEventWithLatencyInfo mouse_wheel_1 = CreateMouseWheel(2, 2);
-  mouse_wheel_1.event.timeStampSeconds = 10.0;
+  MouseWheelEventWithLatencyInfo mouse_wheel_0 =
+      CreateMouseWheelEvent(5.0, 1, 1);
+  MouseWheelEventWithLatencyInfo mouse_wheel_1 =
+      CreateMouseWheelEvent(10.0, 2, 2);
 
   EXPECT_TRUE(CanCoalesce(mouse_wheel_0, mouse_wheel_1));
   Coalesce(mouse_wheel_1, &mouse_wheel_0);
   EXPECT_EQ(10.0, mouse_wheel_0.event.timeStampSeconds);
 }
 
 }  // namespace
 }  // namespace content