revert "SourceEventType added to LatencyInfo."

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"
 
 #include "cc/quads/surface_draw_quad.h"
 #include "cc/surfaces/surface_id_allocator.h"
 #include "cc/surfaces/surface_manager.h"
 #include "content/browser/frame_host/render_widget_host_view_child_frame.h"
 #include "content/browser/renderer_host/render_widget_host_impl.h"
 #include "content/browser/renderer_host/render_widget_host_view_base.h"
 #include "content/common/frame_messages.h"
 #include "third_party/WebKit/public/web/WebInputEvent.h"
-#include "ui/events/blink/web_input_event_traits.h"
 
 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();
   }
 }
@@ skipping 133 matching lines @@
   // it likely means the RenderWidgetHostView has been destroyed but its
   // parent frame has not sent a new compositor frame since that happened.
   if (iter == owner_map_.end())
     return root_view;
 
   return iter->second;
 }
 
 void RenderWidgetHostInputEventRouter::RouteMouseEvent(
     RenderWidgetHostViewBase* root_view,
-    blink::WebMouseEvent* event,
-    const ui::LatencyInfo& latency) {
+    blink::WebMouseEvent* event) {
   RenderWidgetHostViewBase* target;
   gfx::Point transformed_point;
   const int mouse_button_modifiers = blink::WebInputEvent::LeftButtonDown |
                                      blink::WebInputEvent::MiddleButtonDown |
                                      blink::WebInputEvent::RightButtonDown;
   if (mouse_capture_target_.target &&
       event->type != blink::WebInputEvent::MouseDown &&
       (event->type == blink::WebInputEvent::MouseUp ||
        event->modifiers & mouse_button_modifiers)) {
     target = mouse_capture_target_.target;
     transformed_point = root_view->TransformPointToCoordSpaceForView(
         gfx::Point(event->x, event->y), target);
     if (event->type == blink::WebInputEvent::MouseUp)
       mouse_capture_target_.target = nullptr;
   } else {
     target = FindEventTarget(root_view, gfx::Point(event->x, event->y),
                              &transformed_point);
   }
 
   // RenderWidgetHostViewGuest does not properly handle direct routing of mouse
   // events, so they have to go by the double-hop forwarding path through
   // the embedding renderer and then BrowserPluginGuest.
   if (target && target->IsRenderWidgetHostViewGuest()) {
-    root_view->ProcessMouseEvent(*event, latency);
+    ui::LatencyInfo latency_info;
+    root_view->ProcessMouseEvent(*event, latency_info);
     return;
   }
 
   if (event->type == blink::WebInputEvent::MouseDown)
     mouse_capture_target_.target = target;
 
   if (!target)
     return;
 
   // SendMouseEnterOrLeaveEvents is called with the original event
   // coordinates, which are transformed independently for each view that will
   // receive an event.
   if ((event->type == blink::WebInputEvent::MouseLeave ||
        event->type == blink::WebInputEvent::MouseMove) &&
       target != last_mouse_move_target_)
     SendMouseEnterOrLeaveEvents(event, target, root_view);
 
   event->x = transformed_point.x();
   event->y = transformed_point.y();
-  target->ProcessMouseEvent(*event, latency);
+  // TODO(wjmaclean): Initialize latency info correctly for OOPIFs.
+  // https://crbug.com/613628
+  ui::LatencyInfo latency_info;
+  target->ProcessMouseEvent(*event, latency_info);
 }
 
 void RenderWidgetHostInputEventRouter::RouteMouseWheelEvent(
     RenderWidgetHostViewBase* root_view,
-    blink::WebMouseWheelEvent* event,
-    const ui::LatencyInfo& latency) {
+    blink::WebMouseWheelEvent* event) {
   gfx::Point transformed_point;
   RenderWidgetHostViewBase* target = FindEventTarget(
       root_view, gfx::Point(event->x, event->y), &transformed_point);
   if (!target)
     return;
 
   event->x = transformed_point.x();
   event->y = transformed_point.y();
-  target->ProcessMouseWheelEvent(*event, latency);
+  // TODO(wjmaclean): Initialize latency info correctly for OOPIFs.
+  // https://crbug.com/613628
+  ui::LatencyInfo latency_info;
+  target->ProcessMouseWheelEvent(*event, latency_info);
 }
 
 void RenderWidgetHostInputEventRouter::RouteGestureEvent(
     RenderWidgetHostViewBase* root_view,
     blink::WebGestureEvent* event,
     const ui::LatencyInfo& latency) {
   switch (event->sourceDevice) {
     case blink::WebGestureDeviceUninitialized:
       NOTREACHED() << "Uninitialized device type is not allowed";
       break;
@@ skipping 219 matching lines @@
   // difficult to resolve until this is changed to do all scroll targeting,
   // including bubbling, based on GestureScrollBegin.
   DCHECK(target_view);
   DCHECK(event.type == blink::WebInputEvent::GestureScrollUpdate ||
          event.type == blink::WebInputEvent::GestureScrollEnd);
   // DCHECK_XNOR the current and original bubble targets. Both should be set
   // if a bubbling gesture scroll is in progress.
   DCHECK(!first_bubbling_scroll_target_.target ==
          !bubbling_gesture_scroll_target_.target);
 
-  ui::LatencyInfo latency_info =
-      ui::WebInputEventTraits::CreateLatencyInfoForWebGestureEvent(event);
-
   // If target_view is already set up for bubbled scrolls, we forward
   // the event to the current scroll target without further consideration.
   if (target_view == first_bubbling_scroll_target_.target) {
-    bubbling_gesture_scroll_target_.target->ProcessGestureEvent(event,
-                                                                latency_info);
+    bubbling_gesture_scroll_target_.target->ProcessGestureEvent(
+        event, ui::LatencyInfo());
     if (event.type == blink::WebInputEvent::GestureScrollEnd) {
       first_bubbling_scroll_target_.target = nullptr;
       bubbling_gesture_scroll_target_.target = nullptr;
     }
     return;
   }
 
   // Disregard GestureScrollEnd events going to non-current targets.
   // These should only happen on ACKs of synthesized GSE events that are
   // sent from SendGestureScrollEnd calls, and are not relevant here.
   if (event.type == blink::WebInputEvent::GestureScrollEnd)
     return;
 
   // This is a special case to catch races where multiple GestureScrollUpdates
   // have been sent to a renderer before the first one was ACKed, and the ACK
   // caused a bubble retarget. In this case they all get forwarded.
   if (target_view == bubbling_gesture_scroll_target_.target) {
-    bubbling_gesture_scroll_target_.target->ProcessGestureEvent(event,
-                                                                latency_info);
+    bubbling_gesture_scroll_target_.target->ProcessGestureEvent(
+        event, ui::LatencyInfo());
     return;
   }
 
   // If target_view has unrelated gesture events in progress, do
   // not proceed. This could cause confusion between independent
   // scrolls.
   if (target_view == touchscreen_gesture_target_.target ||
       target_view == touchpad_gesture_target_.target ||
       target_view == touch_target_.target)
     return;
 
   // This accounts for bubbling through nested OOPIFs. A gesture scroll has
   // been bubbled but the target has sent back a gesture scroll event ack with
   // unused scroll delta, and so another level of bubbling is needed. This
   // requires a GestureScrollEnd be sent to the last view, which will no
   // longer be the scroll target.
   if (bubbling_gesture_scroll_target_.target)
     SendGestureScrollEnd(bubbling_gesture_scroll_target_.target, event);
   else
     first_bubbling_scroll_target_.target = target_view;
 
   bubbling_gesture_scroll_target_.target = target_view;
 
   SendGestureScrollBegin(target_view, event);
-  target_view->ProcessGestureEvent(event, latency_info);
+  target_view->ProcessGestureEvent(event, ui::LatencyInfo());
 }
 
 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.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));
+  view->ProcessGestureEvent(scroll_begin, ui::LatencyInfo());
 }
 
 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.data.scrollEnd.inertialPhase =
       event.data.scrollUpdate.inertialPhase;
   scroll_end.data.scrollEnd.deltaUnits = event.data.scrollUpdate.deltaUnits;
-  view->ProcessGestureEvent(
-      scroll_end,
-      ui::WebInputEventTraits::CreateLatencyInfoForWebGestureEvent(event));
+  view->ProcessGestureEvent(scroll_end, ui::LatencyInfo());
 }
 
 void RenderWidgetHostInputEventRouter::CancelScrollBubbling(
     RenderWidgetHostViewBase* target_view) {
   DCHECK(target_view);
   if (target_view == first_bubbling_scroll_target_.target) {
     first_bubbling_scroll_target_.target = nullptr;
     bubbling_gesture_scroll_target_.target = nullptr;
   }
 }
@@ skipping 161 matching lines @@
   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