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

ui/events/blink/blink_event_util.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.
 
 // MSVC++ requires this to be set before any other includes to get M_PI.
 #define _USE_MATH_DEFINES
 
 #include "ui/events/blink/blink_event_util.h"
 
 #include <stddef.h>
@@ skipping 513 matching lines @@
   return std::make_pair(scroll_event, pinch_event);
 }
 
 blink::WebTouchEvent CreateWebTouchEventFromMotionEvent(
     const MotionEvent& event,
     bool moved_beyond_slop_region) {
   static_assert(static_cast<int>(MotionEvent::MAX_TOUCH_POINT_COUNT) ==
                     static_cast<int>(blink::WebTouchEvent::kTouchesLengthCap),
                 "inconsistent maximum number of active touch points");
 
-  blink::WebTouchEvent result;
-
-  result.type = ToWebTouchEventType(event.GetAction());
+  blink::WebTouchEvent result(
+      ToWebTouchEventType(event.GetAction()),
+      EventFlagsToWebEventModifiers(event.GetFlags()),
+      ui::EventTimeStampToSeconds(event.GetEventTime()));
   result.dispatchType = result.type == WebInputEvent::TouchCancel
                             ? WebInputEvent::EventNonBlocking
                             : WebInputEvent::Blocking;
-  result.timeStampSeconds = ui::EventTimeStampToSeconds(event.GetEventTime());
   result.movedBeyondSlopRegion = moved_beyond_slop_region;
 
-  result.modifiers = EventFlagsToWebEventModifiers(event.GetFlags());
   // TODO(mustaq): MotionEvent flags seems unrelated, should use
   // metaState instead?
 
   DCHECK_NE(event.GetUniqueEventId(), 0U);
   result.uniqueTouchEventId = event.GetUniqueEventId();
   result.touchesLength =
       std::min(static_cast<unsigned>(event.GetPointerCount()),
                static_cast<unsigned>(WebTouchEvent::kTouchesLengthCap));
   DCHECK_GT(result.touchesLength, 0U);
 
@@ skipping 35 matching lines @@
 
   return modifiers;
 }
 
 WebGestureEvent CreateWebGestureEvent(const GestureEventDetails& details,
                                       base::TimeTicks timestamp,
                                       const gfx::PointF& location,
                                       const gfx::PointF& raw_location,
                                       int flags,
                                       uint32_t unique_touch_event_id) {
-  WebGestureEvent gesture;
-  gesture.timeStampSeconds = ui::EventTimeStampToSeconds(timestamp);
+  WebGestureEvent gesture(WebInputEvent::Undefined,
+                          EventFlagsToWebEventModifiers(flags),
+                          ui::EventTimeStampToSeconds(timestamp));
   gesture.x = gfx::ToFlooredInt(location.x());
   gesture.y = gfx::ToFlooredInt(location.y());
   gesture.globalX = gfx::ToFlooredInt(raw_location.x());
   gesture.globalY = gfx::ToFlooredInt(raw_location.y());
-  gesture.modifiers = EventFlagsToWebEventModifiers(flags);
 
   switch (details.device_type()) {
     case GestureDeviceType::DEVICE_TOUCHSCREEN:
       gesture.sourceDevice = blink::WebGestureDeviceTouchscreen;
       break;
     case GestureDeviceType::DEVICE_TOUCHPAD:
       gesture.sourceDevice = blink::WebGestureDeviceTouchpad;
       break;
     case GestureDeviceType::DEVICE_UNKNOWN:
       NOTREACHED() << "Unknown device type is not allowed";
       gesture.sourceDevice = blink::WebGestureDeviceUninitialized;
       break;
   }
 
   gesture.uniqueTouchEventId = unique_touch_event_id;
 
   switch (details.type()) {
     case ET_GESTURE_SHOW_PRESS:
-      gesture.type = WebInputEvent::GestureShowPress;
+      gesture.setType(WebInputEvent::GestureShowPress);
       gesture.data.showPress.width = details.bounding_box_f().width();
       gesture.data.showPress.height = details.bounding_box_f().height();
       break;
     case ET_GESTURE_DOUBLE_TAP:
-      gesture.type = WebInputEvent::GestureDoubleTap;
+      gesture.setType(WebInputEvent::GestureDoubleTap);
       DCHECK_EQ(1, details.tap_count());
       gesture.data.tap.tapCount = details.tap_count();
       gesture.data.tap.width = details.bounding_box_f().width();
       gesture.data.tap.height = details.bounding_box_f().height();
       break;
     case ET_GESTURE_TAP:
-      gesture.type = WebInputEvent::GestureTap;
+      gesture.setType(WebInputEvent::GestureTap);
       DCHECK_GE(details.tap_count(), 1);
       gesture.data.tap.tapCount = details.tap_count();
       gesture.data.tap.width = details.bounding_box_f().width();
       gesture.data.tap.height = details.bounding_box_f().height();
       break;
     case ET_GESTURE_TAP_UNCONFIRMED:
-      gesture.type = WebInputEvent::GestureTapUnconfirmed;
+      gesture.setType(WebInputEvent::GestureTapUnconfirmed);
       DCHECK_EQ(1, details.tap_count());
       gesture.data.tap.tapCount = details.tap_count();
       gesture.data.tap.width = details.bounding_box_f().width();
       gesture.data.tap.height = details.bounding_box_f().height();
       break;
     case ET_GESTURE_LONG_PRESS:
-      gesture.type = WebInputEvent::GestureLongPress;
+      gesture.setType(WebInputEvent::GestureLongPress);
       gesture.data.longPress.width = details.bounding_box_f().width();
       gesture.data.longPress.height = details.bounding_box_f().height();
       break;
     case ET_GESTURE_LONG_TAP:
-      gesture.type = WebInputEvent::GestureLongTap;
+      gesture.setType(WebInputEvent::GestureLongTap);
       gesture.data.longPress.width = details.bounding_box_f().width();
       gesture.data.longPress.height = details.bounding_box_f().height();
       break;
     case ET_GESTURE_TWO_FINGER_TAP:
-      gesture.type = blink::WebInputEvent::GestureTwoFingerTap;
+      gesture.setType(blink::WebInputEvent::GestureTwoFingerTap);
       gesture.data.twoFingerTap.firstFingerWidth = details.first_finger_width();
       gesture.data.twoFingerTap.firstFingerHeight =
           details.first_finger_height();
       break;
     case ET_GESTURE_SCROLL_BEGIN:
-      gesture.type = WebInputEvent::GestureScrollBegin;
+      gesture.setType(WebInputEvent::GestureScrollBegin);
       gesture.data.scrollBegin.pointerCount = details.touch_points();
       gesture.data.scrollBegin.deltaXHint = details.scroll_x_hint();
       gesture.data.scrollBegin.deltaYHint = details.scroll_y_hint();
       break;
     case ET_GESTURE_SCROLL_UPDATE:
-      gesture.type = WebInputEvent::GestureScrollUpdate;
+      gesture.setType(WebInputEvent::GestureScrollUpdate);
       gesture.data.scrollUpdate.deltaX = details.scroll_x();
       gesture.data.scrollUpdate.deltaY = details.scroll_y();
       gesture.data.scrollUpdate.previousUpdateInSequencePrevented =
           details.previous_scroll_update_in_sequence_prevented();
       break;
     case ET_GESTURE_SCROLL_END:
-      gesture.type = WebInputEvent::GestureScrollEnd;
+      gesture.setType(WebInputEvent::GestureScrollEnd);
       break;
     case ET_SCROLL_FLING_START:
-      gesture.type = WebInputEvent::GestureFlingStart;
+      gesture.setType(WebInputEvent::GestureFlingStart);
       gesture.data.flingStart.velocityX = details.velocity_x();
       gesture.data.flingStart.velocityY = details.velocity_y();
       break;
     case ET_SCROLL_FLING_CANCEL:
-      gesture.type = WebInputEvent::GestureFlingCancel;
+      gesture.setType(WebInputEvent::GestureFlingCancel);
       break;
     case ET_GESTURE_PINCH_BEGIN:
-      gesture.type = WebInputEvent::GesturePinchBegin;
+      gesture.setType(WebInputEvent::GesturePinchBegin);
       break;
     case ET_GESTURE_PINCH_UPDATE:
-      gesture.type = WebInputEvent::GesturePinchUpdate;
+      gesture.setType(WebInputEvent::GesturePinchUpdate);
       gesture.data.pinchUpdate.scale = details.scale();
       break;
     case ET_GESTURE_PINCH_END:
-      gesture.type = WebInputEvent::GesturePinchEnd;
+      gesture.setType(WebInputEvent::GesturePinchEnd);
       break;
     case ET_GESTURE_TAP_CANCEL:
-      gesture.type = WebInputEvent::GestureTapCancel;
+      gesture.setType(WebInputEvent::GestureTapCancel);
       break;
     case ET_GESTURE_TAP_DOWN:
-      gesture.type = WebInputEvent::GestureTapDown;
+      gesture.setType(WebInputEvent::GestureTapDown);
       gesture.data.tapDown.width = details.bounding_box_f().width();
       gesture.data.tapDown.height = details.bounding_box_f().height();
       break;
     case ET_GESTURE_BEGIN:
     case ET_GESTURE_END:
     case ET_GESTURE_SWIPE:
       // The caller is responsible for discarding these gestures appropriately.
-      gesture.type = WebInputEvent::Undefined;
+      gesture.setType(WebInputEvent::Undefined);
       break;
     default:
       NOTREACHED() << "EventType provided wasn't a valid gesture event: "
                    << details.type();
   }
 
   return gesture;
 }
 
 WebGestureEvent CreateWebGestureEventFromGestureEventData(
@@ skipping 239 matching lines @@
   switch (type) {
     case blink::WebGestureEvent::GestureScrollUpdate:
     case blink::WebGestureEvent::GesturePinchUpdate:
       return true;
     default:
       return false;
   }
 }
 
 }  // namespace ui