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

cc/animation/scroll_offset_animation_curve.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_animation_curve.h"
 
 #include <algorithm>
 #include <cmath>
 
 #include "base/logging.h"
@@ skipping 23 matching lines @@
 
 namespace {
 
 const double kEpsilon = 0.01f;
 
 static float MaximumDimension(const gfx::Vector2dF& delta) {
   return std::abs(delta.x()) > std::abs(delta.y()) ? delta.x() : delta.y();
 }
 
 static base::TimeDelta SegmentDuration(const gfx::Vector2dF& delta,
-                                       DurationBehavior behavior) {
+                                       DurationBehavior behavior,
+                                       base::TimeDelta delayed_by) {
   double duration = kConstantDuration;
   switch (behavior) {
     case DurationBehavior::CONSTANT:
       duration = kConstantDuration;
       break;
     case DurationBehavior::DELTA_BASED:
       duration = std::sqrt(std::abs(MaximumDimension(delta)));
       break;
     case DurationBehavior::INVERSE_DELTA:
       duration = std::min(
           std::max(kInverseDeltaOffset +
                        std::abs(MaximumDimension(delta)) * kInverseDeltaSlope,
                    kInverseDeltaMinDuration),
           kInverseDeltaMaxDuration);
       break;
     default:
       NOTREACHED();
   }
-  return base::TimeDelta::FromMicroseconds(duration / kDurationDivisor *
-                                           base::Time::kMicrosecondsPerSecond);
+
+  base::TimeDelta time_delta = base::TimeDelta::FromMicroseconds(
+      duration / kDurationDivisor * base::Time::kMicrosecondsPerSecond);
+
+  time_delta -= delayed_by;
+  if (time_delta >= base::TimeDelta())
+    return time_delta;
+  return base::TimeDelta();
 }
 
 static std::unique_ptr<TimingFunction> EaseOutWithInitialVelocity(
     double velocity) {
   // Clamp velocity to a sane value.
   velocity = std::min(std::max(velocity, -1000.0), 1000.0);
 
   // Based on CubicBezierTimingFunction::EaseType::EASE_IN_OUT preset
   // with first control point scaled.
   const double x1 = 0.42;
@@ skipping 16 matching lines @@
     std::unique_ptr<TimingFunction> timing_function,
     DurationBehavior duration_behavior)
     : target_value_(target_value),
       timing_function_(std::move(timing_function)),
       duration_behavior_(duration_behavior),
       has_set_initial_value_(false) {}
 
 ScrollOffsetAnimationCurve::~ScrollOffsetAnimationCurve() {}
 
 void ScrollOffsetAnimationCurve::SetInitialValue(
-    const gfx::ScrollOffset& initial_value) {
+    const gfx::ScrollOffset& initial_value,
+    base::TimeDelta delayed_by) {
   initial_value_ = initial_value;
   has_set_initial_value_ = true;
   total_animation_duration_ = SegmentDuration(
-      target_value_.DeltaFrom(initial_value_), duration_behavior_);
+      target_value_.DeltaFrom(initial_value_), duration_behavior_, delayed_by);
 }
 
 bool ScrollOffsetAnimationCurve::HasSetInitialValue() const {
   return has_set_initial_value_;
 }
 
 void ScrollOffsetAnimationCurve::ApplyAdjustment(
     const gfx::Vector2dF& adjustment) {
   initial_value_ = ScrollOffsetWithDelta(initial_value_, adjustment);
   target_value_ = ScrollOffsetWithDelta(target_value_, adjustment);
 }
 
 gfx::ScrollOffset ScrollOffsetAnimationCurve::GetValue(
     base::TimeDelta t) const {
   base::TimeDelta duration = total_animation_duration_ - last_retarget_;
   t -= last_retarget_;
 
+  if (duration.is_zero())
+    return target_value_;
+
   if (t <= base::TimeDelta())
     return initial_value_;
 
   if (t >= duration)
     return target_value_;
 
   double progress = timing_function_->GetValue(TimeUtil::Divide(t, duration));
   return gfx::ScrollOffset(
       gfx::Tween::FloatValueBetween(
           progress, initial_value_.x(), target_value_.x()),
@@ skipping 54 matching lines @@
 }
 
 void ScrollOffsetAnimationCurve::UpdateTarget(
     double t,
     const gfx::ScrollOffset& new_target) {
   if (std::abs(MaximumDimension(target_value_.DeltaFrom(new_target))) <
       kEpsilon) {
     target_value_ = new_target;
     return;
   }
+
+  // The total_animation_duration_ is zero because of the delay that we
+  // accounted for when the animation was created. The new duration should
+  // also take the delay into account.
+  if (total_animation_duration_.is_zero()) {
+    DCHECK_LE(t, 0);
+    total_animation_duration_ =
+        SegmentDuration(new_target.DeltaFrom(initial_value_),
+                        duration_behavior_, base::TimeDelta::FromSecondsD(-t));
+    target_value_ = new_target;
+    return;
+  }
+
+  t = std::max(t, last_retarget_.InSecondsF());

[skobes, 2016/09/02 01:27:56]

Any change in t produced by this line represents jank that we're failing to
account for.  Could we save the difference and pass it as delayed_by to
SegmentDuration on the line that assigns new_duration?

Once that's in place, I think we have a guaranteed invariant that we will never
schedule an animation to end later than the event's platform timestamp + the
"ideal" duration, which is pretty cool.

+
   gfx::ScrollOffset current_position =
       GetValue(base::TimeDelta::FromSecondsD(t));
   gfx::Vector2dF old_delta = target_value_.DeltaFrom(initial_value_);
   gfx::Vector2dF new_delta = new_target.DeltaFrom(current_position);
 
   double old_duration =
       (total_animation_duration_ - last_retarget_).InSecondsF();
   double old_normalized_velocity = timing_function_->Velocity(
       (t - last_retarget_.InSecondsF()) / old_duration);
 
   // Use the velocity-based duration bound when it is less than the constant
   // segment duration. This minimizes the "rubber-band" bouncing effect when
   // old_normalized_velocity is large and new_delta is small.
   double new_duration =
-      std::min(SegmentDuration(new_delta, duration_behavior_).InSecondsF(),
+      std::min(SegmentDuration(new_delta, duration_behavior_, base::TimeDelta())
+                   .InSecondsF(),
                VelocityBasedDurationBound(old_delta, old_normalized_velocity,
                                           old_duration, new_delta));
 
   if (new_duration < kEpsilon) {
     // We are already at or very close to the new target. Stop animating.
     target_value_ = new_target;
     total_animation_duration_ = base::TimeDelta::FromSecondsD(t);
     return;
   }
 
   // TimingFunction::Velocity gives the slope of the curve from 0 to 1.
   // To match the "true" velocity in px/sec we must adjust this slope for
   // differences in duration and scroll delta between old and new curves.
   double new_normalized_velocity =
       old_normalized_velocity * (new_duration / old_duration) *
       (MaximumDimension(old_delta) / MaximumDimension(new_delta));
 
   initial_value_ = current_position;
   target_value_ = new_target;
   total_animation_duration_ = base::TimeDelta::FromSecondsD(t + new_duration);
   last_retarget_ = base::TimeDelta::FromSecondsD(t);
   timing_function_ = EaseOutWithInitialVelocity(new_normalized_velocity);
 }
 
 }  // namespace cc