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

ui/events/blink/blink_event_util.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.
 
 // MSVC++ requires this to be set before any other includes to get M_PI.
 #define _USE_MATH_DEFINES
 
 #include "ui/events/blink/blink_event_util.h"
 
 #include <stddef.h>
 
 #include <algorithm>
 #include <bitset>
 #include <cmath>
 #include <limits>
 
 #include "base/time/time.h"
 #include "build/build_config.h"
 #include "third_party/WebKit/public/platform/WebGestureEvent.h"
 #include "third_party/WebKit/public/platform/WebInputEvent.h"
 #include "ui/events/base_event_utils.h"
 #include "ui/events/event_constants.h"
 #include "ui/events/gesture_detection/gesture_event_data.h"
 #include "ui/events/gesture_detection/motion_event.h"
 #include "ui/events/gesture_event_details.h"
 #include "ui/events/keycodes/dom/keycode_converter.h"
 #include "ui/gfx/geometry/safe_integer_conversions.h"
 #include "ui/gfx/geometry/vector2d.h"
+#include "ui/gfx/transform.h"
 
 using blink::WebGestureEvent;
 using blink::WebInputEvent;
 using blink::WebMouseEvent;
 using blink::WebMouseWheelEvent;
 using blink::WebPointerProperties;
 using blink::WebTouchEvent;
 using blink::WebTouchPoint;
 using std::numeric_limits;
 
@@ skipping 335 matching lines @@
     event->data.pinchUpdate.scale *= event_to_coalesce.data.pinchUpdate.scale;
     // Ensure the scale remains bounded above 0 and below Infinity so that
     // we can reliably perform operations like log on the values.
     if (event->data.pinchUpdate.scale < numeric_limits<float>::min())
       event->data.pinchUpdate.scale = numeric_limits<float>::min();
     else if (event->data.pinchUpdate.scale > numeric_limits<float>::max())
       event->data.pinchUpdate.scale = numeric_limits<float>::max();
   }
 }
 
+// Returns the transform matrix corresponding to the gesture event.
+gfx::Transform GetTransformForEvent(const WebGestureEvent& gesture_event) {
+  gfx::Transform gesture_transform;
+  if (gesture_event.type == WebInputEvent::GestureScrollUpdate) {
+    gesture_transform.Translate(gesture_event.data.scrollUpdate.deltaX,
+                                gesture_event.data.scrollUpdate.deltaY);
+  } else if (gesture_event.type == WebInputEvent::GesturePinchUpdate) {
+    float scale = gesture_event.data.pinchUpdate.scale;
+    gesture_transform.Translate(-gesture_event.x, -gesture_event.y);
+    gesture_transform.Scale(scale, scale);
+    gesture_transform.Translate(gesture_event.x, gesture_event.y);
+  } else {
+    NOTREACHED() << "Invalid event type for transform retrieval: "
+                 << WebInputEvent::GetName(gesture_event.type);
+  }
+  return gesture_transform;
+}
+
 }  // namespace
 
 bool CanCoalesce(const blink::WebInputEvent& event_to_coalesce,
                  const blink::WebInputEvent& event) {
   if (blink::WebInputEvent::isGestureEventType(event_to_coalesce.type) &&
       blink::WebInputEvent::isGestureEventType(event.type)) {
     return CanCoalesce(
         static_cast<const blink::WebGestureEvent&>(event_to_coalesce),
         static_cast<const blink::WebGestureEvent&>(event));
   }
@@ skipping 38 matching lines @@
              static_cast<blink::WebTouchEvent*>(event));
     return;
   }
   if (event_to_coalesce.type == blink::WebInputEvent::MouseWheel &&
       event->type == blink::WebInputEvent::MouseWheel) {
     Coalesce(static_cast<const blink::WebMouseWheelEvent&>(event_to_coalesce),
              static_cast<blink::WebMouseWheelEvent*>(event));
   }
 }
 
