Impulse fling target updates as ease in-out.

Context -
This CL is specific to Impulse-based-scrolling [1]. Design doc summary
is that if the flag is turned on, scroll animations will use a
different curve. (i.e the new curve is also Bezier based but with
different control points). The CL that added this new curve is
crrev.com/c/1901628.

Problem -
The new curve causes minor jerks for flings on non-PTP touchpads that
send WM_MOUSEWHEEL(s). The reason this happens is because the steep
initial slope of the curve.

Fix -
Start off as an impulse based curve but when subsequent GSU(s) come in,
update the curve to the old ease in/out style curve. That way,
individual mousewheel ticks, keyboard presses, scrollbar clicks will
still feel impulse based and the fling will be smooth.

Misc -
Why can’t we just fix this by changing the control points on the new
Bezier curve?
If we do this, we’d be changing the personality of the Impulse curve
itself which defeats the purpose of adding this new curve in the first
place.

[1] https://docs.google.com/document/d/1A3VmlY3ZR6UtJt3QQ5uuqaCOgPjV6vCMxvkpvPBe0g0/edit#heading=h.ji0n9h8v0xez

Bug: 1157698
Change-Id: I91b90080f6eac4c268f443daf2345716374a1927
Reviewed-on: https://chromium-review.googlesource.com/c/chromium/src/+/2553869
Commit-Queue: Rahul Arakeri <arakeri@microsoft.com>
Reviewed-by: Robert Flack <flackr@chromium.org>
Cr-Commit-Position: refs/heads/master@{#836344}

cc/animation/scroll_offset_animation_curve.cc

@@ -136,7 +136,8 @@ ScrollOffsetAnimationCurve::ScrollOffsetAnimationCurve(
       animation_type_(animation_type),
       duration_behavior_(duration_behavior),
       has_set_initial_value_(false) {
-  DCHECK_EQ((animation_type == AnimationType::kEaseInOut),
+  DCHECK_EQ((animation_type == AnimationType::kEaseInOut ||
+             animation_type == AnimationType::kImpulse),
             duration_behavior.has_value());
   switch (animation_type) {
     case AnimationType::kEaseInOut:
@@ -162,7 +163,8 @@ ScrollOffsetAnimationCurve::ScrollOffsetAnimationCurve(
       animation_type_(animation_type),
       duration_behavior_(duration_behavior),
       has_set_initial_value_(false) {
-  DCHECK_EQ((animation_type == AnimationType::kEaseInOut),
+  DCHECK_EQ((animation_type == AnimationType::kEaseInOut ||
+             animation_type == AnimationType::kImpulse),
             duration_behavior.has_value());
 }
 
@@ -399,11 +401,8 @@ void ScrollOffsetAnimationCurve::UpdateTarget(
     return;
   }
 
-  base::TimeDelta new_duration =
-      (animation_type_ == AnimationType::kEaseInOut)
-          ? EaseInOutBoundedSegmentDuration(new_delta, t, delayed_by)
-          : ImpulseSegmentDuration(new_delta, delayed_by);
-
+  const base::TimeDelta new_duration =
+      EaseInOutBoundedSegmentDuration(new_delta, t, delayed_by);
   if (new_duration.InSecondsF() < kEpsilon) {
     // The duration is (close to) 0, so stop the animation.
     target_value_ = new_target;
@@ -417,19 +416,17 @@ void ScrollOffsetAnimationCurve::UpdateTarget(
   double new_slope =
       velocity * (new_duration.InSecondsF() / MaximumDimension(new_delta));
 
-  if (animation_type_ == AnimationType::kEaseInOut) {
-    timing_function_ = EaseInOutWithInitialSlope(new_slope);
-  } else {
-    DCHECK_EQ(animation_type_, AnimationType::kImpulse);
-    if (IsNewTargetInOppositeDirection(current_position, target_value_,
-                                       new_target)) {
-      // Prevent any rubber-banding by setting the velocity (and subsequently,
-      // the slope) to 0 when moving in the opposite direciton.
-      new_slope = 0;
-    }
-    timing_function_ = ImpulseCurveWithInitialSlope(new_slope);
+  DCHECK(animation_type_ == AnimationType::kImpulse ||
+         animation_type_ == AnimationType::kEaseInOut);
+  if (animation_type_ == AnimationType::kImpulse &&
+      IsNewTargetInOppositeDirection(current_position, target_value_,
+                                     new_target)) {
+    // Prevent any rubber-banding by setting the velocity (and subsequently, the
+    // slope) to 0 when moving in the opposite direciton.
+    new_slope = 0;
   }
 
+  timing_function_ = EaseInOutWithInitialSlope(new_slope);
   initial_value_ = current_position;
   target_value_ = new_target;
   total_animation_duration_ = t + new_duration;

cc/animation/scroll_offset_animation_curve.h

@@ -92,6 +92,9 @@ class CC_ANIMATION_EXPORT ScrollOffsetAnimationCurve : public AnimationCurve {
   static void SetAnimationDurationForTesting(base::TimeDelta duration);
 
  private:
+  FRIEND_TEST_ALL_PREFIXES(ScrollOffsetAnimationCurveTest, ImpulseUpdateTarget);
+  FRIEND_TEST_ALL_PREFIXES(ScrollOffsetAnimationCurveTest,
+                           ImpulseUpdateTargetSwitchDirections);
   friend class ScrollOffsetAnimationCurveFactory;
   enum class AnimationType { kLinear, kEaseInOut, kImpulse };
 

cc/animation/scroll_offset_animation_curve_factory.cc

@@ -4,6 +4,7 @@
 
 #include "cc/animation/scroll_offset_animation_curve_factory.h"
 
+#include <memory>
 #include "base/memory/ptr_util.h"
 #include "cc/animation/timing_function.h"
 #include "cc/base/features.h"
@@ -86,6 +87,7 @@ std::unique_ptr<ScrollOffsetAnimationCurve>
 ScrollOffsetAnimationCurveFactory::CreateImpulseAnimation(
     const gfx::ScrollOffset& target_value) {
   return base::WrapUnique(new ScrollOffsetAnimationCurve(
-      target_value, ScrollOffsetAnimationCurve::AnimationType::kImpulse));
+      target_value, ScrollOffsetAnimationCurve::AnimationType::kImpulse,
+      ScrollOffsetAnimationCurve::DurationBehavior::INVERSE_DELTA));
 }
 }  // namespace cc

cc/animation/scroll_offset_animation_curve_unittest.cc

@@ -21,6 +21,8 @@ namespace {
 // This is the value of the default Impulse bezier curve when t = 0.5
 constexpr double halfway_through_default_impulse_curve = 0.874246;
 
+}  // namespace
+
 TEST(ScrollOffsetAnimationCurveTest, DeltaBasedDuration) {
   gfx::ScrollOffset target_value(100.f, 200.f);
   std::unique_ptr<ScrollOffsetAnimationCurve> curve(
@@ -208,8 +210,8 @@ TEST(ScrollOffsetAnimationCurveTest, ImpulseUpdateTarget) {
   gfx::Vector2dF new_delta =
       new_target_value.DeltaFrom(distance_halfway_through_initial_animation);
   base::TimeDelta updated_segment_duration =
-      ScrollOffsetAnimationCurve::ImpulseSegmentDuration(new_delta,
-                                                         base::TimeDelta());
+      curve->EaseInOutBoundedSegmentDuration(new_delta, base::TimeDelta(),
+                                             base::TimeDelta());
 
   base::TimeDelta overall_duration = time_of_update + updated_segment_duration;
   EXPECT_NEAR(overall_duration.InSecondsF(), curve->Duration().InSecondsF(),
@@ -257,25 +259,26 @@ TEST(ScrollOffsetAnimationCurveTest, ImpulseUpdateTargetSwitchDirections) {
   curve->UpdateTarget(base::TimeDelta::FromSecondsD(initial_duration / 2),
                       updated_target);
 
-  double updated_duration =
-      ScrollOffsetAnimationCurve::ImpulseSegmentDuration(
-          gfx::Vector2dF(updated_initial_value.x(), updated_initial_value.y()),
-          base::TimeDelta())
-          .InSecondsF();
-
   EXPECT_NEAR(
       initial_target_value.y() * halfway_through_default_impulse_curve,
       curve->GetValue(base::TimeDelta::FromSecondsD(initial_duration / 2.0))
           .y(),
       0.01f);
 
-  EXPECT_NEAR(
-      updated_initial_value.y() * (1.0 - halfway_through_default_impulse_curve),
-      curve
-          ->GetValue(base::TimeDelta::FromSecondsD(initial_duration / 2.0 +
-                                                   updated_duration / 2.0))
-          .y(),
-      0.01f);
+  // Once the impulse style curve is updated, it turns to an ease-in ease-out
+  // type curve.
+  double updated_duration = curve
+                                ->EaseInOutBoundedSegmentDuration(
+                                    gfx::Vector2dF(updated_initial_value.x(),
+                                                   updated_initial_value.y()),
+                                    base::TimeDelta(), base::TimeDelta())
+                                .InSecondsF();
+  EXPECT_NEAR(updated_initial_value.y() * 0.5,
+              curve
+                  ->GetValue(base::TimeDelta::FromSecondsD(
+                      initial_duration / 2.0 + updated_duration / 2.0))
+                  .y(),
+              0.01f);
   EXPECT_NEAR(0.0,
               curve
                   ->GetValue(base::TimeDelta::FromSecondsD(
@@ -453,5 +456,4 @@ TEST(ScrollOffsetAnimationCurveTest, UpdateTargetZeroLastSegmentDuration) {
   EXPECT_NEAR(expected_duration, curve->Duration().InSecondsF(), 0.0002f);
 }
 
-}  // namespace
 }  // namespace cc