Implement compositor thread VSync aligned event queue

ui/events/blink/input_handler_proxy.cc

 // Copyright 2013 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/input_handler_proxy.h"
 
 #include <stddef.h>
 
 #include <algorithm>
 
 #include "base/auto_reset.h"
 #include "base/command_line.h"
 #include "base/location.h"
 #include "base/logging.h"
+#include "base/memory/ptr_util.h"
 #include "base/metrics/histogram_macros.h"
 #include "base/single_thread_task_runner.h"
 #include "base/threading/thread_task_runner_handle.h"
+#include "base/time/default_tick_clock.h"
 #include "base/trace_event/trace_event.h"
 #include "cc/input/main_thread_scrolling_reason.h"
 #include "third_party/WebKit/public/platform/WebInputEvent.h"
+#include "ui/events/blink/blink_event_util.h"
+#include "ui/events/blink/compositor_thread_event_queue.h"
 #include "ui/events/blink/did_overscroll_params.h"
+#include "ui/events/blink/event_with_callback.h"
 #include "ui/events/blink/input_handler_proxy_client.h"
 #include "ui/events/blink/input_scroll_elasticity_controller.h"
 #include "ui/events/blink/web_input_event_traits.h"
 #include "ui/events/latency_info.h"
 #include "ui/gfx/geometry/point_conversions.h"
 
 using blink::WebFloatPoint;
 using blink::WebFloatSize;
 using blink::WebGestureEvent;
 using blink::WebInputEvent;
@@ skipping 23 matching lines @@
 // Minimum velocity for the active touch scroll to preserve (boost) an active
 // fling for which cancellation has been deferred.
 const double kMinBoostTouchScrollSpeedSquare = 150 * 150.;
 
 // Timeout window after which the active fling will be cancelled if no animation
 // ticks, scrolls or flings of sufficient velocity relative to the current fling
 // are received. The default value on Android native views is 40ms, but we use a
 // slightly increased value to accomodate small IPC message delays.
 const double kFlingBoostTimeoutDelaySeconds = 0.05;
 
