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

content/browser/renderer_host/input/gesture_event_queue.cc

 // Copyright 2014 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/gesture_event_queue.h"
 
 #include "base/trace_event/trace_event.h"
 #include "content/browser/renderer_host/input/touchpad_tap_suppression_controller.h"
 #include "content/browser/renderer_host/input/touchscreen_tap_suppression_controller.h"
 #include "ui/events/blink/web_input_event_traits.h"
 
 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() {
 }
 
 GestureEventQueue::GestureEventQueue(
     GestureEventQueueClient* client,
     TouchpadTapSuppressionControllerClient* touchpad_client,
     const Config& config)
     : client_(client),
       fling_in_progress_(false),
@@ skipping 258 matching lines @@
     if (coalesced_gesture_events_.size() == 1) {
       client_->SendGestureEventImmediately(gesture_event);
     } else if (coalesced_gesture_events_.size() == 2) {
       DCHECK(!ignore_next_ack_);
       // If there is an in-flight scroll, the new pinch can be forwarded
       // immediately, avoiding a potential frame delay between the two
       // (similarly for an in-flight pinch with a new scroll).
       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);
       }
     }
     return;
   }
 
   GestureEventWithLatencyInfo* last_event = &coalesced_gesture_events_.back();
   if (last_event->CanCoalesceWith(gesture_event)) {
     last_event->CoalesceWith(gesture_event);
     return;
   }
 
-  if (!IsCompatibleScrollorPinch(gesture_event, *last_event)) {
+  if (!ui::IsCompatibleScrollorPinch(gesture_event.event, last_event->event)) {
     coalesced_gesture_events_.push_back(gesture_event);
     return;
   }
 
+  GestureEventWithLatencyInfo* second_last_event = nullptr;
+  if (unsent_events_count > 1 &&
+      ui::IsCompatibleScrollorPinch(
+          gesture_event.event,
+          coalesced_gesture_events_[coalesced_gesture_events_.size() - 2]
+              .event)) {
+    second_last_event =
+        &coalesced_gesture_events_[coalesced_gesture_events_.size() - 2];
+  }
+
+  std::pair<blink::WebGestureEvent, blink::WebGestureEvent> coalesced_events =
+      ui::CoalesceScrollAndPinch(
+          second_last_event ? &second_last_event->event : nullptr,
+          last_event->event, gesture_event.event);
+
+  DCHECK_LE(last_event->latency.trace_id(), gesture_event.latency.trace_id());
+  if (second_last_event) {
+    DCHECK_LE(second_last_event->latency.trace_id(),
+              last_event->latency.trace_id());
+  }
+  ui::LatencyInfo oldest_latency =
+      second_last_event ? second_last_event->latency : last_event->latency;
+  oldest_latency.set_coalesced();
+
   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;
+  pinch_event.event = coalesced_events.second;
+  pinch_event.latency = oldest_latency;
 
-  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));
+  // Pop |last_event| and |second_last_event| first.
   coalesced_gesture_events_.pop_back();
-
-  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;
+  if (second_last_event)
+    coalesced_gesture_events_.pop_back();
   coalesced_gesture_events_.push_back(scroll_event);
-  pinch_event.event.data.pinchUpdate.scale = combined_scale;
   coalesced_gesture_events_.push_back(pinch_event);
 }
 
 size_t GestureEventQueue::EventsInFlightCount() const {
   if (coalesced_gesture_events_.empty())
     return 0;
 
   if (!ignore_next_ack_)
     return 1;
 
   DCHECK_GT(coalesced_gesture_events_.size(), 1U);
   return 2;
 }
 
 }  // namespace content