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

third_party/WebKit/Source/web/WebViewImpl.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 591 matching lines @@
   if (!event.hasPreciseScrollingDeltas)
     endActiveFlingAnimation();
 
   hidePopups();
   return PageWidgetEventHandler::handleMouseWheel(mainFrame, event);
 }
 
 WebGestureEvent WebViewImpl::createGestureScrollEventFromFling(
     WebInputEvent::Type type,
     WebGestureDevice sourceDevice) const {
-  WebGestureEvent gestureEvent;
-  gestureEvent.type = type;
+  WebGestureEvent gestureEvent(type, m_flingModifier,
+                               WTF::monotonicallyIncreasingTime());
   gestureEvent.sourceDevice = sourceDevice;
-  gestureEvent.timeStampSeconds = WTF::monotonicallyIncreasingTime();
   gestureEvent.x = m_positionOnFlingStart.x;
   gestureEvent.y = m_positionOnFlingStart.y;
   gestureEvent.globalX = m_globalPositionOnFlingStart.x;
   gestureEvent.globalY = m_globalPositionOnFlingStart.y;
-  gestureEvent.modifiers = m_flingModifier;
   return gestureEvent;
 }
 
 bool WebViewImpl::scrollBy(const WebFloatSize& delta,
                            const WebFloatSize& velocity) {
   DCHECK_NE(m_flingSourceDevice, WebGestureDeviceUninitialized);
   if (!m_page || !m_page->mainFrame() || !m_page->mainFrame()->isLocalFrame() ||
       !m_page->deprecatedLocalMainFrame()->view())
     return false;
 
   if (m_flingSourceDevice == WebGestureDeviceTouchpad) {
-    WebMouseWheelEvent syntheticWheel;
+    WebMouseWheelEvent syntheticWheel(WebInputEvent::MouseWheel,
+                                      m_flingModifier,
+                                      WTF::monotonicallyIncreasingTime());
     const float tickDivisor = WheelEvent::TickMultiplier;
 
-    syntheticWheel.type = WebInputEvent::MouseWheel;
-    syntheticWheel.timeStampSeconds = WTF::monotonicallyIncreasingTime();
     syntheticWheel.deltaX = delta.width;
     syntheticWheel.deltaY = delta.height;
     syntheticWheel.wheelTicksX = delta.width / tickDivisor;
     syntheticWheel.wheelTicksY = delta.height / tickDivisor;
     syntheticWheel.hasPreciseScrollingDeltas = true;
     syntheticWheel.x = m_positionOnFlingStart.x;
     syntheticWheel.y = m_positionOnFlingStart.y;
     syntheticWheel.globalX = m_globalPositionOnFlingStart.x;
     syntheticWheel.globalY = m_globalPositionOnFlingStart.y;
-    syntheticWheel.modifiers = m_flingModifier;
 
     if (handleMouseWheel(*m_page->deprecatedLocalMainFrame(), syntheticWheel) !=
         WebInputEventResult::NotHandled)
       return true;
 
     // TODO(dtapuska): Remove these GSB/GSE sequences when trackpad latching is
     // implemented; see crbug.com/526463.
     WebGestureEvent syntheticScrollBegin = createGestureScrollEventFromFling(
         WebInputEvent::GestureScrollBegin, WebGestureDeviceTouchpad);
     syntheticScrollBegin.data.scrollBegin.deltaXHint = delta.width;
@@ skipping 274 matching lines @@
 }
 
 WebInputEventResult WebViewImpl::handleSyntheticWheelFromTouchpadPinchEvent(
     const WebGestureEvent& pinchEvent) {
   DCHECK_EQ(pinchEvent.type, WebInputEvent::GesturePinchUpdate);
 
   // For pinch gesture events, match typical trackpad behavior on Windows by
   // sending fake wheel events with the ctrl modifier set when we see trackpad
   // pinch gestures.  Ideally we'd someday get a platform 'pinch' event and
   // send that instead.
-  WebMouseWheelEvent wheelEvent;
-  wheelEvent.type = WebInputEvent::MouseWheel;
-  wheelEvent.timeStampSeconds = pinchEvent.timeStampSeconds;
+  WebMouseWheelEvent wheelEvent(
+      WebInputEvent::MouseWheel,
+      pinchEvent.modifiers | WebInputEvent::ControlKey,
+      pinchEvent.timeStampSeconds);
   wheelEvent.windowX = wheelEvent.x = pinchEvent.x;
   wheelEvent.windowY = wheelEvent.y = pinchEvent.y;
   wheelEvent.globalX = pinchEvent.globalX;
   wheelEvent.globalY = pinchEvent.globalY;
-  wheelEvent.modifiers = pinchEvent.modifiers | WebInputEvent::ControlKey;
   wheelEvent.deltaX = 0;
 
   // The function to convert scales to deltaY values is designed to be
   // compatible with websites existing use of wheel events, and with existing
   // Windows trackpad behavior.  In particular, we want:
   //  - deltas should accumulate via addition: f(s1*s2)==f(s1)+f(s2)
   //  - deltas should invert via negation: f(1/s) == -f(s)
   //  - zoom in should be positive: f(s) > 0 iff s > 1
   //  - magnitude roughly matches wheels: f(2) > 25 && f(2) < 100
   //  - a formula that's relatively easy to use from JavaScript
@@ skipping 2818 matching lines @@
   result.setToShadowHostIfInUserAgentShadowRoot();
   return result;
 }
 
 WebHitTestResult WebViewImpl::hitTestResultForTap(
     const WebPoint& tapPointWindowPos,
     const WebSize& tapArea) {
   if (!m_page->mainFrame()->isLocalFrame())
     return HitTestResult();
 
-  WebGestureEvent tapEvent;
+  WebGestureEvent tapEvent(WebInputEvent::GestureTap,
+                           WebInputEvent::NoModifiers,
+                           WTF::monotonicallyIncreasingTime());
   tapEvent.x = tapPointWindowPos.x;
   tapEvent.y = tapPointWindowPos.y;
-  tapEvent.type = WebInputEvent::GestureTap;
   // GestureTap is only ever from a touchscreen.
   tapEvent.sourceDevice = WebGestureDeviceTouchscreen;
   tapEvent.data.tap.tapCount = 1;
   tapEvent.data.tap.width = tapArea.width;
   tapEvent.data.tap.height = tapArea.height;
 
   WebGestureEvent scaledEvent =
       TransformWebGestureEvent(mainFrameImpl()->frameView(), tapEvent);
 
   HitTestResult result =
@@ skipping 401 matching lines @@
   if (focusedFrame->localFrameRoot() != mainFrameImpl()->frame())
     return nullptr;
   return focusedFrame;
 }
 
 LocalFrame* WebViewImpl::focusedLocalFrameAvailableForIme() const {
   return m_imeAcceptEvents ? focusedLocalFrameInWidget() : nullptr;
 }
 
 }  // namespace blink