+const size_t kTenSeconds = 10 * 1000 * 1000;
+
 gfx::Vector2dF ToClientScrollIncrement(const WebFloatSize& increment) {
   return gfx::Vector2dF(-increment.width, -increment.height);
 }
 
 double InSecondsF(const base::TimeTicks& time) {
   return (time - base::TimeTicks()).InSecondsF();
 }
 
 bool ShouldSuppressScrollForFlingBoosting(
     const gfx::Vector2dF& current_fling_velocity,
@@ skipping 160 matching lines @@
 #endif
       gesture_scroll_on_impl_thread_(false),
       gesture_pinch_on_impl_thread_(false),
       fling_may_be_active_on_main_thread_(false),
       disallow_horizontal_fling_scroll_(false),
       disallow_vertical_fling_scroll_(false),
       has_fling_animation_started_(false),
       smooth_scroll_enabled_(false),
       uma_latency_reporting_enabled_(base::TimeTicks::IsHighResolution()),
       touch_start_result_(kEventDispositionUndefined),
-      current_overscroll_params_(nullptr) {
+      current_overscroll_params_(nullptr),
+      has_ongoing_compositor_scroll_pinch_(false),
+      tick_clock_(base::MakeUnique<base::DefaultTickClock>()) {
   DCHECK(client);
   input_handler_->BindToClient(this);
   cc::ScrollElasticityHelper* scroll_elasticity_helper =
       input_handler_->CreateScrollElasticityHelper();
   if (scroll_elasticity_helper) {
     scroll_elasticity_controller_.reset(
         new InputScrollElasticityController(scroll_elasticity_helper));
   }
+  compositor_event_queue_ =
+      base::FeatureList::IsEnabled(features::kVsyncAlignedInputEvents)
+          ? base::MakeUnique<CompositorThreadEventQueue>()
+          : nullptr;
 }
 
 InputHandlerProxy::~InputHandlerProxy() {}
 
 void InputHandlerProxy::WillShutdown() {
   scroll_elasticity_controller_.reset();
   input_handler_ = NULL;
   client_->WillShutdown();
 }
 
 void InputHandlerProxy::HandleInputEventWithLatencyInfo(
     ScopedWebInputEvent event,
     const LatencyInfo& latency_info,
     const EventDispositionCallback& callback) {
   DCHECK(input_handler_);
 
   if (uma_latency_reporting_enabled_)
     ReportInputEventLatencyUma(*event, latency_info);
 
   TRACE_EVENT_WITH_FLOW1("input,benchmark", "LatencyInfo.Flow",
                          TRACE_ID_DONT_MANGLE(latency_info.trace_id()),
                          TRACE_EVENT_FLAG_FLOW_IN | TRACE_EVENT_FLAG_FLOW_OUT,
                          "step", "HandleInputEventImpl");
 
-  ui::LatencyInfo monitored_latency_info = latency_info;
+  std::unique_ptr<EventWithCallback> event_with_callback =
+      base::MakeUnique<EventWithCallback>(std::move(event), latency_info,
+                                          tick_clock_->NowTicks(), callback);
+
+  // Note: Other input can race ahead of gesture input as they don't have to go
+  // through the queue, but we believe it's OK to do so.
+  if (!compositor_event_queue_ ||
+      !IsGestureScollOrPinch(event_with_callback->event().type)) {
+    DispatchSingleInputEvent(std::move(event_with_callback),
+                             tick_clock_->NowTicks());
+    return;
+  }
+
+  if (has_ongoing_compositor_scroll_pinch_) {
+    bool needs_animate_input = compositor_event_queue_->empty();
+    compositor_event_queue_->Queue(std::move(event_with_callback),
+                                   tick_clock_->NowTicks());
+    if (needs_animate_input)
+      input_handler_->SetNeedsAnimateInput();
+    return;
+  }
+
+  // We have to dispatch the event to know whether the gesture sequence will be
+  // handled by the compositor or not.
+  DispatchSingleInputEvent(std::move(event_with_callback),
+                           tick_clock_->NowTicks());
+}
+
+void InputHandlerProxy::DispatchSingleInputEvent(
+    std::unique_ptr<EventWithCallback> event_with_callback,
+    const base::TimeTicks now) {
+  if (compositor_event_queue_ &&
+      IsGestureScollOrPinch(event_with_callback->event().type)) {
+    // Report the coalesced count only for continuous events to avoid the noise
+    // from non-continuous events.
+    if (IsContinuousGestureEvent(event_with_callback->event().type)) {
+      UMA_HISTOGRAM_CUSTOM_COUNTS(
+          "Event.CompositorThreadEventQueue.Continuous.HeadQueueingTime",
+          (now - event_with_callback->creation_timestamp()).InMicroseconds(), 1,
+          kTenSeconds, 50);
+
+      UMA_HISTOGRAM_CUSTOM_COUNTS(
+          "Event.CompositorThreadEventQueue.Continuous.TailQueueingTime",
+          (now - event_with_callback->last_coalesced_timestamp())
+              .InMicroseconds(),
+          1, kTenSeconds, 50);
+
+      UMA_HISTOGRAM_COUNTS_1000(
+          "Event.CompositorThreadEventQueue.CoalescedCount",
+          static_cast<int>(event_with_callback->coalesced_count()));
+    } else {
+      UMA_HISTOGRAM_CUSTOM_COUNTS(
+          "Event.CompositorThreadEventQueue.NonContinuous.QueueingTime",
+          (now - event_with_callback->creation_timestamp()).InMicroseconds(), 1,
+          kTenSeconds, 50);
+    }
+  }
+
+  ui::LatencyInfo monitored_latency_info = event_with_callback->latency_info();
   std::unique_ptr<cc::SwapPromiseMonitor> latency_info_swap_promise_monitor =
       input_handler_->CreateLatencyInfoSwapPromiseMonitor(
           &monitored_latency_info);
 
   current_overscroll_params_.reset();
-  InputHandlerProxy::EventDisposition disposition = HandleInputEvent(*event);
-  callback.Run(disposition, std::move(event), monitored_latency_info,
-               std::move(current_overscroll_params_));
+  InputHandlerProxy::EventDisposition disposition =
+      HandleInputEvent(event_with_callback->event());
+
+  switch (event_with_callback->event().type) {
+    case blink::WebGestureEvent::GestureScrollBegin:
+    case blink::WebGestureEvent::GesturePinchBegin:
+    case blink::WebGestureEvent::GestureScrollUpdate:
+    case blink::WebGestureEvent::GesturePinchUpdate:
+      has_ongoing_compositor_scroll_pinch_ = disposition == DID_HANDLE;
+      break;
+
+    case blink::WebGestureEvent::GestureScrollEnd:
+    case blink::WebGestureEvent::GesturePinchEnd:
+      has_ongoing_compositor_scroll_pinch_ = false;
+      break;
+    default:
+      break;
+  }
+
+  // Will run callback for every original events.
+  event_with_callback->RunCallbacks(disposition, monitored_latency_info,
+                                    std::move(current_overscroll_params_));
+}
+
+void InputHandlerProxy::DispatchQueuedInputEvents() {
+  if (!compositor_event_queue_)
+    return;
+
+  // Calling |NowTicks()| is expensive so we only want to do it once.
+  base::TimeTicks now = tick_clock_->NowTicks();
+  while (!compositor_event_queue_->empty())
+    DispatchSingleInputEvent(compositor_event_queue_->Pop(), now);
 }
 
 InputHandlerProxy::EventDisposition InputHandlerProxy::HandleInputEvent(
     const WebInputEvent& event) {
   DCHECK(input_handler_);
 
   if (FilterInputEventForFlingBoosting(event))
     return DID_HANDLE;
 
   switch (event.type) {
@@ skipping 834 matching lines @@
     float page_scale_factor,
     float min_page_scale_factor,
     float max_page_scale_factor) {
   if (synchronous_input_handler_) {
     synchronous_input_handler_->UpdateRootLayerState(
         total_scroll_offset, max_scroll_offset, scrollable_size,
         page_scale_factor, min_page_scale_factor, max_page_scale_factor);
   }
 }
 
+void InputHandlerProxy::DeliverInputForBeginFrame() {
+  DispatchQueuedInputEvents();
+}
+
 void InputHandlerProxy::SetOnlySynchronouslyAnimateRootFlings(
     SynchronousInputHandler* synchronous_input_handler) {
   allow_root_animate_ = !synchronous_input_handler;
   synchronous_input_handler_ = synchronous_input_handler;
   if (synchronous_input_handler_)
     input_handler_->RequestUpdateForSynchronousInputHandler();
 }
 
 void InputHandlerProxy::SynchronouslyAnimate(base::TimeTicks time) {
   // When this function is used, SetOnlySynchronouslyAnimate() should have been
@@ skipping 264 matching lines @@
   // the over-scroll animation. Note that the call to the elasticity controller
   // is made asynchronously, to minimize divergence between main thread and
   // impl thread event handling paths.
   base::ThreadTaskRunnerHandle::Get()->PostTask(
       FROM_HERE,
       base::Bind(&InputScrollElasticityController::ObserveGestureEventAndResult,
                  scroll_elasticity_controller_->GetWeakPtr(), gesture_event,
                  scroll_result));
 }
 
+void InputHandlerProxy::SetTickClockForTesting(
+    std::unique_ptr<base::TickClock> tick_clock) {
+  tick_clock_ = std::move(tick_clock);
+}
+
 }  // namespace ui