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 td = base::TimeDelta::FromMicroseconds(

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

td -> time_delta

https://google.github.io/styleguide/cppguide.html#General_Naming_Rules
'Give as descriptive a name as possible, within reason. Do not worry about
saving horizontal space as it is far more important to make your code
immediately understandable by a new reader. Do not use abbreviations that are
ambiguous or unfamiliar to readers outside your project, and do not abbreviate
by deleting letters within a word.'

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

Great, thanks!

+      duration / kDurationDivisor * base::Time::kMicrosecondsPerSecond);
+
+  td = td - delayed_by;
+  if (td >= base::TimeDelta())

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

operator> is comparing unsigned integers, so this is always true...

Does
operator-(https://cs.chromium.org/chromium/src/base/time/time.h?rcl=1472109603&l=185)
do what you think it does?

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

Whoops, nevermind, this looks fine.

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

Acknowledged.

+    return td;
+  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 (has_set_initial_value_ && duration == base::TimeDelta())

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

duration_.is_zero()

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

Done.

+    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;
   }
+
+  if (t == 0) {

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

Should this be combined with the clause above?

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

I think this is more clear in communicating that this case is for when the
animation hasn't started yet, as opposed to the one above, where the new target
very small. WDYT?

[tdresser, 2016/08/29 15:28:28]

Acknowledged.

+    // Just update the target since the animation hasn't started yet.
+    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();
   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