[Compositor event queue] Coalesce gesture scroll&pinch of the same sequence

content/browser/renderer_host/input/gesture_event_queue.cc

Index: content/browser/renderer_host/input/gesture_event_queue.cc
diff --git a/content/browser/renderer_host/input/gesture_event_queue.cc b/content/browser/renderer_host/input/gesture_event_queue.cc
index a0a80e382ce04fa2dd27c4e8f0213f6f0fecaa16..d50bbed25d255424d66d9c88b3e05920e910fb65 100644
--- a/content/browser/renderer_host/input/gesture_event_queue.cc
+++ b/content/browser/renderer_host/input/gesture_event_queue.cc
@@ -13,47 +13,6 @@ using blink::WebGestureEvent;
 using blink::WebInputEvent;
 
 namespace content {
-namespace {
-
-// Whether |event_in_queue| is GesturePinchUpdate or GestureScrollUpdate and
-// has the same modifiers/source as the new scroll/pinch event. Compatible
-// scroll and pinch event pairs can be logically coalesced.
-bool IsCompatibleScrollorPinch(
-    const GestureEventWithLatencyInfo& new_event,
-    const GestureEventWithLatencyInfo& event_in_queue) {
-  DCHECK(new_event.event.type == WebInputEvent::GestureScrollUpdate ||
-         new_event.event.type == WebInputEvent::GesturePinchUpdate)
-      << "Invalid event type for pinch/scroll coalescing: "
-      << WebInputEvent::GetName(new_event.event.type);
-  DLOG_IF(WARNING, new_event.event.timeStampSeconds <
-                       event_in_queue.event.timeStampSeconds)
-      << "Event time not monotonic?\n";
-  return (event_in_queue.event.type == WebInputEvent::GestureScrollUpdate ||
-          event_in_queue.event.type == WebInputEvent::GesturePinchUpdate) &&
-         event_in_queue.event.modifiers == new_event.event.modifiers &&
-         event_in_queue.event.sourceDevice == new_event.event.sourceDevice;
-}
-
-// Returns the transform matrix corresponding to the gesture event.
-gfx::Transform GetTransformForEvent(
-    const GestureEventWithLatencyInfo& gesture_event) {
-  gfx::Transform gesture_transform;
-  if (gesture_event.event.type == WebInputEvent::GestureScrollUpdate) {
-    gesture_transform.Translate(gesture_event.event.data.scrollUpdate.deltaX,
-                                gesture_event.event.data.scrollUpdate.deltaY);
-  } else if (gesture_event.event.type == WebInputEvent::GesturePinchUpdate) {
-    float scale = gesture_event.event.data.pinchUpdate.scale;
-    gesture_transform.Translate(-gesture_event.event.x, -gesture_event.event.y);
-    gesture_transform.Scale(scale, scale);
-    gesture_transform.Translate(gesture_event.event.x, gesture_event.event.y);
-  } else {
-    NOTREACHED() << "Invalid event type for transform retrieval: "
-                 << WebInputEvent::GetName(gesture_event.event.type);
-  }
-  return gesture_transform;
-}
-
-}  // namespace
 
 GestureEventQueue::Config::Config() {
 }
@@ -332,7 +291,8 @@ void GestureEventQueue::QueueScrollOrPinchAndForwardIfNecessary(
       const GestureEventWithLatencyInfo& first_event =
           coalesced_gesture_events_.front();
       if (gesture_event.event.type != first_event.event.type &&
-          IsCompatibleScrollorPinch(gesture_event, first_event)) {
+          ui::IsCompatibleScrollorPinch(gesture_event.event,
+                                        first_event.event)) {
         ignore_next_ack_ = true;
         client_->SendGestureEventImmediately(gesture_event);
       }
@@ -346,63 +306,50 @@ void GestureEventQueue::QueueScrollOrPinchAndForwardIfNecessary(
     return;
   }
 
-  if (!IsCompatibleScrollorPinch(gesture_event, *last_event)) {
+  if (!ui::IsCompatibleScrollorPinch(gesture_event.event, last_event->event)) {
     coalesced_gesture_events_.push_back(gesture_event);
     return;
   }
 
+  // Extract the last event in queue.
+  blink::WebGestureEvent last_gesture_event =
+      coalesced_gesture_events_.back().event;
+  DCHECK_LE(coalesced_gesture_events_.back().latency.trace_id(),
+            gesture_event.latency.trace_id());
+  ui::LatencyInfo oldest_latency = coalesced_gesture_events_.back().latency;
+  oldest_latency.set_coalesced();
+  coalesced_gesture_events_.pop_back();
+
+  // Extract the second last event in queue.
+  ui::ScopedWebInputEvent second_last_gesture_event = nullptr;
+  if (unsent_events_count > 1 &&
+      ui::IsCompatibleScrollorPinch(gesture_event.event,
+                                    coalesced_gesture_events_.back().event)) {
+    second_last_gesture_event =
+        ui::WebInputEventTraits::Clone(coalesced_gesture_events_.back().event);
+    DCHECK_LE(coalesced_gesture_events_.back().latency.trace_id(),
+              oldest_latency.trace_id());
+    oldest_latency = coalesced_gesture_events_.back().latency;
+    oldest_latency.set_coalesced();
+    coalesced_gesture_events_.pop_back();
+  }
+
+  std::pair<blink::WebGestureEvent, blink::WebGestureEvent> coalesced_events =
+      ui::CoalesceScrollAndPinch(
+          second_last_gesture_event
+              ? &ui::ToWebGestureEvent(*second_last_gesture_event)
+              : nullptr,
+          last_gesture_event, gesture_event.event);
+
   GestureEventWithLatencyInfo scroll_event;
+  scroll_event.event = coalesced_events.first;
+  scroll_event.latency = oldest_latency;
+
   GestureEventWithLatencyInfo pinch_event;
-  scroll_event.event.modifiers |= gesture_event.event.modifiers;
-  scroll_event.event.sourceDevice = gesture_event.event.sourceDevice;
-  scroll_event.event.timeStampSeconds = gesture_event.event.timeStampSeconds;
-  // Keep the oldest LatencyInfo.
-  DCHECK_LE(last_event->latency.trace_id(), gesture_event.latency.trace_id());
-  scroll_event.latency = last_event->latency;
-  pinch_event = scroll_event;
-  scroll_event.event.type = WebInputEvent::GestureScrollUpdate;
-  pinch_event.event.type = WebInputEvent::GesturePinchUpdate;
-  pinch_event.event.x = gesture_event.event.type ==
-      WebInputEvent::GesturePinchUpdate ?
-          gesture_event.event.x : last_event->event.x;
-  pinch_event.event.y = gesture_event.event.type ==
-      WebInputEvent::GesturePinchUpdate ?
-          gesture_event.event.y : last_event->event.y;
-
-  gfx::Transform combined_scroll_pinch = GetTransformForEvent(*last_event);
-  // Only include the second-to-last event in the coalesced pair if it exists
-  // and can be combined with the new event.
-  if (unsent_events_count > 1) {
-    const GestureEventWithLatencyInfo& second_last_event =
-        coalesced_gesture_events_[coalesced_gesture_events_.size() - 2];
-    if (IsCompatibleScrollorPinch(gesture_event, second_last_event)) {
-      // Keep the oldest LatencyInfo.
-      DCHECK_LE(second_last_event.latency.trace_id(),
-                scroll_event.latency.trace_id());
-      scroll_event.latency = second_last_event.latency;
-      pinch_event.latency = second_last_event.latency;
-      combined_scroll_pinch.PreconcatTransform(
-          GetTransformForEvent(second_last_event));
-      coalesced_gesture_events_.pop_back();
-    }
-  }
-  combined_scroll_pinch.ConcatTransform(GetTransformForEvent(gesture_event));
-  coalesced_gesture_events_.pop_back();
+  pinch_event.event = coalesced_events.second;
+  pinch_event.latency = oldest_latency;
 
-  float combined_scale =
-      SkMScalarToFloat(combined_scroll_pinch.matrix().get(0, 0));
-  float combined_scroll_pinch_x =
-      SkMScalarToFloat(combined_scroll_pinch.matrix().get(0, 3));
-  float combined_scroll_pinch_y =
-      SkMScalarToFloat(combined_scroll_pinch.matrix().get(1, 3));
-  scroll_event.event.data.scrollUpdate.deltaX =
-      (combined_scroll_pinch_x + pinch_event.event.x) / combined_scale -
-      pinch_event.event.x;
-  scroll_event.event.data.scrollUpdate.deltaY =
-      (combined_scroll_pinch_y + pinch_event.event.y) / combined_scale -
-      pinch_event.event.y;
   coalesced_gesture_events_.push_back(scroll_event);
-  pinch_event.event.data.pinchUpdate.scale = combined_scale;
   coalesced_gesture_events_.push_back(pinch_event);
 }