Communicate MT changes to impl-only scroll offset animations

cc/animation/scroll_offset_animations_impl.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 "cc/animation/scroll_offset_animations_impl.h"
 
 #include "cc/animation/animation_events.h"
 #include "cc/animation/animation_host.h"
 #include "cc/animation/animation_id_provider.h"
 #include "cc/animation/animation_player.h"
@@ skipping 72 matching lines @@
   new_target.SetToMax(gfx::ScrollOffset());
   new_target.SetToMin(max_scroll_offset);
 
   curve->UpdateTarget(
       animation->TrimTimeToCurrentIteration(frame_monotonic_time).InSecondsF(),
       new_target);
 
   return true;
 }
 
+void ScrollOffsetAnimationsImpl::ScrollAnimationApplyAdjustment(
+    ElementId element_id,
+    const gfx::Vector2dF& adjustment,
+    base::TimeTicks frame_monotonic_time) {
+  DCHECK(scroll_offset_animation_player_);
+  if (element_id != scroll_offset_animation_player_->element_id())
+    return;
+
+  if (!scroll_offset_animation_player_->element_animations())
+    return;
+
+  Animation* animation =
+      scroll_offset_animation_player_->element_animations()->GetAnimation(
+          TargetProperty::SCROLL_OFFSET);
+  if (!animation)
+    return;
+
+  // Abort the old animation.
+  ScrollAnimationAbort(/* needs_completion */ false);
+
+  // Start a new one with the adjusment.
+  std::unique_ptr<ScrollOffsetAnimationCurve> new_curve =
+      animation->curve()
+          ->ToScrollOffsetAnimationCurve()
+          ->CloneToScrollOffsetAnimationCurve();
+  new_curve->ApplyAdjustment(
+      animation->TrimTimeToCurrentIteration(frame_monotonic_time), adjustment);
+
+  std::unique_ptr<Animation> new_animation = Animation::Create(
+      std::move(new_curve), AnimationIdProvider::NextAnimationId(),
+      AnimationIdProvider::NextGroupId(), TargetProperty::SCROLL_OFFSET);
+  new_animation->set_is_impl_only(true);
+  new_animation->set_affects_active_elements(false);
+
+  ReattachScrollOffsetPlayerIfNeeded(element_id);

[loyso (OOO), 2016/05/06 01:04:38]

element_id == scroll_offset_animation_player_->element_id here. Do we need to
reattach? Also, is it a valid case when we keep spaming impl thread with these
udates? Can we replace element_id !=
scroll_offset_animation_player_->element_id() with a DCHECK?

[ymalik, 2016/05/06 05:41:49]

You're right, no need to reattach.

We can't replay it with a DCHECK in case the adjustment is applied to a layer
that we're not currently scrolling.

+
+  scroll_offset_animation_player_->AddAnimation(std::move(new_animation));
+}
+
 void ScrollOffsetAnimationsImpl::ScrollAnimationAbort(bool needs_completion) {
   DCHECK(scroll_offset_animation_player_);
   scroll_offset_animation_player_->AbortAnimations(
       TargetProperty::SCROLL_OFFSET, needs_completion);
 }
 
 void ScrollOffsetAnimationsImpl::NotifyAnimationFinished(
     base::TimeTicks monotonic_time,
     TargetProperty::Type target_property,
     int group) {
   DCHECK_EQ(target_property, TargetProperty::SCROLL_OFFSET);
   DCHECK(animation_host_->mutator_host_client());
   animation_host_->mutator_host_client()->ScrollOffsetAnimationFinished();
 }
 
 void ScrollOffsetAnimationsImpl::ReattachScrollOffsetPlayerIfNeeded(
     ElementId element_id) {
   if (scroll_offset_animation_player_->element_id() != element_id) {
     if (scroll_offset_animation_player_->element_id())
       scroll_offset_animation_player_->DetachElement();
     if (element_id)
       scroll_offset_animation_player_->AttachElement(element_id);
   }
 }
 
 }  // namespace cc