+// 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 WebGestureEvent& new_event,
+                               const WebGestureEvent& event_in_queue) {
+  DCHECK(new_event.type == WebInputEvent::GestureScrollUpdate ||
+         new_event.type == WebInputEvent::GesturePinchUpdate)
+      << "Invalid event type for pinch/scroll coalescing: "
+      << WebInputEvent::GetName(new_event.type);
+  DLOG_IF(WARNING, new_event.timeStampSeconds < event_in_queue.timeStampSeconds)
+      << "Event time not monotonic?\n";
+  return (event_in_queue.type == WebInputEvent::GestureScrollUpdate ||
+          event_in_queue.type == WebInputEvent::GesturePinchUpdate) &&
+         event_in_queue.modifiers == new_event.modifiers &&
+         event_in_queue.sourceDevice == new_event.sourceDevice;
+}
+
+std::pair<WebGestureEvent, WebGestureEvent> CoalesceScrollAndPinch(
+    const WebGestureEvent* second_last_event,
+    const WebGestureEvent& last_event,
+    const WebGestureEvent& new_event) {
+  DCHECK(!CanCoalesce(new_event, last_event))
+      << "New event can be coalesced with the last event in queue directly.";
+  DCHECK(IsContinuousGestureEvent(new_event.type));
+  DCHECK(IsCompatibleScrollorPinch(new_event, last_event));
+  DCHECK(!second_last_event ||
+         IsCompatibleScrollorPinch(new_event, *second_last_event));
+
+  WebGestureEvent scroll_event;
+  WebGestureEvent pinch_event;
+  scroll_event.modifiers |= new_event.modifiers;
+  scroll_event.sourceDevice = new_event.sourceDevice;
+  scroll_event.timeStampSeconds = new_event.timeStampSeconds;
+  pinch_event = scroll_event;
+  scroll_event.type = WebInputEvent::GestureScrollUpdate;
+  pinch_event.type = WebInputEvent::GesturePinchUpdate;
+  pinch_event.x = new_event.type == WebInputEvent::GesturePinchUpdate
+                      ? new_event.x
+                      : last_event.x;
+  pinch_event.y = new_event.type == WebInputEvent::GesturePinchUpdate
+                      ? new_event.y
+                      : last_event.y;
+
+  gfx::Transform combined_scroll_pinch = GetTransformForEvent(last_event);
+  if (second_last_event) {
+    combined_scroll_pinch.PreconcatTransform(
+        GetTransformForEvent(*second_last_event));
+  }
+  combined_scroll_pinch.ConcatTransform(GetTransformForEvent(new_event));
+
+  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.data.scrollUpdate.deltaX =
+      (combined_scroll_pinch_x + pinch_event.x) / combined_scale -
+      pinch_event.x;
+  scroll_event.data.scrollUpdate.deltaY =
+      (combined_scroll_pinch_y + pinch_event.y) / combined_scale -
+      pinch_event.y;
+  pinch_event.data.pinchUpdate.scale = combined_scale;
+
+  return std::make_pair(scroll_event, pinch_event);
+}
+
 blink::WebTouchEvent CreateWebTouchEventFromMotionEvent(
     const MotionEvent& event,
     bool moved_beyond_slop_region) {
   static_assert(static_cast<int>(MotionEvent::MAX_TOUCH_POINT_COUNT) ==
                     static_cast<int>(blink::WebTouchEvent::kTouchesLengthCap),
                 "inconsistent maximum number of active touch points");
 
   blink::WebTouchEvent result;
 
   result.type = ToWebTouchEventType(event.GetAction());
@@ skipping 423 matching lines @@
 bool IsContinuousGestureEvent(WebInputEvent::Type type) {
   switch (type) {
     case blink::WebGestureEvent::GestureScrollUpdate:
     case blink::WebGestureEvent::GesturePinchUpdate:
       return true;
     default:
       return false;
   }
 }
 
+const blink::WebGestureEvent* ToWebGestureEvent(
+    const blink::WebInputEvent* event) {
+  if (!event)
+    return nullptr;
+  DCHECK(IsGestureScollOrPinch(event->type));
+  return static_cast<const blink::WebGestureEvent*>(event);
+}
+
+const blink::WebGestureEvent& ToWebGestureEvent(
+    const blink::WebInputEvent& event) {
+  DCHECK(IsGestureScollOrPinch(event.type));
+  return static_cast<const blink::WebGestureEvent&>(event);
+}
+
 }  // namespace ui