Refactor compositor event handling path to be callback-based

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>
 
@@ skipping 43 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 bool kBundleAckWithTriggeringEvent = true;

[tdresser, 2016/09/01 16:58:45]

The point of this bool is just to make this easy to revert, right? It seems like
it's adding some complexity, and I'm not sure it's worth it.

[chongz, 2016/09/01 20:13:13]

Removed.

I was just trying to avoid passing raw 'true'/'false'. I thought I read it from
code style but I might be wrong.

[tdresser, 2016/09/01 21:08:10]

Yup, that is general good practice. I'd tend to do it by making the parameter a
two valued enum type though.

+
 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 165 matching lines @@
       expect_scroll_update_end_(false),
 #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) {
+      touch_start_result_(kEventDispositionUndefined),
+      current_overscroll_params_(nullptr) {
   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));
   }
 }
 
 InputHandlerProxy::~InputHandlerProxy() {}
 
 void InputHandlerProxy::WillShutdown() {
   scroll_elasticity_controller_.reset();
   input_handler_ = NULL;
   client_->WillShutdown();
 }
 
-InputHandlerProxy::EventDisposition
-InputHandlerProxy::HandleInputEventWithLatencyInfo(
-    const WebInputEvent& event,
-    ui::LatencyInfo* latency_info) {
+void InputHandlerProxy::HandleInputEventWithLatencyInfo(
+    ScopedWebInputEvent event,
+    const LatencyInfo& latency_info,
+    const EventDispositionCallback& callback) {
   DCHECK(input_handler_);
 
   if (uma_latency_reporting_enabled_)
-    ReportInputEventLatencyUma(event, *latency_info);
+    ReportInputEventLatencyUma(*event, latency_info);
 
-  TRACE_EVENT_WITH_FLOW1("input,benchmark",
-                         "LatencyInfo.Flow",
-                         TRACE_ID_DONT_MANGLE(latency_info->trace_id()),
+  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<cc::SwapPromiseMonitor> latency_info_swap_promise_monitor =
-      input_handler_->CreateLatencyInfoSwapPromiseMonitor(latency_info);
-  InputHandlerProxy::EventDisposition disposition = HandleInputEvent(event);
-  return disposition;
+      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 InputHandlerProxy::HandleInputEvent(
     const WebInputEvent& event) {
   DCHECK(input_handler_);
 
   if (FilterInputEventForFlingBoosting(event))
     return DID_HANDLE;
 
   switch (event.type) {
@@ skipping 222 matching lines @@
 
         cc::ScrollStateData scroll_state_update_data;
         scroll_state_update_data.delta_x = scroll_delta.x();
         scroll_state_update_data.delta_y = scroll_delta.y();
         scroll_state_update_data.position_x = wheel_event.x;
         scroll_state_update_data.position_y = wheel_event.y;
         cc::ScrollState scroll_state_update(scroll_state_update_data);
 
         scroll_result = input_handler_->ScrollBy(&scroll_state_update);
         HandleOverscroll(gfx::Point(wheel_event.x, wheel_event.y),
-                         scroll_result);
+                         scroll_result, !kBundleAckWithTriggeringEvent);
 
         cc::ScrollStateData scroll_state_end_data;
         scroll_state_end_data.is_ending = true;
         cc::ScrollState scroll_state_end(scroll_state_end_data);
         input_handler_->ScrollEnd(&scroll_state_end);
 
         result = scroll_result.did_scroll ? DID_HANDLE : DROP_EVENT;
         break;
       }
       case cc::InputHandler::SCROLL_IGNORED:
@@ skipping 91 matching lines @@
       case cc::InputHandler::SCROLL_ON_IMPL_THREAD:
         return DID_HANDLE;
       case cc::InputHandler::SCROLL_IGNORED:
         return DROP_EVENT;
       default:
         return DID_NOT_HANDLE;
     }
   }
   cc::InputHandlerScrollResult scroll_result =
       input_handler_->ScrollBy(&scroll_state);
-  HandleOverscroll(scroll_point, scroll_result);
+  HandleOverscroll(scroll_point, scroll_result, kBundleAckWithTriggeringEvent);
 
   if (scroll_elasticity_controller_)
     HandleScrollElasticityOverscroll(gesture_event, scroll_result);
 
   return scroll_result.did_scroll ? DID_HANDLE : DROP_EVENT;
 }
 
 InputHandlerProxy::EventDisposition InputHandlerProxy::HandleGestureScrollEnd(
   const WebGestureEvent& gesture_event) {
 #ifndef NDEBUG
@@ skipping 444 matching lines @@
 void InputHandlerProxy::SynchronouslyZoomBy(float magnify_delta,
                                             const gfx::Point& anchor) {
   DCHECK(synchronous_input_handler_);
   input_handler_->PinchGestureBegin();
   input_handler_->PinchGestureUpdate(magnify_delta, anchor);
   input_handler_->PinchGestureEnd();
 }
 
 void InputHandlerProxy::HandleOverscroll(
     const gfx::Point& causal_event_viewport_point,
-    const cc::InputHandlerScrollResult& scroll_result) {
+    const cc::InputHandlerScrollResult& scroll_result,
+    bool bundle_ack_with_triggering_event) {

[tdresser, 2016/09/01 16:58:45]

Can we tweak this naming? bundle_overscroll_params_with_ack perhaps? 

[chongz, 2016/09/01 20:13:13]

Done.

   DCHECK(client_);
   if (!scroll_result.did_overscroll_root)
     return;
 
   TRACE_EVENT2("input",
                "InputHandlerProxy::DidOverscroll",
                "dx",
                scroll_result.unused_scroll_delta.x(),
                "dy",
                scroll_result.unused_scroll_delta.y());
 
   if (fling_curve_) {
     static const int kFlingOverscrollThreshold = 1;
     disallow_horizontal_fling_scroll_ |=
         std::abs(scroll_result.accumulated_root_overscroll.x()) >=
         kFlingOverscrollThreshold;
     disallow_vertical_fling_scroll_ |=
         std::abs(scroll_result.accumulated_root_overscroll.y()) >=
         kFlingOverscrollThreshold;
   }
 
+  if (bundle_ack_with_triggering_event) {
+    // Bundle overscroll message with triggering event response, saving an IPC.
+    current_overscroll_params_.reset(new DidOverscrollParams());
+    current_overscroll_params_->accumulated_overscroll =
+        scroll_result.accumulated_root_overscroll;
+    current_overscroll_params_->latest_overscroll_delta =
+        scroll_result.unused_scroll_delta;
+    current_overscroll_params_->current_fling_velocity =
+        ToClientScrollIncrement(current_fling_velocity_);
+    current_overscroll_params_->causal_event_viewport_point =
+        gfx::PointF(causal_event_viewport_point);
+    return;
+  }
+
   client_->DidOverscroll(scroll_result.accumulated_root_overscroll,
                          scroll_result.unused_scroll_delta,
                          ToClientScrollIncrement(current_fling_velocity_),
                          gfx::PointF(causal_event_viewport_point));
 }
 
 bool InputHandlerProxy::CancelCurrentFling() {
   if (CancelCurrentFlingWithoutNotifyingClient()) {
     client_->DidStopFlinging();
     return true;
@@ skipping 152 matching lines @@
       clipped_increment = ToClientScrollIncrement(clipped_increment);
       cc::ScrollStateData scroll_state_data;
       scroll_state_data.delta_x = clipped_increment.width;
       scroll_state_data.delta_y = clipped_increment.height;
       scroll_state_data.velocity_x = clipped_velocity.width;
       scroll_state_data.velocity_y = clipped_velocity.height;
       scroll_state_data.is_in_inertial_phase = true;
       cc::ScrollState scroll_state(scroll_state_data);
       cc::InputHandlerScrollResult scroll_result =
           input_handler_->ScrollBy(&scroll_state);
-      HandleOverscroll(fling_parameters_.point, scroll_result);
+      HandleOverscroll(fling_parameters_.point, scroll_result,
+                       !kBundleAckWithTriggeringEvent);
       did_scroll = scroll_result.did_scroll;
     } break;
     case blink::WebGestureDeviceUninitialized:
       NOTREACHED();
       return false;
   }
 
   if (did_scroll) {
     fling_parameters_.cumulativeScroll.width += clipped_increment.width;
     fling_parameters_.cumulativeScroll.height += clipped_increment.height;
@@ skipping 18 matching lines @@
   // 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));
 }
 
 }  // namespace ui