Revert of 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::FlingScrollByMouseWheel(
+InputHandlerProxy::EventDisposition InputHandlerProxy::ScrollByMouseWheel(
     const WebMouseWheelEvent& wheel_event,
     cc::EventListenerProperties listener_properties) {
   DCHECK(listener_properties == cc::EventListenerProperties::kPassive ||
          listener_properties == cc::EventListenerProperties::kNone);
 
-  DCHECK(!wheel_event.railsMode);
-  gfx::Vector2dF scroll_delta(-wheel_event.deltaX, -wheel_event.deltaY);
+  // 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.scrollByPage);
-  DCHECK(wheel_event.hasPreciseScrollingDeltas);
-  if (touchpad_and_wheel_scroll_latching_enabled_) {
-    if (gesture_scroll_on_impl_thread_) {
-      TRACE_EVENT_INSTANT2("input",
-                           "InputHandlerProxy::handle_input wheel scroll",
-                           TRACE_EVENT_SCOPE_THREAD, "deltaX", scroll_delta.x(),
-                           "deltaY", scroll_delta.y());
+  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;
 
-      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);
+  } 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::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;
-      }
+    RecordMainThreadScrollingReasons(
+        blink::WebGestureDeviceTouchpad,
+        scroll_status.main_thread_scrolling_reasons);
 
-      return DROP_EVENT;
-    } else {
-      return DID_NOT_HANDLE;
+    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;
     }
-  } else {  // !touchpad_and_wheel_scroll_latching_enabled_
+
+  } else {
     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 (!touchpad_and_wheel_scroll_latching_enabled_ &&
-          gesture_event.sourceDevice == blink::WebGestureDeviceTouchpad) {
+      if (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 444 matching lines @@
   if (CancelCurrentFlingWithoutNotifyingClient()) {
     client_->DidStopFlinging();
     return true;
   }
   return false;
 }
 
 bool InputHandlerProxy::CancelCurrentFlingWithoutNotifyingClient() {
   bool had_fling_animation = !!fling_curve_;
   if (had_fling_animation &&
-      (fling_parameters_.sourceDevice == blink::WebGestureDeviceTouchscreen ||
-       (touchpad_and_wheel_scroll_latching_enabled_ &&
-        fling_parameters_.sourceDevice == blink::WebGestureDeviceTouchpad))) {
+      fling_parameters_.sourceDevice == blink::WebGestureDeviceTouchscreen) {
     cc::ScrollStateData scroll_state_data;
     scroll_state_data.is_ending = true;
     cc::ScrollState scroll_state(scroll_state_data);
     input_handler_->ScrollEnd(&scroll_state);
     TRACE_EVENT_ASYNC_END0(
         "input",
         "InputHandlerProxy::HandleGestureFling::started",
         this);
   }
 
@@ skipping 50 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 = FlingScrollByMouseWheel(synthetic_wheel, properties);
+      disposition = ScrollByMouseWheel(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