Touchpad and wheel scroll latching for ChromeOS behind flag.

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 236 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()),
+      touchpad_and_wheel_scroll_latching_enabled_(false),
       touch_start_result_(kEventDispositionUndefined),
       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(
@@ skipping 339 matching lines @@
     case cc::EventListenerProperties::kBlocking:
       return DID_NOT_HANDLE;
     case cc::EventListenerProperties::kNone:
       return DROP_EVENT;
     default:
       NOTREACHED();
       return DROP_EVENT;
   }
 }
 
-InputHandlerProxy::EventDisposition InputHandlerProxy::ScrollByMouseWheel(
+InputHandlerProxy::EventDisposition InputHandlerProxy::FlingScrollByMouseWheel(
     const WebMouseWheelEvent& wheel_event,
     cc::EventListenerProperties listener_properties) {
   DCHECK(listener_properties == cc::EventListenerProperties::kPassive ||
          listener_properties == cc::EventListenerProperties::kNone);
 
-  // TODO(ccameron): The rail information should be pushed down into
-  // InputHandler.
-  gfx::Vector2dF scroll_delta(
-      wheel_event.railsMode != WebInputEvent::RailsModeVertical
-          ? -wheel_event.deltaX
-          : 0,
-      wheel_event.railsMode != WebInputEvent::RailsModeHorizontal
-          ? -wheel_event.deltaY
-          : 0);
+  DCHECK(!wheel_event.railsMode);

[bokan, 2017/01/10 18:53:58]

Is this because the TODO was resolved?

[sahel, 2017/01/10 21:10:06]

No it's not, it is because this function is only called in touchpadScrollFling
and the  synthetic_wheel event there doesn't have vertical/horizontal rail mode.

+  gfx::Vector2dF scroll_delta(-wheel_event.deltaX, -wheel_event.deltaY);
 
-  if (wheel_event.scrollByPage) {
-    // TODO(jamesr): We don't properly handle scroll by page in the compositor
-    // thread, so punt it to the main thread. http://crbug.com/236639
-    RecordMainThreadScrollingReasons(
-        blink::WebGestureDeviceTouchpad,
-        cc::MainThreadScrollingReason::kPageBasedScrolling);
-    return DID_NOT_HANDLE;
+  DCHECK(!wheel_event.scrollByPage);

[bokan, 2017/01/10 18:53:58]

The bug linked with the TODO(jamesr) is still open. Why is it ok to DCHECK this
now?

[sahel, 2017/01/10 21:10:06]

Similarly, this part of the code was never executed.

+  DCHECK(wheel_event.hasPreciseScrollingDeltas);
+  if (touchpad_and_wheel_scroll_latching_enabled_) {
+    if (gesture_scroll_on_impl_thread_) {

[bokan, 2017/01/10 18:53:58]

nit: 

if (!gesture_scroll_on_impl_thread_) 
  return DID_NOT_HANDLE;

[sahel, 2017/01/10 21:10:06]

Done.

+      TRACE_EVENT_INSTANT2("input",
+                           "InputHandlerProxy::handle_input wheel scroll",
+                           TRACE_EVENT_SCOPE_THREAD, "deltaX", scroll_delta.x(),
+                           "deltaY", scroll_delta.y());
 
-  } else if (ShouldAnimate(wheel_event.hasPreciseScrollingDeltas)) {
-    base::TimeTicks event_time =
-        base::TimeTicks() +
-        base::TimeDelta::FromSecondsD(wheel_event.timeStampSeconds);
-    base::TimeDelta delay = base::TimeTicks::Now() - event_time;
-    cc::InputHandler::ScrollStatus scroll_status =
-        input_handler_->ScrollAnimated(gfx::Point(wheel_event.x, wheel_event.y),
-                                       scroll_delta, delay);
+      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;

[bokan, 2017/01/10 18:53:58]

This code is duplicated from below. Instead of copying it up here, find a way to
reuse it. e.g. Presumably you want to avoid the ScrollBegin, just guard it in
|!touchpad_and_wheel_scroll_latching_enabled_|

[sahel, 2017/01/10 21:10:06]

I initially did that in mouse_wheel_event_queue. I got this review comment
saying that since we will get rid of the flag, copying some parts of code is
prefered because this way it's easier to delete the
|!touchpad_and_wheel_scroll_latching_enabled_| code path.

I can still change the code to avoid copying but I will have more fine grain
if(touchpad...) conditions.

[bokan, 2017/01/10 21:25:06]

Ok, if it's going away eventually duplication is fine.

[sahel, 2017/01/12 18:53:44]

Acknowledged.

+      cc::ScrollState scroll_state_update(scroll_state_update_data);
 
-    RecordMainThreadScrollingReasons(
-        blink::WebGestureDeviceTouchpad,
-        scroll_status.main_thread_scrolling_reasons);
+      cc::InputHandlerScrollResult scroll_result =
+          input_handler_->ScrollBy(&scroll_state_update);
+      HandleOverscroll(gfx::Point(wheel_event.x, wheel_event.y), scroll_result,
+                       false);
+      if (scroll_result.did_scroll) {
+        return listener_properties == cc::EventListenerProperties::kPassive
+                   ? DID_HANDLE_NON_BLOCKING
+                   : DID_HANDLE;
+      }
+      // End of fling.
+      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);
 
-    switch (scroll_status.thread) {
-      case cc::InputHandler::SCROLL_ON_IMPL_THREAD:
-        return DID_HANDLE;
-      case cc::InputHandler::SCROLL_IGNORED:
-        return DROP_EVENT;
-      default:
-        return DID_NOT_HANDLE;
+      return DROP_EVENT;
+    } else {
+      return DID_NOT_HANDLE;
     }
-
-  } else {
+  } else {  // !touchpad_and_wheel_scroll_latching_enabled_
     cc::ScrollStateData scroll_state_begin_data;
     scroll_state_begin_data.position_x = wheel_event.x;
     scroll_state_begin_data.position_y = wheel_event.y;
     scroll_state_begin_data.is_beginning = true;
     cc::ScrollState scroll_state_begin(scroll_state_begin_data);
     cc::InputHandler::ScrollStatus scroll_status = input_handler_->ScrollBegin(
         &scroll_state_begin, cc::InputHandler::WHEEL);
 
     RecordMainThreadScrollingReasons(
         blink::WebGestureDeviceTouchpad,
@@ skipping 200 matching lines @@
     NOTREACHED();
     return DID_NOT_HANDLE;
   }
 
 #ifndef NDEBUG
   expect_scroll_update_end_ = false;
 #endif
 
   switch (scroll_status.thread) {
     case cc::InputHandler::SCROLL_ON_IMPL_THREAD: {
-      if (gesture_event.sourceDevice == blink::WebGestureDeviceTouchpad) {
+      if (!touchpad_and_wheel_scroll_latching_enabled_ &&
+          gesture_event.sourceDevice == blink::WebGestureDeviceTouchpad) {
         scroll_state.set_is_ending(true);
         input_handler_->ScrollEnd(&scroll_state);
       }
 
       const float vx = gesture_event.data.flingStart.velocityX;
       const float vy = gesture_event.data.flingStart.velocityY;
       current_fling_velocity_ = gfx::Vector2dF(vx, vy);
       DCHECK(!current_fling_velocity_.IsZero());
       fling_curve_.reset(client_->CreateFlingAnimationCurve(
           gesture_event.sourceDevice,
@@ skipping 515 matching lines @@
                                          fling_parameters_.modifiers,
                                          InSecondsF(base::TimeTicks::Now()));
       synthetic_wheel.deltaX = increment.width;
       synthetic_wheel.deltaY = increment.height;
       synthetic_wheel.hasPreciseScrollingDeltas = true;
       synthetic_wheel.x = fling_parameters_.point.x;
       synthetic_wheel.y = fling_parameters_.point.y;
       synthetic_wheel.globalX = fling_parameters_.globalPoint.x;
       synthetic_wheel.globalY = fling_parameters_.globalPoint.y;
 
-      disposition = ScrollByMouseWheel(synthetic_wheel, properties);
+      disposition = FlingScrollByMouseWheel(synthetic_wheel, properties);
 
       // Send the event over to the main thread.
       if (disposition == DID_HANDLE_NON_BLOCKING) {
         client_->DispatchNonBlockingEventToMainThread(
             ui::WebInputEventTraits::Clone(synthetic_wheel), ui::LatencyInfo());
       }
       break;
     }
     default:
       NOTREACHED();
@@ skipping 109 matching lines @@
                  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