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 12 matching lines @@
 const double kInverseDeltaMinDuration = 6.0;
 const double kInverseDeltaMaxDuration = 12.0;
 
 const double kInverseDeltaSlope =
     (kInverseDeltaMinDuration - kInverseDeltaMaxDuration) /
     (kInverseDeltaRampEndPx - kInverseDeltaRampStartPx);
 
 const double kInverseDeltaOffset =
     kInverseDeltaMaxDuration - kInverseDeltaRampStartPx * kInverseDeltaSlope;
 
+const double kMinDuration = 5.0;
+
 namespace cc {
 
 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 jank_adjustment) {
   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 td = base::TimeDelta::FromMicroseconds(
+      duration / kDurationDivisor * base::Time::kMicrosecondsPerSecond);
+  base::TimeDelta min_td = base::TimeDelta::FromMicroseconds(
+      kMinDuration / kDurationDivisor * base::Time::kMicrosecondsPerSecond);
+  // jank_adjustment is the time delay between now and when we were actually
+  // asked to scroll. If the delay is large, setting the duration to 0 will
+  // scroll to the target position instantly.
+  if (td - jank_adjustment > min_td)
+    return td - jank_adjustment;
+  return base::TimeDelta();

[ymalik, 2016/06/21 23:46:02]

@skobes, If the animation duration is < 83ms, this will just do an instant
scroll. I picked 5 as the min duration constant as a starter, reasonable?  

 }
 
 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 jank_adjustment) {
   initial_value_ = initial_value;
   has_set_initial_value_ = true;
-  total_animation_duration_ = SegmentDuration(
-      target_value_.DeltaFrom(initial_value_), duration_behavior_);
+  total_animation_duration_ =
+      SegmentDuration(target_value_.DeltaFrom(initial_value_),
+                      duration_behavior_, jank_adjustment);
 }
 
 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 (t >= duration)
+    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()),
       gfx::Tween::FloatValueBetween(
           progress, initial_value_.y(), target_value_.y()));
 }
 
 base::TimeDelta ScrollOffsetAnimationCurve::Duration() const {
   return total_animation_duration_;
@@ skipping 55 matching lines @@
     target_value_ = new_target;
     return;
   }
   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();
+
+  if (old_duration < kEpsilon) {
+    // We had an almost instant animation previously, don't try to animate.
+    target_value_ = new_target;
+    return;
+  }
+

[ymalik, 2016/06/21 23:46:02]

Reasoning: I think updating an animation which had a small duration will have a
really high velocity match anyway, so might as well just do this whole animation
instantly? Is this reasonable?  

   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