Impl thread smooth scrolling.

cc/trees/layer_tree_host_impl.cc

Index: cc/trees/layer_tree_host_impl.cc
diff --git a/cc/trees/layer_tree_host_impl.cc b/cc/trees/layer_tree_host_impl.cc
index caa380ec8623f26c387539b3067298a87da5a698..69b08f68482c2c20afefde5382e9578c8c8e7ef0 100644
--- a/cc/trees/layer_tree_host_impl.cc
+++ b/cc/trees/layer_tree_host_impl.cc
@@ -13,6 +13,8 @@
 #include "base/metrics/histogram.h"
 #include "base/stl_util.h"
 #include "base/strings/stringprintf.h"
+#include "cc/animation/animation_id_provider.h"
+#include "cc/animation/scroll_offset_animation_curve.h"
 #include "cc/animation/scrollbar_animation_controller.h"
 #include "cc/animation/timing_function.h"
 #include "cc/base/latency_info_swap_promise_monitor.h"
@@ -2262,6 +2264,57 @@ InputHandler::ScrollStatus LayerTreeHostImpl::ScrollBegin(
   return ScrollIgnored;
 }
 
+InputHandler::ScrollStatus LayerTreeHostImpl::ScrollAnimated(
+    const gfx::Point& viewport_point,
+    const gfx::Vector2dF& scroll_delta) {
+  if (CurrentlyScrollingLayer()) {
+    // TODO(skobes): Update the target of the existing animation.
+    return ScrollIgnored;
+  }
+  InputHandler::ScrollStatus scroll_status = ScrollBegin(viewport_point, Wheel);
+  if (scroll_status == ScrollStarted) {
+    for (LayerImpl* layer_impl = CurrentlyScrollingLayer(); layer_impl;
+         layer_impl = layer_impl->parent()) {
+      if (!layer_impl->scrollable())
+        continue;
+
+      gfx::Vector2dF current_offset = layer_impl->TotalScrollOffset();
+      gfx::Vector2dF target_offset = current_offset + scroll_delta;
+      target_offset.SetToMax(gfx::Vector2dF());
+      target_offset.SetToMin(layer_impl->MaxScrollOffset());
+      gfx::Vector2dF actual_delta = target_offset - current_offset;
+
+      const float kEpsilon = 0.1f;
+      bool can_layer_scroll = (std::abs(actual_delta.x()) > kEpsilon ||
+                               std::abs(actual_delta.y()) > kEpsilon);

[ajuma, 2014/07/08 14:44:49]

If actual_delta is less than kEpsilon but non-zero, shouldn't the layer still be
scrolled by actual_delta?

ScrollBy has logic for deciding whether scrolls should bubble. Do we need that
logic here too? Can it be shared?

[skobes, 2014/07/08 17:49:12]

I based this on the logic in ScrollBy, I think the use of kEpsilon is to deal
with rounding error from floating point math.  I assume scroll offsets are
rounded to pixel boundary somewhere?
I think it is not needed here since should_bubble_scrolls_ is always true for
wheel scrolls.  When the ScrollInputType is NonBubblingGesture we do not go
through ScrollAnimated.

[ajuma, 2014/07/08 18:45:32]

It looks like ScrollBy actually performs the scroll (calling
ScrollLayerWithLocalDelta) before considering whether the amount scrolled was
greater than kEpsilon. You're right that it might not change what gets
displayed, but it's still going to be a difference in the value of the layer's
scroll offset.
There's also the logic for bubbling scrolls to show the top controls. Presumably
that's not so important here because wheel scrolling is going to be pretty
uncommon on Android, but it probably still warrants a comment and/or a TODO.

[skobes, 2014/07/08 21:21:58]

Fair point, done.
Added a comment.  This codepath shouldn't apply to Android.

+
+      if (!can_layer_scroll)
+        continue;
+
+      active_tree_->SetCurrentlyScrollingLayer(layer_impl);
+
+      scoped_ptr<ScrollOffsetAnimationCurve> curve =
+          ScrollOffsetAnimationCurve::Create(target_offset,
+                                             EaseInOutTimingFunction::Create());
+      curve->SetInitialValue(current_offset);
+
+      scoped_ptr<Animation> animation =
+          Animation::Create(curve->Clone().Pass(),
+                            AnimationIdProvider::NextAnimationId(),
+                            AnimationIdProvider::NextGroupId(),
+                            Animation::ScrollOffset);
+      animation->set_is_impl_only(true);
+
+      layer_impl->layer_animation_controller()->AddAnimation(animation.Pass());
+
+      SetNeedsAnimate();
+      return ScrollStarted;
+    }
+  }
+  ScrollEnd();
+  return scroll_status;
+}
+
 gfx::Vector2dF LayerTreeHostImpl::ScrollLayerWithViewportSpaceDelta(
     LayerImpl* layer_impl,
     float scale_from_viewport_to_screen_space,
@@ -2886,6 +2939,10 @@ void LayerTreeHostImpl::UpdateAnimationState(bool start_ready_animations) {
     (*iter).second->UpdateState(start_ready_animations, events.get());
 
   if (!events->empty()) {
+    if (std::find_if(events->begin(),
+                     events->end(),
+                     IsScrollOffsetAnimationFinished()) != events->end())
+      ScrollEnd();

[ajuma, 2014/07/08 14:44:49]

I think a better approach would be to modify LayerAnimationController so that
for impl-only animations, we directly call NotifyAnimationStarted (in
::PromoteStartedAnimations) and NotifyAnimationFinished (in
::MarkAnimationsForDeletion) rather then enqueuing events which get sent to the
main thread. (These events currently get sent to the main thread because a
previous consumer of impl-only animations expected to get notified on the main
thread, but this is no longer used.) Then you can set LayerImpl as the animation
delegate as you initially planned.

[skobes, 2014/07/08 17:49:12]

Done.

     client_->PostAnimationEventsToMainThreadOnImplThread(events.Pass());
   }