Fix scroll animation UpdateTarget for zero-duration segments

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 192 matching lines @@
     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()) {

[skobes, 2016/09/12 22:45:46]

I think this block is redundant now?

[ymalik, 2016/09/12 23:35:05]

Yes, you're right. 

     DCHECK_LE(t, 0);
     total_animation_duration_ =
         SegmentDuration(new_target.DeltaFrom(initial_value_),
                         duration_behavior_, base::TimeDelta::FromSecondsD(-t));
     target_value_ = new_target;
     return;
   }
 
   base::TimeDelta delayed_by = base::TimeDelta::FromSecondsD(
       std::max(0.0, last_retarget_.InSecondsF() - t));
   t = std::max(t, last_retarget_.InSecondsF());
 
   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);
 
+  // The last segement was of zero duration.
+  if ((total_animation_duration_ - last_retarget_).is_zero()) {
+    DCHECK_EQ(t, last_retarget_.InSecondsF());
+    total_animation_duration_ =
+        SegmentDuration(new_delta, duration_behavior_, base::TimeDelta());

[skobes, 2016/09/12 22:45:46]

Pass delayed_by here?

[ymalik, 2016/09/12 23:35:05]

Done.

+    target_value_ = new_target;
+    return;
+  }
+
   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_, delayed_by).InSecondsF(),
@@ skipping 15 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