[Refactor] ScrollAnimated always scrolls latched node

This CL makes it so that the CC animated scroll path latches only in
ScrollAnimatedBegin and prevents it from re-latching at all in
ScrollAnimated.

Since the targetted scrolling node can no longer change in
ScrollAnimated it no longer needs to return any value so the signature
of the method and some tests had to change.

Bug: 1016229
Change-Id: I9b3609de3f22dd7859bece5bb121c7ea752779a5
Reviewed-on: https://chromium-review.googlesource.com/c/chromium/src/+/1980984
Commit-Queue: David Bokan <bokan@chromium.org>
Reviewed-by: Philip Rogers <pdr@chromium.org>
Cr-Commit-Position: refs/heads/master@{#727997}

cc/input/input_handler.h

@@ -176,12 +176,12 @@ class CC_EXPORT InputHandler {
   // a subsequent call to ScrollAnimated can begin on the impl thread.
   virtual ScrollStatus ScrollAnimatedBegin(ScrollState* scroll_state) = 0;
 
-  // Returns SCROLL_ON_IMPL_THREAD if an animation is initiated on the impl
-  // thread. delayed_by is the delay that is taken into account when determining
-  // the duration of the animation.
-  virtual ScrollStatus ScrollAnimated(const gfx::Point& viewport_point,
-                                      const gfx::Vector2dF& scroll_delta,
-                                      base::TimeDelta delayed_by) = 0;
+  // |delayed_by| is the delay that is taken into account when determining
+  // the duration of the animation. TODO(bokan): Should eventually be merged
+  // into ScrollBy. https://crbug.com/1016229.
+  virtual void ScrollAnimated(const gfx::Point& viewport_point,
+                              const gfx::Vector2dF& scroll_delta,
+                              base::TimeDelta delayed_by) = 0;
 
   // Scroll the layer selected by |ScrollBegin| by given |scroll_state| delta.
   // Internally, the delta is transformed to local layer's coordinate space for

cc/trees/layer_tree_host_impl.h

@@ -267,10 +267,9 @@ class CC_EXPORT LayerTreeHostImpl : public InputHandler,
       ScrollState* scroll_state,
       InputHandler::ScrollInputType type) override;
   ScrollStatus ScrollAnimatedBegin(ScrollState* scroll_state) override;
-  InputHandler::ScrollStatus ScrollAnimated(
-      const gfx::Point& viewport_point,
-      const gfx::Vector2dF& scroll_delta,
-      base::TimeDelta delayed_by = base::TimeDelta()) override;
+  void ScrollAnimated(const gfx::Point& viewport_point,
+                      const gfx::Vector2dF& scroll_delta,
+                      base::TimeDelta delayed_by = base::TimeDelta()) override;
   InputHandlerScrollResult ScrollBy(ScrollState* scroll_state) override;
   void RequestUpdateForSynchronousInputHandler() override;
   void SetSynchronousInputHandlerRootScrollOffset(

ui/events/blink/input_handler_proxy.cc

@@ -912,28 +912,19 @@ InputHandlerProxy::HandleGestureScrollUpdate(
   if (ShouldAnimate(gesture_event.SourceDevice(),
                     gesture_event.data.scroll_update.delta_units !=
                         ui::input_types::ScrollGranularity::kScrollByPixel)) {
-    DCHECK(!scroll_state.is_in_inertial_phase());
-    base::TimeTicks event_time = gesture_event.TimeStamp();
-    base::TimeDelta delay = base::TimeTicks::Now() - event_time;
-    switch (input_handler_
-                ->ScrollAnimated(gfx::ToFlooredPoint(scroll_point),
-                                 scroll_delta, delay)
-                .thread) {
-      case cc::InputHandler::SCROLL_ON_IMPL_THREAD:
-        return DID_HANDLE;
-      case cc::InputHandler::SCROLL_IGNORED:
-        TRACE_EVENT_INSTANT0("input", "Scroll Ignored",
-                             TRACE_EVENT_SCOPE_THREAD);
-        return DROP_EVENT;
-      case cc::InputHandler::SCROLL_ON_MAIN_THREAD:
-      case cc::InputHandler::SCROLL_UNKNOWN:
-        if (input_handler_->ScrollingShouldSwitchtoMainThread()) {
-          TRACE_EVENT_INSTANT0("input", "Move Scroll To Main Thread",
-                               TRACE_EVENT_SCOPE_THREAD);
-          gesture_scroll_on_impl_thread_ = false;
-          client_->GenerateScrollBeginAndSendToMainThread(gesture_event);
-        }
-        return DID_NOT_HANDLE;
+    if (input_handler_->ScrollingShouldSwitchtoMainThread()) {
+      TRACE_EVENT_INSTANT0("input", "Move Scroll To Main Thread",
+                           TRACE_EVENT_SCOPE_THREAD);
+      gesture_scroll_on_impl_thread_ = false;
+      client_->GenerateScrollBeginAndSendToMainThread(gesture_event);
+      return DID_NOT_HANDLE;
+    } else {
+      DCHECK(!scroll_state.is_in_inertial_phase());
+      base::TimeTicks event_time = gesture_event.TimeStamp();
+      base::TimeDelta delay = base::TimeTicks::Now() - event_time;
+      input_handler_->ScrollAnimated(gfx::ToFlooredPoint(scroll_point),
+                                     scroll_delta, delay);
+      return DID_HANDLE;
     }
   }
 

ui/events/blink/input_handler_proxy_unittest.cc

@@ -117,9 +117,9 @@ class MockInputHandler : public cc::InputHandler {
                             cc::InputHandler::ScrollInputType type));
   MOCK_METHOD1(ScrollAnimatedBegin, ScrollStatus(cc::ScrollState*));
   MOCK_METHOD3(ScrollAnimated,
-               ScrollStatus(const gfx::Point& viewport_point,
-                            const gfx::Vector2dF& scroll_delta,
-                            base::TimeDelta));
+               void(const gfx::Point& viewport_point,
+                    const gfx::Vector2dF& scroll_delta,
+                    base::TimeDelta));
   MOCK_METHOD1(ScrollBy, cc::InputHandlerScrollResult(cc::ScrollState*));
   MOCK_METHOD1(ScrollEnd, void(bool));
   MOCK_METHOD0(ScrollingShouldSwitchtoMainThread, bool());
@@ -749,8 +749,9 @@ TEST_P(InputHandlerProxyTest, AnimatedScrollbarScroll) {
 
   // Test setup for a kGestureScrollUpdate.
   gesture_.SetType(WebInputEvent::kGestureScrollUpdate);
-  EXPECT_CALL(mock_input_handler_, ScrollAnimated(_, _, _))
-      .WillOnce(testing::Return(kImplThreadScrollState));
+  EXPECT_CALL(mock_input_handler_, ScrollAnimated(_, _, _));
+  EXPECT_CALL(mock_input_handler_, ScrollingShouldSwitchtoMainThread())
+      .WillOnce(testing::Return(false));
   EXPECT_EQ(expected_disposition_,
             input_handler_->RouteToTypeSpecificHandler(gesture_));
   EXPECT_TRUE(input_handler_->gesture_scroll_on_impl_thread_for_testing());
@@ -837,6 +838,8 @@ TEST_P(InputHandlerProxyTest, DISABLED_GestureScrollByCoarsePixels) {
       ui::input_types::ScrollGranularity::kScrollByPixel;
   EXPECT_CALL(mock_input_handler_, ScrollAnimatedBegin(_))
       .WillOnce(testing::Return(kImplThreadScrollState));
+  EXPECT_CALL(mock_input_handler_, ScrollingShouldSwitchtoMainThread())
+      .WillOnce(testing::Return(false));
   EXPECT_EQ(expected_disposition_,
             input_handler_->RouteToTypeSpecificHandler(gesture_));
 
@@ -844,8 +847,7 @@ TEST_P(InputHandlerProxyTest, DISABLED_GestureScrollByCoarsePixels) {
   gesture_.data.scroll_update.delta_units =
       ui::input_types::ScrollGranularity::kScrollByPixel;
 
-  EXPECT_CALL(mock_input_handler_, ScrollAnimated(_, _, _))
-      .WillOnce(testing::Return(kImplThreadScrollState));
+  EXPECT_CALL(mock_input_handler_, ScrollAnimated(_, _, _));
   EXPECT_EQ(expected_disposition_,
             input_handler_->RouteToTypeSpecificHandler(gesture_));