Impl thread smooth scrolling.

cc/trees/layer_tree_host_impl.cc

 // Copyright 2011 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 "cc/trees/layer_tree_host_impl.h"
 
 #include <algorithm>
 #include <limits>
 
 #include "base/basictypes.h"
 #include "base/containers/hash_tables.h"
 #include "base/json/json_writer.h"
 #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"
 #include "cc/base/math_util.h"
 #include "cc/base/util.h"
 #include "cc/debug/benchmark_instrumentation.h"
 #include "cc/debug/debug_rect_history.h"
 #include "cc/debug/devtools_instrumentation.h"
 #include "cc/debug/frame_rate_counter.h"
 #include "cc/debug/paint_time_counter.h"
@@ skipping 2229 matching lines @@
     active_tree_->SetCurrentlyScrollingLayer(scrolling_layer_impl);
     should_bubble_scrolls_ = (type != NonBubblingGesture);
     wheel_scrolling_ = (type == Wheel);
     client_->RenewTreePriority();
     UMA_HISTOGRAM_BOOLEAN("TryScroll.SlowScroll", false);
     return ScrollStarted;
   }
   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,
     const gfx::PointF& viewport_point,
     const gfx::Vector2dF& viewport_delta) {
   // Layers with non-invertible screen space transforms should not have passed
   // the scroll hit test in the first place.
   DCHECK(layer_impl->screen_space_transform().IsInvertible());
   gfx::Transform inverse_screen_space_transform(
       gfx::Transform::kSkipInitialization);
@@ skipping 604 matching lines @@
   scoped_ptr<AnimationEventsVector> events =
       make_scoped_ptr(new AnimationEventsVector);
   AnimationRegistrar::AnimationControllerMap copy =
       animation_registrar_->active_animation_controllers();
   for (AnimationRegistrar::AnimationControllerMap::iterator iter = copy.begin();
        iter != copy.end();
        ++iter)
     (*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());
   }
 
   SetNeedsAnimate();
 }
 
 void LayerTreeHostImpl::ActivateAnimations() {
   if (!settings_.accelerated_animation_enabled || !needs_animate_layers() ||
       !active_tree_->root_layer())
     return;
@@ skipping 247 matching lines @@
 }
 
 void LayerTreeHostImpl::UnregisterPictureLayerImpl(PictureLayerImpl* layer) {
   std::vector<PictureLayerImpl*>::iterator it =
       std::find(picture_layers_.begin(), picture_layers_.end(), layer);
   DCHECK(it != picture_layers_.end());
   picture_layers_.erase(it);
 }
 
 }  // namespace cc