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

content/browser/renderer_host/render_widget_host_input_event_router.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/browser/renderer_host/render_widget_host_input_event_router.h"
 
 #include <vector>
 
 #include "base/metrics/histogram_macros.h"
 
@@ skipping 11 matching lines @@
 namespace {
 
 void TransformEventTouchPositions(blink::WebTouchEvent* event,
                                   const gfx::Vector2d& delta) {
   for (unsigned i = 0; i < event->touchesLength; ++i) {
      event->touches[i].position.x += delta.x();
      event->touches[i].position.y += delta.y();
   }
 }
 
-blink::WebGestureEvent DummyGestureScrollUpdate() {
-  blink::WebGestureEvent dummy_gesture_scroll_update;
-  dummy_gesture_scroll_update.type = blink::WebInputEvent::GestureScrollUpdate;
-  return dummy_gesture_scroll_update;
+blink::WebGestureEvent DummyGestureScrollUpdate(double timeStampSeconds) {
+  return blink::WebGestureEvent(blink::WebInputEvent::GestureScrollUpdate,
+                                blink::WebInputEvent::NoModifiers,
+                                timeStampSeconds);
 }
 
 }  // anonymous namespace
 
 namespace content {
 
 void RenderWidgetHostInputEventRouter::OnRenderWidgetHostViewBaseDestroyed(
     RenderWidgetHostViewBase* view) {
   view->RemoveObserver(this);
 
@@ skipping 284 matching lines @@
         // of the touch sequence, though this could be wrong; a better approach
         // might be to always transform each point to the |touch_target_.target|
         // for the duration of the sequence.
         touch_target_.delta = transformed_point - original_point;
         touchscreen_gesture_target_queue_.push_back(touch_target_);
 
         if (!touch_target_.target)
           return;
 
         if (touch_target_.target == bubbling_gesture_scroll_target_.target) {
-          SendGestureScrollEnd(bubbling_gesture_scroll_target_.target,
-                               DummyGestureScrollUpdate());
+          SendGestureScrollEnd(
+              bubbling_gesture_scroll_target_.target,
+              DummyGestureScrollUpdate(event->timeStampSeconds));
           CancelScrollBubbling(bubbling_gesture_scroll_target_.target);
         }
       }
 
       if (touch_target_.target) {
         TransformEventTouchPositions(event, touch_target_.delta);
         touch_target_.target->ProcessTouchEvent(*event, latency);
       }
       break;
     }
@@ skipping 93 matching lines @@
          entered_views.back() == exited_views.back()) {
     common_ancestor = entered_views.back();
     entered_views.pop_back();
     exited_views.pop_back();
   }
 
   gfx::Point transformed_point;
   // Send MouseLeaves.
   for (auto view : exited_views) {
     blink::WebMouseEvent mouse_leave(*event);
-    mouse_leave.type = blink::WebInputEvent::MouseLeave;
+    mouse_leave.setType(blink::WebInputEvent::MouseLeave);
     // There is a chance of a race if the last target has recently created a
     // new compositor surface. The SurfaceID for that might not have
     // propagated to its embedding surface, which makes it impossible to
     // compute the transformation for it
     if (!root_view->TransformPointToCoordSpaceForView(
             gfx::Point(event->x, event->y), view, &transformed_point))
       transformed_point = gfx::Point();
     mouse_leave.x = transformed_point.x();
     mouse_leave.y = transformed_point.y();
     view->ProcessMouseEvent(mouse_leave, ui::LatencyInfo());
   }
 
   // The ancestor might need to trigger MouseOut handlers.
   if (common_ancestor && common_ancestor != target) {
     blink::WebMouseEvent mouse_move(*event);
-    mouse_move.type = blink::WebInputEvent::MouseMove;
+    mouse_move.setType(blink::WebInputEvent::MouseMove);
     if (!root_view->TransformPointToCoordSpaceForView(
             gfx::Point(event->x, event->y), common_ancestor,
             &transformed_point))
       transformed_point = gfx::Point();
     mouse_move.x = transformed_point.x();
     mouse_move.y = transformed_point.y();
     common_ancestor->ProcessMouseEvent(mouse_move, ui::LatencyInfo());
   }
 
   // Send MouseMoves to trigger MouseEnter handlers.
   for (auto view : entered_views) {
     if (view == target)
       continue;
     blink::WebMouseEvent mouse_enter(*event);
-    mouse_enter.type = blink::WebInputEvent::MouseMove;
+    mouse_enter.setType(blink::WebInputEvent::MouseMove);
     if (!root_view->TransformPointToCoordSpaceForView(
             gfx::Point(event->x, event->y), view, &transformed_point))
       transformed_point = gfx::Point();
     mouse_enter.x = transformed_point.x();
     mouse_enter.y = transformed_point.y();
     view->ProcessMouseEvent(mouse_enter, ui::LatencyInfo());
   }
 
   last_mouse_move_target_ = target;
   last_mouse_move_root_view_ = root_view;
