Communicate MT changes to impl-only scroll offset animations

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 90 matching lines @@
   initial_value_ = initial_value;
   has_set_initial_value_ = true;
   total_animation_duration_ = SegmentDuration(
       target_value_.DeltaFrom(initial_value_), duration_behavior_);
 }
 
 bool ScrollOffsetAnimationCurve::HasSetInitialValue() const {
   return has_set_initial_value_;
 }
 
+void ScrollOffsetAnimationCurve::ApplyAdjustment(
+    base::TimeDelta t,
+    const gfx::Vector2dF& adjustment) {
+  SetInitialValue(ScrollOffsetWithDelta(GetValue(t), adjustment));

[skobes, 2016/05/07 00:25:16]

I don't think we want to call SetInitialValue here since that will reset
total_animation_duration_.  We should just apply the adjustment directly to
initial_value_.

[ymalik, 2016/05/10 19:40:59]

We are starting essentially aborting the previous animation and starting a new
animation with the adjustment. The initial value of the animation needs to be
where we currently are offsetted by the adjustment. Because the distance the new
animation covers is less than that of the old animation, shouldn't the total
duration also be adjusted?

I tried it without adjusting total_animation_duration_ and it didn't seem as
smooth as with it.

[ymalik, 2016/05/12 22:31:25]

Spoke to you offline. And you're right that we shouldn't change the duration. I
was missing the fact that I need to copy over the start time from the previous
animation.

+  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 <= base::TimeDelta())
     return initial_value_;
 
   if (t >= duration)
     return target_value_;
@@ skipping 94 matching lines @@
       (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