Fix Event Latency Info on generate gesture events.

content/browser/renderer_host/input/mouse_wheel_event_queue.cc

 // Copyright 2016 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/input/mouse_wheel_event_queue.h"
 
 #include "base/metrics/histogram_macros.h"
 #include "base/stl_util.h"
 #include "base/trace_event/trace_event.h"
 
+using blink::WebGestureEvent;
 using blink::WebInputEvent;
 using blink::WebMouseWheelEvent;
 using ui::LatencyInfo;
 
 namespace content {
 
 // This class represents a single queued mouse wheel event. Its main use
 // is that it is reported via trace events.
 class QueuedWebMouseWheelEvent : public MouseWheelEventWithLatencyInfo {
  public:
@@ skipping 57 matching lines @@
     return;
 
   event_sent_for_gesture_ack_->latency.AddNewLatencyFrom(latency_info);
   client_->OnMouseWheelEventAck(*event_sent_for_gesture_ack_, ack_result);
 
   // If event wasn't consumed then generate a gesture scroll for it.
   if (send_gestures_ && ack_result != INPUT_EVENT_ACK_STATE_CONSUMED &&
       event_sent_for_gesture_ack_->event.canScroll &&
       (scrolling_device_ == blink::WebGestureDeviceUninitialized ||
        scrolling_device_ == blink::WebGestureDeviceTouchpad)) {
-    GestureEventWithLatencyInfo scroll_update;
-    scroll_update.event.timeStampSeconds =
+    WebGestureEvent scroll_update;
+    scroll_update.timeStampSeconds =
         event_sent_for_gesture_ack_->event.timeStampSeconds;
 
-    scroll_update.event.x = event_sent_for_gesture_ack_->event.x;
-    scroll_update.event.y = event_sent_for_gesture_ack_->event.y;
-    scroll_update.event.globalX = event_sent_for_gesture_ack_->event.globalX;
-    scroll_update.event.globalY = event_sent_for_gesture_ack_->event.globalY;
-    scroll_update.event.type = WebInputEvent::GestureScrollUpdate;
-    scroll_update.event.sourceDevice = blink::WebGestureDeviceTouchpad;
-    scroll_update.event.resendingPluginId = -1;
-    scroll_update.event.data.scrollUpdate.deltaX =
+    scroll_update.x = event_sent_for_gesture_ack_->event.x;
+    scroll_update.y = event_sent_for_gesture_ack_->event.y;
+    scroll_update.globalX = event_sent_for_gesture_ack_->event.globalX;
+    scroll_update.globalY = event_sent_for_gesture_ack_->event.globalY;
+    scroll_update.type = WebInputEvent::GestureScrollUpdate;
+    scroll_update.sourceDevice = blink::WebGestureDeviceTouchpad;
+    scroll_update.resendingPluginId = -1;
+    scroll_update.data.scrollUpdate.deltaX =
         event_sent_for_gesture_ack_->event.deltaX;
-    scroll_update.event.data.scrollUpdate.deltaY =
+    scroll_update.data.scrollUpdate.deltaY =
         event_sent_for_gesture_ack_->event.deltaY;
     // Only OSX populates the momentumPhase; so expect this to
     // always be PhaseNone on all other platforms.
-    scroll_update.event.data.scrollUpdate.inertial =
+    scroll_update.data.scrollUpdate.inertial =
         event_sent_for_gesture_ack_->event.momentumPhase !=
         blink::WebMouseWheelEvent::PhaseNone;
     if (event_sent_for_gesture_ack_->event.scrollByPage) {
-      scroll_update.event.data.scrollUpdate.deltaUnits =
-          blink::WebGestureEvent::Page;
+      scroll_update.data.scrollUpdate.deltaUnits = WebGestureEvent::Page;
 
       // Turn page scrolls into a *single* page scroll because
       // the magnitude the number of ticks is lost when coalescing.
-      if (scroll_update.event.data.scrollUpdate.deltaX)
-        scroll_update.event.data.scrollUpdate.deltaX =
-            scroll_update.event.data.scrollUpdate.deltaX > 0 ? 1 : -1;
-      if (scroll_update.event.data.scrollUpdate.deltaY)
-        scroll_update.event.data.scrollUpdate.deltaY =
-            scroll_update.event.data.scrollUpdate.deltaY > 0 ? 1 : -1;
+      if (scroll_update.data.scrollUpdate.deltaX)
+        scroll_update.data.scrollUpdate.deltaX =
+            scroll_update.data.scrollUpdate.deltaX > 0 ? 1 : -1;
+      if (scroll_update.data.scrollUpdate.deltaY)
+        scroll_update.data.scrollUpdate.deltaY =
+            scroll_update.data.scrollUpdate.deltaY > 0 ? 1 : -1;
     } else {
-      scroll_update.event.data.scrollUpdate.deltaUnits =
+      scroll_update.data.scrollUpdate.deltaUnits =
           event_sent_for_gesture_ack_->event.hasPreciseScrollingDeltas
-              ? blink::WebGestureEvent::PrecisePixels
-              : blink::WebGestureEvent::Pixels;
+              ? WebGestureEvent::PrecisePixels
+              : WebGestureEvent::Pixels;
 
       if (event_sent_for_gesture_ack_->event.railsMode ==
           WebInputEvent::RailsModeVertical)
-        scroll_update.event.data.scrollUpdate.deltaX = 0;
+        scroll_update.data.scrollUpdate.deltaX = 0;
       if (event_sent_for_gesture_ack_->event.railsMode ==
           WebInputEvent::RailsModeHorizontal)
-        scroll_update.event.data.scrollUpdate.deltaY = 0;
+        scroll_update.data.scrollUpdate.deltaY = 0;
     }
 
     bool current_phase_ended = false;
     bool has_phase_info = false;
 
     if (event_sent_for_gesture_ack_->event.phase !=
             blink::WebMouseWheelEvent::PhaseNone ||
         event_sent_for_gesture_ack_->event.momentumPhase !=
             blink::WebMouseWheelEvent::PhaseNone) {
       has_phase_info = true;
       current_phase_ended = event_sent_for_gesture_ack_->event.phase ==
                                 blink::WebMouseWheelEvent::PhaseEnded ||
                             event_sent_for_gesture_ack_->event.phase ==
                                 blink::WebMouseWheelEvent::PhaseCancelled ||
                             event_sent_for_gesture_ack_->event.momentumPhase ==
                                 blink::WebMouseWheelEvent::PhaseEnded ||
                             event_sent_for_gesture_ack_->event.momentumPhase ==
                                 blink::WebMouseWheelEvent::PhaseCancelled;
     }
 
-    bool needs_update = scroll_update.event.data.scrollUpdate.deltaX != 0 ||
-                        scroll_update.event.data.scrollUpdate.deltaY != 0;
+    bool needs_update = scroll_update.data.scrollUpdate.deltaX != 0 ||
+                        scroll_update.data.scrollUpdate.deltaY != 0;
 
     // If there is no update to send and the current phase is ended yet a GSB
     // needs to be sent, this event sequence doesn't need to be generated
     // because the events generated will be a GSB (non-synthetic) and GSE
     // (non-synthetic). This situation arises when OSX generates double
     // phase end information.
     bool empty_sequence =
         !needs_update && needs_scroll_begin_ && current_phase_ended;
 
     if (needs_update || !empty_sequence) {
       if (needs_scroll_begin_) {
         // If no GSB has been sent, it will be a non-synthetic GSB.
         SendScrollBegin(scroll_update, false);
       } else if (has_phase_info) {
         // If a GSB has been sent, generate a synthetic GSB if we have phase
         // information. This should be removed once crbug.com/526463 is fully
         // implemented.
         SendScrollBegin(scroll_update, true);
       }
 
       if (needs_update)
-        client_->SendGestureEvent(scroll_update);
+        client_->ForwardGestureEvent(scroll_update);
 
       if (current_phase_ended) {
         // Non-synthetic GSEs are sent when the current phase is canceled or
         // ended.
-        SendScrollEnd(scroll_update.event, false);
+        SendScrollEnd(scroll_update, false);
       } else if (has_phase_info) {
         // Generate a synthetic GSE for every update to force hit testing so
         // that the non-latching behavior is preserved. Remove once
         // crbug.com/526463 is fully implemented.
-        SendScrollEnd(scroll_update.event, true);
+        SendScrollEnd(scroll_update, true);
       } else {
         scroll_end_timer_.Start(
             FROM_HERE,
             base::TimeDelta::FromMilliseconds(scroll_transaction_ms_),
             base::Bind(&MouseWheelEventQueue::SendScrollEnd,
-                       base::Unretained(this), scroll_update.event, false));
+                       base::Unretained(this), scroll_update, false));
       }
     }
   }
 
   event_sent_for_gesture_ack_.reset();
   TryForwardNextEventToRenderer();
 }
 
 void MouseWheelEventQueue::OnGestureScrollEvent(
     const GestureEventWithLatencyInfo& gesture_event) {
   if (gesture_event.event.type == blink::WebInputEvent::GestureScrollBegin) {
     // If there is a current scroll going on and a new scroll that isn't
     // wheel based cancel current one by sending a ScrollEnd.
     if (scroll_end_timer_.IsRunning() &&
         gesture_event.event.sourceDevice != blink::WebGestureDeviceTouchpad) {
       base::Closure task = scroll_end_timer_.user_task();
       scroll_end_timer_.Reset();
       task.Run();
     }
     scrolling_device_ = gesture_event.event.sourceDevice;
   } else if (scrolling_device_ == gesture_event.event.sourceDevice &&
              (gesture_event.event.type ==
                   blink::WebInputEvent::GestureScrollEnd ||
               gesture_event.event.type ==
                   blink::WebInputEvent::GestureFlingStart)) {
     scrolling_device_ = blink::WebGestureDeviceUninitialized;
+    if (scroll_end_timer_.IsRunning())
+      scroll_end_timer_.Reset();

[dtapuska, 2016/04/04 14:53:15]

Although this typically wouldn't get hit. The one unit test was generating a GFS
while a GSE was in the to be run state. That would generate a GSE after the GFS
would have been processed.

   }
 }
 
 void MouseWheelEventQueue::TryForwardNextEventToRenderer() {
   TRACE_EVENT0("input", "MouseWheelEventQueue::TryForwardNextEventToRenderer");
 
   if (wheel_queue_.empty() || event_sent_for_gesture_ack_)
     return;
 
   event_sent_for_gesture_ack_.reset(wheel_queue_.front());
   wheel_queue_.pop_front();
 
   client_->SendMouseWheelEventImmediately(*event_sent_for_gesture_ack_);
 }
 