@@ skipping 68 matching lines @@
   SendGestureScrollBegin(target_view, event);
   target_view->ProcessGestureEvent(event, latency_info);
 }
 
 void RenderWidgetHostInputEventRouter::SendGestureScrollBegin(
     RenderWidgetHostViewBase* view,
     const blink::WebGestureEvent& event) {
   DCHECK(event.type == blink::WebInputEvent::GestureScrollUpdate ||
          event.type == blink::WebInputEvent::GesturePinchBegin);
   blink::WebGestureEvent scroll_begin(event);
-  scroll_begin.type = blink::WebInputEvent::GestureScrollBegin;
+  scroll_begin.setType(blink::WebInputEvent::GestureScrollBegin);
   scroll_begin.data.scrollBegin.deltaXHint = event.data.scrollUpdate.deltaX;
   scroll_begin.data.scrollBegin.deltaYHint = event.data.scrollUpdate.deltaY;
   scroll_begin.data.scrollBegin.deltaHintUnits =
       event.data.scrollUpdate.deltaUnits;
   view->ProcessGestureEvent(
       scroll_begin,
       ui::WebInputEventTraits::CreateLatencyInfoForWebGestureEvent(event));
 }
 
 void RenderWidgetHostInputEventRouter::SendGestureScrollEnd(
     RenderWidgetHostViewBase* view,
     const blink::WebGestureEvent& event) {
   DCHECK(event.type == blink::WebInputEvent::GestureScrollUpdate ||
          event.type == blink::WebInputEvent::GesturePinchEnd);
   blink::WebGestureEvent scroll_end(event);
-  scroll_end.type = blink::WebInputEvent::GestureScrollEnd;
-  scroll_end.timeStampSeconds =
-      (base::TimeTicks::Now() - base::TimeTicks()).InSecondsF();
+  scroll_end.setType(blink::WebInputEvent::GestureScrollEnd);
+  scroll_end.setTimeStampSeconds(
+      (base::TimeTicks::Now() - base::TimeTicks()).InSecondsF());
   scroll_end.data.scrollEnd.inertialPhase =
       event.data.scrollUpdate.inertialPhase;
   scroll_end.data.scrollEnd.deltaUnits = event.data.scrollUpdate.deltaUnits;
   view->ProcessGestureEvent(
       scroll_end,
       ui::WebInputEventTraits::CreateLatencyInfoForWebGestureEvent(event));
 }
 
 void RenderWidgetHostInputEventRouter::CancelScrollBubbling(
     RenderWidgetHostViewBase* target_view) {
@@ skipping 116 matching lines @@
     }
 
     touchscreen_gesture_target_ = touchscreen_gesture_target_queue_.front();
     touchscreen_gesture_target_queue_.pop_front();
 
     // Abort any scroll bubbling in progress to avoid double entry.
     if (touchscreen_gesture_target_.target &&
         touchscreen_gesture_target_.target ==
             bubbling_gesture_scroll_target_.target) {
       SendGestureScrollEnd(bubbling_gesture_scroll_target_.target,
-                           DummyGestureScrollUpdate());
+                           DummyGestureScrollUpdate(event->timeStampSeconds));
       CancelScrollBubbling(bubbling_gesture_scroll_target_.target);
     }
   }
 
   if (!touchscreen_gesture_target_.target)
     return;
 
   // TODO(mohsen): Add tests to check event location.
   event->x += touchscreen_gesture_target_.delta.x();
   event->y += touchscreen_gesture_target_.delta.y();
@@ skipping 17 matching lines @@
     // touchpad gesture sequence, though this could be wrong; a better approach
     // might be to always transform each point to the
     // |touchpad_gesture_target_.target| for the duration of the sequence.
     touchpad_gesture_target_.delta = transformed_point - original_point;
 
     // Abort any scroll bubbling in progress to avoid double entry.
     if (touchpad_gesture_target_.target &&
         touchpad_gesture_target_.target ==
             bubbling_gesture_scroll_target_.target) {
       SendGestureScrollEnd(bubbling_gesture_scroll_target_.target,
-                           DummyGestureScrollUpdate());
+                           DummyGestureScrollUpdate(event->timeStampSeconds));
       CancelScrollBubbling(bubbling_gesture_scroll_target_.target);
     }
   }
 
   if (!touchpad_gesture_target_.target)
     return;
 
   // TODO(mohsen): Add tests to check event location.
   event->x += touchpad_gesture_target_.delta.x();
   event->y += touchpad_gesture_target_.delta.y();
   touchpad_gesture_target_.target->ProcessGestureEvent(*event, latency);
 }
 
 }  // namespace content