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

ui/events/blink/compositor_thread_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 "ui/events/blink/compositor_thread_event_queue.h"
 
+#include "base/memory/ptr_util.h"
+#include "ui/events/blink/blink_event_util.h"
+#include "ui/events/blink/web_input_event_traits.h"
+
 namespace ui {
 
 CompositorThreadEventQueue::CompositorThreadEventQueue() {}
 
 CompositorThreadEventQueue::~CompositorThreadEventQueue() {}
 
-// TODO(chongz): Support coalescing events across interleaved boundaries.
-// https://crbug.com/661601
-void CompositorThreadEventQueue::Queue(std::unique_ptr<EventWithCallback> event,
-                                       base::TimeTicks timestamp_now) {
-  if (!queue_.empty() && queue_.back()->CanCoalesceWith(*event)) {
-    queue_.back()->CoalesceWith(event.get(), timestamp_now);
+void CompositorThreadEventQueue::Queue(
+    std::unique_ptr<EventWithCallback> new_event,
+    base::TimeTicks timestamp_now) {
+  if (queue_.empty() || !IsContinuousGestureEvent(new_event->event().type) ||
+      !IsCompatibleScrollorPinch(new_event->ToWebGestureEvent(),
+                                 queue_.back()->ToWebGestureEvent())) {
+    queue_.emplace_back(std::move(new_event));
     return;
   }
 
-  queue_.emplace_back(std::move(event));
+  if (queue_.back()->CanCoalesceWith(*new_event)) {
+    queue_.back()->CoalesceWith(new_event.get(), timestamp_now);
+    return;
+  }
+
+  // Coalesce |GestureScrollUpdate| and |GesturePinchUpdate| in one sequence.
+  EventWithCallback* last_event = queue_.back().get();
+  EventWithCallback* second_last_event = nullptr;
+  if (queue_.size() > 1 &&
+      IsCompatibleScrollorPinch(
+          new_event->ToWebGestureEvent(),
+          queue_[queue_.size() - 2]->ToWebGestureEvent())) {
+    second_last_event = queue_[queue_.size() - 2].get();
+  }
+
+  std::pair<blink::WebGestureEvent, blink::WebGestureEvent> coalesced_events =

[dtapuska, 2016/12/08 15:18:37]

Isn't this complicated logic if second_last_event is null?

Have we thought about always ensuring GSU's always come before GPU's and then
could we just do this coalescing in place?

[chongz, 2016/12/09 20:52:25]

As discussed we have to go through the matrix as 2 pinch events with different
pinch point could also coalesce to 1 scroll event and 1 pinch event.

I've moved the logic of calculating other attributes and call pop_back() earlier
as per our discussion.

+      CoalesceScrollAndPinch(
+          second_last_event ? &second_last_event->ToWebGestureEvent() : nullptr,
+          last_event->ToWebGestureEvent(), new_event->ToWebGestureEvent());
+
+  DCHECK_LE(last_event->latency_info().trace_id(),
+            new_event->latency_info().trace_id());
+  if (second_last_event) {
+    DCHECK_LE(second_last_event->latency_info().trace_id(),
+              last_event->latency_info().trace_id());
+  }
+  LatencyInfo oldest_latency = second_last_event
+                                   ? second_last_event->latency_info()
+                                   : last_event->latency_info();
+  oldest_latency.set_coalesced();
+  const base::TimeTicks oldest_creation_timestamp =
+      second_last_event ? second_last_event->creation_timestamp()
+                        : last_event->creation_timestamp();
+
+  // Creating 2 events, but store original events in the last one.
+  auto combined_original_events =
+      base::MakeUnique<EventWithCallback::OriginalEventList>();
+  if (second_last_event) {
+    combined_original_events->splice(combined_original_events->end(),
+                                     second_last_event->original_events());
+  }
+  combined_original_events->splice(combined_original_events->end(),
+                                   last_event->original_events());
+  combined_original_events->splice(combined_original_events->end(),
+                                   new_event->original_events());
+
+  std::unique_ptr<EventWithCallback> scroll_event =
+      base::MakeUnique<EventWithCallback>(
+          WebInputEventTraits::Clone(coalesced_events.first), oldest_latency,
+          oldest_creation_timestamp, timestamp_now, nullptr);
+
+  std::unique_ptr<EventWithCallback> pinch_event =
+      base::MakeUnique<EventWithCallback>(
+          WebInputEventTraits::Clone(coalesced_events.second), oldest_latency,
+          oldest_creation_timestamp, timestamp_now,
+          std::move(combined_original_events));
+
+  // Pop |last_event| and |second_last_event| first.
+  queue_.pop_back();
+  if (second_last_event)
+    queue_.pop_back();
+  queue_.emplace_back(std::move(scroll_event));
+  queue_.emplace_back(std::move(pinch_event));
 }
 
 std::unique_ptr<EventWithCallback> CompositorThreadEventQueue::Pop() {
   std::unique_ptr<EventWithCallback> result;
   if (!queue_.empty()) {
     result.reset(queue_.front().release());
     queue_.pop_front();
   }
   return result;
 }
 
 }  // namespace ui