Take MT jank into account when animating the scroll offset on CC

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 18 matching lines @@
 }
 
 ScrollOffsetAnimationsImpl::~ScrollOffsetAnimationsImpl() {
   scroll_offset_timeline_->DetachPlayer(scroll_offset_animation_player_.get());
   animation_host_->RemoveAnimationTimeline(scroll_offset_timeline_.get());
 }
 
 void ScrollOffsetAnimationsImpl::ScrollAnimationCreate(
     ElementId element_id,
     const gfx::ScrollOffset& target_offset,
-    const gfx::ScrollOffset& current_offset) {
+    const gfx::ScrollOffset& current_offset,
+    base::TimeDelta delayed_by) {
   std::unique_ptr<ScrollOffsetAnimationCurve> curve =
       ScrollOffsetAnimationCurve::Create(
           target_offset, CubicBezierTimingFunction::CreatePreset(
                              CubicBezierTimingFunction::EaseType::EASE_IN_OUT),
           ScrollOffsetAnimationCurve::DurationBehavior::INVERSE_DELTA);
-  curve->SetInitialValue(current_offset);
+  curve->SetInitialValue(current_offset, delayed_by);
 
   std::unique_ptr<Animation> animation = Animation::Create(
       std::move(curve), AnimationIdProvider::NextAnimationId(),
       AnimationIdProvider::NextGroupId(), TargetProperty::SCROLL_OFFSET);
   animation->set_is_impl_only(true);
 
   DCHECK(scroll_offset_animation_player_);
   DCHECK(scroll_offset_animation_player_->animation_timeline());
 
   ReattachScrollOffsetPlayerIfNeeded(element_id);
 
   scroll_offset_animation_player_->AddAnimation(std::move(animation));
 }
 
 bool ScrollOffsetAnimationsImpl::ScrollAnimationUpdateTarget(
     ElementId element_id,
     const gfx::Vector2dF& scroll_delta,
     const gfx::ScrollOffset& max_scroll_offset,
-    base::TimeTicks frame_monotonic_time) {
+    base::TimeTicks frame_monotonic_time,
+    base::TimeDelta delayed_by) {
   DCHECK(scroll_offset_animation_player_);
   if (!scroll_offset_animation_player_->element_animations())
     return false;
 
   DCHECK_EQ(element_id, scroll_offset_animation_player_->element_id());
 
   Animation* animation =
       scroll_offset_animation_player_->element_animations()->GetAnimation(
           TargetProperty::SCROLL_OFFSET);
   if (!animation) {
@@ skipping 11 matching lines @@
   new_target.SetToMax(gfx::ScrollOffset());
   new_target.SetToMin(max_scroll_offset);
 
   // TODO(ymalik): Animation::TrimTimeToCurrentIteration should probably check
   // for run_state == Animation::WAITING_FOR_TARGET_AVAILABILITY.
   base::TimeDelta trimmed =
       animation->run_state() == Animation::WAITING_FOR_TARGET_AVAILABILITY
           ? base::TimeDelta()
           : animation->TrimTimeToCurrentIteration(frame_monotonic_time);
 
+  // Re-target taking the delay into account.
+  if (delayed_by > base::TimeDelta())

[tdresser, 2016/08/25 15:55:54]

!delayed_by.is_zero()

[ymalik, 2016/08/29 14:52:05]

Covered this on chat, but for posterity:
delayed_by is a TimeDelta and can be negative, so this prevents against  
non-sane values.

+    trimmed = delayed_by < trimmed ? trimmed - delayed_by : base::TimeDelta();

[tdresser, 2016/08/25 15:55:54]

I'm not completely clear on what's going on here.

We're trimming time off the front?

I'm not sure how overflow works with TimeDeltas, but we should be sure this
makes sense.

[tdresser, 2016/08/29 14:31:33]

Subtraction is just saturated. This seems reasonable.

[ymalik, 2016/08/29 14:52:05]

Yes. We're just trying to use the delay as a signal that this should have really
been re-targeted delayed_by ago.

+
   curve->UpdateTarget(trimmed.InSecondsF(), new_target);
 
   return true;
 }
 
 void ScrollOffsetAnimationsImpl::ScrollAnimationApplyAdjustment(
     ElementId element_id,
     const gfx::Vector2dF& adjustment) {
   DCHECK(scroll_offset_animation_player_);
   if (element_id != scroll_offset_animation_player_->element_id())
@@ skipping 47 matching lines @@
     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