-void MouseWheelEventQueue::SendScrollEnd(blink::WebGestureEvent update_event,
+void MouseWheelEventQueue::SendScrollEnd(WebGestureEvent update_event,
                                          bool synthetic) {
   DCHECK((synthetic && !needs_scroll_end_) || needs_scroll_end_);
 
-  GestureEventWithLatencyInfo scroll_end(update_event);
-  scroll_end.event.timeStampSeconds =
+  WebGestureEvent scroll_end(update_event);
+  scroll_end.timeStampSeconds =
       (base::TimeTicks::Now() - base::TimeTicks()).InSecondsF();
-  scroll_end.event.type = WebInputEvent::GestureScrollEnd;
-  scroll_end.event.resendingPluginId = -1;
-  scroll_end.event.data.scrollEnd.synthetic = synthetic;
-  scroll_end.event.data.scrollEnd.inertial =
-      update_event.data.scrollUpdate.inertial;
-  scroll_end.event.data.scrollEnd.deltaUnits =
+  scroll_end.type = WebInputEvent::GestureScrollEnd;
+  scroll_end.resendingPluginId = -1;
+  scroll_end.data.scrollEnd.synthetic = synthetic;
+  scroll_end.data.scrollEnd.inertial = update_event.data.scrollUpdate.inertial;
+  scroll_end.data.scrollEnd.deltaUnits =
       update_event.data.scrollUpdate.deltaUnits;
 
   if (!synthetic) {
     needs_scroll_begin_ = true;
     needs_scroll_end_ = false;
 
     if (scroll_end_timer_.IsRunning())
       scroll_end_timer_.Reset();
   }
-  client_->SendGestureEvent(scroll_end);
+  client_->ForwardGestureEvent(scroll_end);
 }
 
 void MouseWheelEventQueue::SendScrollBegin(
-    const GestureEventWithLatencyInfo& gesture_update,
+    const WebGestureEvent& gesture_update,
     bool synthetic) {
   DCHECK((synthetic && !needs_scroll_begin_) || needs_scroll_begin_);
 
-  GestureEventWithLatencyInfo scroll_begin(gesture_update);
-  scroll_begin.event.type = WebInputEvent::GestureScrollBegin;
-  scroll_begin.event.data.scrollBegin.synthetic = synthetic;
-  scroll_begin.event.data.scrollBegin.inertial =
-      gesture_update.event.data.scrollUpdate.inertial;
-  scroll_begin.event.data.scrollBegin.deltaXHint =
-      gesture_update.event.data.scrollUpdate.deltaX;
-  scroll_begin.event.data.scrollBegin.deltaYHint =
-      gesture_update.event.data.scrollUpdate.deltaY;
-  scroll_begin.event.data.scrollBegin.targetViewport = false;
-  scroll_begin.event.data.scrollBegin.deltaHintUnits =
-      gesture_update.event.data.scrollUpdate.deltaUnits;
+  WebGestureEvent scroll_begin(gesture_update);
+  scroll_begin.type = WebInputEvent::GestureScrollBegin;
+  scroll_begin.data.scrollBegin.synthetic = synthetic;
+  scroll_begin.data.scrollBegin.inertial =
+      gesture_update.data.scrollUpdate.inertial;
+  scroll_begin.data.scrollBegin.deltaXHint =
+      gesture_update.data.scrollUpdate.deltaX;
+  scroll_begin.data.scrollBegin.deltaYHint =
+      gesture_update.data.scrollUpdate.deltaY;
+  scroll_begin.data.scrollBegin.targetViewport = false;
+  scroll_begin.data.scrollBegin.deltaHintUnits =
+      gesture_update.data.scrollUpdate.deltaUnits;
 
   needs_scroll_begin_ = false;
   needs_scroll_end_ = true;
-  client_->SendGestureEvent(scroll_begin);
+  client_->ForwardGestureEvent(scroll_begin);
 }
 
 }  // namespace content