cc/animation/scroll_offset_animation_curve_unittest.cc - chromium/src.git - Git at Google

 // Copyright 2013 The Chromium Authors
 // 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 <utility>
 #include <vector>

 #include "base/test/scoped_feature_list.h"
 #include "base/time/time.h"
 #include "cc/animation/scroll_offset_animation_curve_factory.h"
 #include "cc/base/features.h"
 #include "testing/gtest/include/gtest/gtest.h"
 #include "ui/gfx/geometry/test/geometry_util.h"

 using DurationBehavior = cc::ScrollOffsetAnimationCurve::DurationBehavior;

 const double kConstantDuration = 9.0;
 const double kDurationDivisor = 60.0;
 const double kInverseDeltaMaxDuration = 12.0;

 namespace cc {

 class ScrollOffsetAnimationCurveTest : public ::testing::Test {
  public:
   ScrollOffsetAnimationCurveTest() {
     std::vector<base::test::FeatureRefAndParams> enabled_features = {
         {
             features::kProgrammaticScrollAnimationOverride,
             {
                 {"cubic_bezier_x1", "0.4"},          //
                 {"cubic_bezier_y1", "0.0"},          //
                 {"cubic_bezier_x2", "0.0"},          //
                 {"cubic_bezier_y2", "1.0"},          //
                 {"max_animation_duration", "1.5s"},  //
             }  //
         }  //
     };
     scoped_feature_list_.InitWithFeaturesAndParameters(
         /*enabled_features=*/
         std::move(enabled_features),
         /*disabled_features=*/{});
   }
   ~ScrollOffsetAnimationCurveTest() override = default;

  private:
   base::test::ScopedFeatureList scoped_feature_list_;
 };

 TEST_F(ScrollOffsetAnimationCurveTest, DeltaBasedDuration) {
   gfx::PointF target_value(100.f, 200.f);
   std::unique_ptr<ScrollOffsetAnimationCurve> curve(
       ScrollOffsetAnimationCurveFactory::CreateEaseInOutAnimationForTesting(
           target_value));

   curve->SetInitialValue(target_value);
   EXPECT_DOUBLE_EQ(0.0, curve->Duration().InSecondsF());

   // x decreases, y stays the same.
   curve->SetInitialValue(gfx::PointF(136.f, 200.f));
   EXPECT_DOUBLE_EQ(0.1, curve->Duration().InSecondsF());

   // x increases, y stays the same.
   curve->SetInitialValue(gfx::PointF(19.f, 200.f));
   EXPECT_DOUBLE_EQ(0.15, curve->Duration().InSecondsF());

   // x stays the same, y decreases.
   curve->SetInitialValue(gfx::PointF(100.f, 344.f));
   EXPECT_DOUBLE_EQ(0.2, curve->Duration().InSecondsF());

   // x stays the same, y increases.
   curve->SetInitialValue(gfx::PointF(100.f, 191.f));
   EXPECT_DOUBLE_EQ(0.05, curve->Duration().InSecondsF());

   // x decreases, y decreases.
   curve->SetInitialValue(gfx::PointF(32500.f, 500.f));
   EXPECT_DOUBLE_EQ(1.5, curve->Duration().InSecondsF());

   // x decreases, y increases.
   curve->SetInitialValue(gfx::PointF(150.f, 119.f));
   EXPECT_DOUBLE_EQ(0.15, curve->Duration().InSecondsF());

   // x increases, y decreases.
   curve->SetInitialValue(gfx::PointF(0.f, 14600.f));
   EXPECT_DOUBLE_EQ(1.5, curve->Duration().InSecondsF());

   // x increases, y increases.
   curve->SetInitialValue(gfx::PointF(95.f, 191.f));
   EXPECT_DOUBLE_EQ(0.05, curve->Duration().InSecondsF());
 }

 TEST_F(ScrollOffsetAnimationCurveTest, GetValue) {
   gfx::PointF initial_value(2.f, 40.f);
   gfx::PointF target_value(10.f, 20.f);
   std::unique_ptr<ScrollOffsetAnimationCurve> curve(
       ScrollOffsetAnimationCurveFactory::CreateEaseInOutAnimationForTesting(
           target_value));
   curve->SetInitialValue(initial_value);

   base::TimeDelta duration = curve->Duration();
   EXPECT_GT(curve->Duration().InSecondsF(), 0);
   EXPECT_LT(curve->Duration().InSecondsF(), 0.1);

   EXPECT_EQ(duration, curve->Duration());

   EXPECT_POINTF_EQ(initial_value, curve->GetValue(base::Seconds(-1.0)));
   EXPECT_POINTF_EQ(initial_value, curve->GetValue(base::TimeDelta()));
   EXPECT_POINTF_NEAR(gfx::PointF(8.8921f, 22.7697f),
                      curve->GetValue(duration * 0.5f), 0.00025);
   EXPECT_POINTF_EQ(target_value, curve->GetValue(duration));
   EXPECT_POINTF_EQ(target_value,
                    curve->GetValue(duration + base::Seconds(1.0)));

   // Verify that GetValue takes the timing function into account.
   gfx::PointF value = curve->GetValue(duration * 0.25f);
   EXPECT_NEAR(5.2583f, value.x(), 0.0002f);
   EXPECT_NEAR(31.8541f, value.y(), 0.0002f);
 }

 TEST_F(ScrollOffsetAnimationCurveTest, MaxAnimationDuration) {
   gfx::PointF initial_value(2.f, 40.f);
   gfx::PointF target_value(200000.f, 400000.f);
   std::unique_ptr<ScrollOffsetAnimationCurve> curve(
       ScrollOffsetAnimationCurveFactory::CreateEaseInOutAnimationForTesting(
           target_value));

   curve->SetInitialValue(initial_value);
   EXPECT_EQ(curve->Duration().InSecondsF(), 1.5);
 }

 // Verify that a clone behaves exactly like the original.
 TEST_F(ScrollOffsetAnimationCurveTest, Clone) {
   gfx::PointF initial_value(2.f, 40.f);
   gfx::PointF target_value(10.f, 20.f);
   std::unique_ptr<ScrollOffsetAnimationCurve> curve(
       ScrollOffsetAnimationCurveFactory::CreateEaseInOutAnimationForTesting(
           target_value));
   curve->SetInitialValue(initial_value);
   base::TimeDelta duration = curve->Duration();

   std::unique_ptr<gfx::AnimationCurve> clone(curve->Clone());

   EXPECT_EQ(duration, clone->Duration());

   ScrollOffsetAnimationCurve* cloned_curve =
       ScrollOffsetAnimationCurve::ToScrollOffsetAnimationCurve(clone.get());

   EXPECT_POINTF_EQ(initial_value, cloned_curve->GetValue(base::Seconds(-1.0)));
   EXPECT_POINTF_EQ(initial_value, cloned_curve->GetValue(base::TimeDelta()));
   EXPECT_POINTF_NEAR(gfx::PointF(8.89213f, 22.76970f),
                      cloned_curve->GetValue(duration * 0.5f), 0.00025);
   EXPECT_POINTF_EQ(target_value, cloned_curve->GetValue(duration));
   EXPECT_POINTF_EQ(target_value,
                    cloned_curve->GetValue(duration + base::Seconds(1.f)));

   // Verify that the timing function was cloned correctly.
   gfx::PointF value = cloned_curve->GetValue(duration * 0.25f);
   EXPECT_NEAR(5.2583f, value.x(), 0.0002f);
   EXPECT_NEAR(31.8541f, value.y(), 0.0002f);
 }

 TEST_F(ScrollOffsetAnimationCurveTest, EaseInOutUpdateTarget) {
   gfx::PointF initial_value(0.f, 0.f);
   gfx::PointF target_value(0.f, 3600.f);
   double duration = kConstantDuration / kDurationDivisor;
   std::unique_ptr<ScrollOffsetAnimationCurve> curve(
       ScrollOffsetAnimationCurveFactory::CreateEaseInOutAnimationForTesting(
           target_value, DurationBehavior::kConstant));
   curve->SetInitialValue(initial_value);
   EXPECT_NEAR(duration, curve->Duration().InSecondsF(), 0.0002f);
   EXPECT_NEAR(3101.4792f, curve->GetValue(base::Seconds(duration / 2.0)).y(),
               0.0002f);
   EXPECT_NEAR(3600.0, curve->GetValue(base::Seconds(duration)).y(), 0.0002f);

   curve->UpdateTarget(base::Seconds(duration / 2), gfx::PointF(0.0, 9900.0));

   EXPECT_NEAR(duration * 1.5, curve->Duration().InSecondsF(), 0.0002f);
   EXPECT_NEAR(3101.4792f, curve->GetValue(base::Seconds(duration / 2.0)).y(),
               0.0002f);
   EXPECT_NEAR(9097.8, curve->GetValue(base::Seconds(duration)).y(), 0.1f);
   EXPECT_NEAR(9900.0, curve->GetValue(base::Seconds(duration * 1.5)).y(),
               0.0002f);

   curve->UpdateTarget(base::Seconds(duration), gfx::PointF(0.0, 7200.0));

   // A closer target at high velocity reduces the duration.
   EXPECT_NEAR(duration * 2, curve->Duration().InSecondsF(), 0.0002f);
   EXPECT_NEAR(9097.8, curve->GetValue(base::Seconds(duration)).y(), 0.1f);
   EXPECT_NEAR(7200.0, curve->GetValue(base::Seconds(duration * 2)).y(),
               0.0002f);
 }

 TEST_F(ScrollOffsetAnimationCurveTest, InverseDeltaDuration) {
   std::unique_ptr<ScrollOffsetAnimationCurve> curve(
       ScrollOffsetAnimationCurveFactory::CreateEaseInOutAnimationForTesting(
           gfx::PointF(0.f, 100.f), DurationBehavior::kInverseDelta));

   curve->SetInitialValue(gfx::PointF());
   double smallDeltaDuration = curve->Duration().InSecondsF();

   curve->UpdateTarget(base::Seconds(0.01f), gfx::PointF(0.f, 300.f));
   double mediumDeltaDuration = curve->Duration().InSecondsF();

   curve->UpdateTarget(base::Seconds(0.01f), gfx::PointF(0.f, 500.f));
   double largeDeltaDuration = curve->Duration().InSecondsF();

   EXPECT_GT(smallDeltaDuration, mediumDeltaDuration);
   EXPECT_GT(mediumDeltaDuration, largeDeltaDuration);

   curve->UpdateTarget(base::Seconds(0.01f), gfx::PointF(0.f, 5000.f));
   EXPECT_EQ(largeDeltaDuration, curve->Duration().InSecondsF());
 }

 TEST_F(ScrollOffsetAnimationCurveTest, LinearAnimation) {
   // Testing autoscroll downwards for a scroller of length 1000px.
   gfx::PointF current_offset(0.f, 0.f);
   gfx::PointF target_offset(0.f, 1000.f);
   std::unique_ptr<ScrollOffsetAnimationCurve> curve(
       ScrollOffsetAnimationCurveFactory::CreateLinearAnimationForTesting(
           target_offset));

   const float autoscroll_velocity = 800.f;  // pixels per second.
   curve->SetInitialValue(current_offset, base::TimeDelta(),
                          autoscroll_velocity);
   EXPECT_FLOAT_EQ(1.25f, curve->Duration().InSecondsF());

   // Test scrolling down from half way.
   current_offset = gfx::PointF(0.f, 500.f);
   curve->SetInitialValue(current_offset, base::TimeDelta(),
                          autoscroll_velocity);
   EXPECT_FLOAT_EQ(0.625f, curve->Duration().InSecondsF());

   // Test scrolling down when max_offset is reached.
   current_offset = gfx::PointF(0.f, 1000.f);
   curve->SetInitialValue(current_offset, base::TimeDelta(),
                          autoscroll_velocity);
   EXPECT_FLOAT_EQ(0.f, curve->Duration().InSecondsF());
 }

 TEST_F(ScrollOffsetAnimationCurveTest, CurveWithDelay) {
   std::unique_ptr<ScrollOffsetAnimationCurve> curve(
       ScrollOffsetAnimationCurveFactory::CreateEaseInOutAnimationForTesting(
           gfx::PointF(0.f, 100.f), DurationBehavior::kInverseDelta));
   double duration_in_seconds = kInverseDeltaMaxDuration / kDurationDivisor;
   double delay_in_seconds = 0.02;
   double curve_duration = duration_in_seconds - delay_in_seconds;

   curve->SetInitialValue(gfx::PointF(), base::Seconds(delay_in_seconds));
   EXPECT_NEAR(curve_duration, curve->Duration().InSecondsF(), 0.0002f);

   curve->UpdateTarget(base::Seconds(0.01f), gfx::PointF(0.f, 500.f));
   EXPECT_GT(curve_duration, curve->Duration().InSecondsF());
   EXPECT_EQ(gfx::PointF(0.f, 500.f), curve->target_value());
 }

 TEST_F(ScrollOffsetAnimationCurveTest, CurveWithLargeDelay) {
   DurationBehavior duration_hint = DurationBehavior::kInverseDelta;
   std::unique_ptr<ScrollOffsetAnimationCurve> curve(
       ScrollOffsetAnimationCurveFactory::CreateEaseInOutAnimationForTesting(
           gfx::PointF(0.f, 100.f), duration_hint));
   curve->SetInitialValue(gfx::PointF(), base::Seconds(0.2));
   EXPECT_EQ(0.f, curve->Duration().InSecondsF());

   // Re-targeting when animation duration is 0.
   curve->UpdateTarget(base::Seconds(-0.01), gfx::PointF(0.f, 300.f));
   double duration =
       curve
           ->EaseInOutSegmentDuration(gfx::Vector2dF(0.f, 200.f), duration_hint,
                                      base::Seconds(0.01))
           .InSecondsF();
   EXPECT_EQ(duration, curve->Duration().InSecondsF());

   // Re-targeting before last_retarget_, the  difference should be accounted for
   // in duration.
   curve->UpdateTarget(base::Seconds(-0.01), gfx::PointF(0.f, 500.f));
   duration = curve
                  ->EaseInOutSegmentDuration(gfx::Vector2dF(0.f, 500.f),
                                             duration_hint, base::Seconds(0.01))
                  .InSecondsF();
   EXPECT_EQ(duration, curve->Duration().InSecondsF());

   EXPECT_POINTF_EQ(gfx::PointF(0.f, 500.f),
                    curve->GetValue(base::Seconds(1.0)));
 }

 // This test verifies that if the last segment duration is zero, ::UpdateTarget
 // simply updates the total animation duration see crbug.com/645317.
 TEST_F(ScrollOffsetAnimationCurveTest, UpdateTargetZeroLastSegmentDuration) {
   DurationBehavior duration_hint = DurationBehavior::kInverseDelta;
   std::unique_ptr<ScrollOffsetAnimationCurve> curve(
       ScrollOffsetAnimationCurveFactory::CreateEaseInOutAnimationForTesting(
           gfx::PointF(0.f, 100.f), duration_hint));
   double duration_in_seconds = kInverseDeltaMaxDuration / kDurationDivisor;
   double delay_in_seconds = 0.02;
   double curve_duration = duration_in_seconds - delay_in_seconds;

   curve->SetInitialValue(gfx::PointF(), base::Seconds(delay_in_seconds));
   EXPECT_NEAR(curve_duration, curve->Duration().InSecondsF(), 0.0002f);

   // Re-target 1, this should set last_retarget_ to 0.05.
   gfx::Vector2dF new_delta =
       gfx::PointF(0.f, 200.f) - curve->GetValue(base::Seconds(0.05));
   double expected_duration =
       curve
           ->EaseInOutSegmentDuration(new_delta, duration_hint,
                                      base::TimeDelta())
           .InSecondsF() +
       0.05;
   curve->UpdateTarget(base::Seconds(0.05), gfx::PointF(0.f, 200.f));
   EXPECT_NEAR(expected_duration, curve->Duration().InSecondsF(), 0.0002f);

   // Re-target 2, this should set total_animation_duration to t, which is
   // last_retarget_. This is what would cause the DCHECK failure in
   // crbug.com/645317.
   curve->UpdateTarget(base::Seconds(-0.145), gfx::PointF(0.f, 300.f));
   EXPECT_NEAR(0.05, curve->Duration().InSecondsF(), 0.0002f);

   // Re-target 3, this should set total_animation_duration based on new_delta.
   new_delta = gfx::PointF(0.f, 500.f) - curve->GetValue(base::Seconds(0.05));
   expected_duration = curve
                           ->EaseInOutSegmentDuration(new_delta, duration_hint,
                                                      base::Seconds(0.15))
                           .InSecondsF();
   curve->UpdateTarget(base::Seconds(-0.1), gfx::PointF(0.f, 500.f));
   EXPECT_NEAR(expected_duration, curve->Duration().InSecondsF(), 0.0002f);
 }

 class ScrollOffsetAnimationCurveTestWithProgrammaticOverride
     : public ::testing::Test {
  public:
   ScrollOffsetAnimationCurveTestWithProgrammaticOverride() {
     std::vector<base::test::FeatureRefAndParams> enabled_features = {
         {
             features::kProgrammaticScrollAnimationOverride,
             {
                 {"cubic_bezier_x1", "0.42"},         //
                 {"cubic_bezier_y1", "0.0"},          //
                 {"cubic_bezier_x2", "0.58"},         //
                 {"cubic_bezier_y2", "1.0"},          //
                 {"max_animation_duration", "0.7s"},  //
             }  //
         }  //
     };
     scoped_feature_list_.InitWithFeaturesAndParameters(
         /*enabled_features=*/
         std::move(enabled_features),
         /*disabled_features=*/{});
   }
   ~ScrollOffsetAnimationCurveTestWithProgrammaticOverride() override = default;

  private:
   base::test::ScopedFeatureList scoped_feature_list_;
 };

 TEST_F(ScrollOffsetAnimationCurveTestWithProgrammaticOverride, GetValue) {
   gfx::PointF initial_value(2.f, 40.f);
   gfx::PointF target_value(10.f, 20.f);
   std::unique_ptr<ScrollOffsetAnimationCurve> curve(
       ScrollOffsetAnimationCurveFactory::CreateAnimation(
           target_value, ScrollOffsetAnimationCurve::ScrollType::kProgrammatic));

   curve->SetInitialValue(initial_value);

   base::TimeDelta duration = curve->Duration();
   EXPECT_GT(curve->Duration().InSecondsF(), 0);
   EXPECT_LT(curve->Duration().InSecondsF(), 0.1);

   EXPECT_EQ(duration, curve->Duration());

   EXPECT_POINTF_EQ(initial_value, curve->GetValue(base::Seconds(-1.0)));
   EXPECT_POINTF_EQ(initial_value, curve->GetValue(base::TimeDelta()));
   EXPECT_POINTF_NEAR(gfx::PointF(6.f, 30.f), curve->GetValue(duration * 0.5f),
                      0.001f);
   EXPECT_POINTF_EQ(target_value, curve->GetValue(duration));
   EXPECT_POINTF_EQ(target_value,
                    curve->GetValue(duration + base::Seconds(1.0)));

   // Verify that GetValue takes the timing function into account.
   gfx::PointF value = curve->GetValue(duration * 0.25f);
   EXPECT_NEAR(3.033f, value.x(), 0.001f);
   EXPECT_NEAR(37.416f, value.y(), 0.001f);
 }

 TEST_F(ScrollOffsetAnimationCurveTestWithProgrammaticOverride,
        MaxAnimationDuration) {
   gfx::PointF initial_value(2.f, 40.f);
   gfx::PointF target_value(200000.f, 400000.f);
   std::unique_ptr<ScrollOffsetAnimationCurve> curve(
       ScrollOffsetAnimationCurveFactory::CreateAnimation(
           target_value, ScrollOffsetAnimationCurve::ScrollType::kProgrammatic));

   curve->SetInitialValue(initial_value);
   EXPECT_EQ(curve->Duration().InSecondsF(), 0.7);
 }

 }  // namespace cc
	// Copyright 2013 The Chromium Authors
	// 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 <utility>
	#include <vector>

	#include "base/test/scoped_feature_list.h"
	#include "base/time/time.h"
	#include "cc/animation/scroll_offset_animation_curve_factory.h"
	#include "cc/base/features.h"
	#include "testing/gtest/include/gtest/gtest.h"
	#include "ui/gfx/geometry/test/geometry_util.h"

	using DurationBehavior = cc::ScrollOffsetAnimationCurve::DurationBehavior;

	const double kConstantDuration = 9.0;
	const double kDurationDivisor = 60.0;
	const double kInverseDeltaMaxDuration = 12.0;

	namespace cc {

	class ScrollOffsetAnimationCurveTest : public ::testing::Test {
	public:
	ScrollOffsetAnimationCurveTest() {
	std::vector<base::test::FeatureRefAndParams> enabled_features = {
	{
	features::kProgrammaticScrollAnimationOverride,
	{
	{"cubic_bezier_x1", "0.4"}, //
	{"cubic_bezier_y1", "0.0"}, //
	{"cubic_bezier_x2", "0.0"}, //
	{"cubic_bezier_y2", "1.0"}, //
	{"max_animation_duration", "1.5s"}, //
	} //
	} //
	};
	scoped_feature_list_.InitWithFeaturesAndParameters(
	/enabled_features=/
	std::move(enabled_features),
	/disabled_features=/{});
	}
	~ScrollOffsetAnimationCurveTest() override = default;

	private:
	base::test::ScopedFeatureList scoped_feature_list_;
	};

	TEST_F(ScrollOffsetAnimationCurveTest, DeltaBasedDuration) {
	gfx::PointF target_value(100.f, 200.f);
	std::unique_ptr<ScrollOffsetAnimationCurve> curve(
	ScrollOffsetAnimationCurveFactory::CreateEaseInOutAnimationForTesting(
	target_value));

	curve->SetInitialValue(target_value);
	EXPECT_DOUBLE_EQ(0.0, curve->Duration().InSecondsF());

	// x decreases, y stays the same.
	curve->SetInitialValue(gfx::PointF(136.f, 200.f));
	EXPECT_DOUBLE_EQ(0.1, curve->Duration().InSecondsF());

	// x increases, y stays the same.
	curve->SetInitialValue(gfx::PointF(19.f, 200.f));
	EXPECT_DOUBLE_EQ(0.15, curve->Duration().InSecondsF());

	// x stays the same, y decreases.
	curve->SetInitialValue(gfx::PointF(100.f, 344.f));
	EXPECT_DOUBLE_EQ(0.2, curve->Duration().InSecondsF());

	// x stays the same, y increases.
	curve->SetInitialValue(gfx::PointF(100.f, 191.f));
	EXPECT_DOUBLE_EQ(0.05, curve->Duration().InSecondsF());

	// x decreases, y decreases.
	curve->SetInitialValue(gfx::PointF(32500.f, 500.f));
	EXPECT_DOUBLE_EQ(1.5, curve->Duration().InSecondsF());

	// x decreases, y increases.
	curve->SetInitialValue(gfx::PointF(150.f, 119.f));
	EXPECT_DOUBLE_EQ(0.15, curve->Duration().InSecondsF());

	// x increases, y decreases.
	curve->SetInitialValue(gfx::PointF(0.f, 14600.f));
	EXPECT_DOUBLE_EQ(1.5, curve->Duration().InSecondsF());

	// x increases, y increases.
	curve->SetInitialValue(gfx::PointF(95.f, 191.f));
	EXPECT_DOUBLE_EQ(0.05, curve->Duration().InSecondsF());
	}

	TEST_F(ScrollOffsetAnimationCurveTest, GetValue) {
	gfx::PointF initial_value(2.f, 40.f);
	gfx::PointF target_value(10.f, 20.f);
	std::unique_ptr<ScrollOffsetAnimationCurve> curve(
	ScrollOffsetAnimationCurveFactory::CreateEaseInOutAnimationForTesting(
	target_value));
	curve->SetInitialValue(initial_value);

	base::TimeDelta duration = curve->Duration();
	EXPECT_GT(curve->Duration().InSecondsF(), 0);
	EXPECT_LT(curve->Duration().InSecondsF(), 0.1);

	EXPECT_EQ(duration, curve->Duration());

	EXPECT_POINTF_EQ(initial_value, curve->GetValue(base::Seconds(-1.0)));
	EXPECT_POINTF_EQ(initial_value, curve->GetValue(base::TimeDelta()));
	EXPECT_POINTF_NEAR(gfx::PointF(8.8921f, 22.7697f),
	curve->GetValue(duration * 0.5f), 0.00025);
	EXPECT_POINTF_EQ(target_value, curve->GetValue(duration));
	EXPECT_POINTF_EQ(target_value,
	curve->GetValue(duration + base::Seconds(1.0)));

	// Verify that GetValue takes the timing function into account.
	gfx::PointF value = curve->GetValue(duration * 0.25f);
	EXPECT_NEAR(5.2583f, value.x(), 0.0002f);
	EXPECT_NEAR(31.8541f, value.y(), 0.0002f);
	}

	TEST_F(ScrollOffsetAnimationCurveTest, MaxAnimationDuration) {
	gfx::PointF initial_value(2.f, 40.f);
	gfx::PointF target_value(200000.f, 400000.f);
	std::unique_ptr<ScrollOffsetAnimationCurve> curve(
	ScrollOffsetAnimationCurveFactory::CreateEaseInOutAnimationForTesting(
	target_value));

	curve->SetInitialValue(initial_value);
	EXPECT_EQ(curve->Duration().InSecondsF(), 1.5);
	}

	// Verify that a clone behaves exactly like the original.
	TEST_F(ScrollOffsetAnimationCurveTest, Clone) {
	gfx::PointF initial_value(2.f, 40.f);
	gfx::PointF target_value(10.f, 20.f);
	std::unique_ptr<ScrollOffsetAnimationCurve> curve(
	ScrollOffsetAnimationCurveFactory::CreateEaseInOutAnimationForTesting(
	target_value));
	curve->SetInitialValue(initial_value);
	base::TimeDelta duration = curve->Duration();

	std::unique_ptr<gfx::AnimationCurve> clone(curve->Clone());

	EXPECT_EQ(duration, clone->Duration());

	ScrollOffsetAnimationCurve* cloned_curve =
	ScrollOffsetAnimationCurve::ToScrollOffsetAnimationCurve(clone.get());

	EXPECT_POINTF_EQ(initial_value, cloned_curve->GetValue(base::Seconds(-1.0)));
	EXPECT_POINTF_EQ(initial_value, cloned_curve->GetValue(base::TimeDelta()));
	EXPECT_POINTF_NEAR(gfx::PointF(8.89213f, 22.76970f),
	cloned_curve->GetValue(duration * 0.5f), 0.00025);
	EXPECT_POINTF_EQ(target_value, cloned_curve->GetValue(duration));
	EXPECT_POINTF_EQ(target_value,
	cloned_curve->GetValue(duration + base::Seconds(1.f)));

	// Verify that the timing function was cloned correctly.
	gfx::PointF value = cloned_curve->GetValue(duration * 0.25f);
	EXPECT_NEAR(5.2583f, value.x(), 0.0002f);
	EXPECT_NEAR(31.8541f, value.y(), 0.0002f);
	}

	TEST_F(ScrollOffsetAnimationCurveTest, EaseInOutUpdateTarget) {
	gfx::PointF initial_value(0.f, 0.f);
	gfx::PointF target_value(0.f, 3600.f);
	double duration = kConstantDuration / kDurationDivisor;
	std::unique_ptr<ScrollOffsetAnimationCurve> curve(
	ScrollOffsetAnimationCurveFactory::CreateEaseInOutAnimationForTesting(
	target_value, DurationBehavior::kConstant));
	curve->SetInitialValue(initial_value);
	EXPECT_NEAR(duration, curve->Duration().InSecondsF(), 0.0002f);
	EXPECT_NEAR(3101.4792f, curve->GetValue(base::Seconds(duration / 2.0)).y(),
	0.0002f);
	EXPECT_NEAR(3600.0, curve->GetValue(base::Seconds(duration)).y(), 0.0002f);

	curve->UpdateTarget(base::Seconds(duration / 2), gfx::PointF(0.0, 9900.0));

	EXPECT_NEAR(duration * 1.5, curve->Duration().InSecondsF(), 0.0002f);
	EXPECT_NEAR(3101.4792f, curve->GetValue(base::Seconds(duration / 2.0)).y(),
	0.0002f);
	EXPECT_NEAR(9097.8, curve->GetValue(base::Seconds(duration)).y(), 0.1f);
	EXPECT_NEAR(9900.0, curve->GetValue(base::Seconds(duration * 1.5)).y(),
	0.0002f);

	curve->UpdateTarget(base::Seconds(duration), gfx::PointF(0.0, 7200.0));

	// A closer target at high velocity reduces the duration.
	EXPECT_NEAR(duration * 2, curve->Duration().InSecondsF(), 0.0002f);
	EXPECT_NEAR(9097.8, curve->GetValue(base::Seconds(duration)).y(), 0.1f);
	EXPECT_NEAR(7200.0, curve->GetValue(base::Seconds(duration * 2)).y(),
	0.0002f);
	}

	TEST_F(ScrollOffsetAnimationCurveTest, InverseDeltaDuration) {
	std::unique_ptr<ScrollOffsetAnimationCurve> curve(
	ScrollOffsetAnimationCurveFactory::CreateEaseInOutAnimationForTesting(
	gfx::PointF(0.f, 100.f), DurationBehavior::kInverseDelta));

	curve->SetInitialValue(gfx::PointF());
	double smallDeltaDuration = curve->Duration().InSecondsF();

	curve->UpdateTarget(base::Seconds(0.01f), gfx::PointF(0.f, 300.f));
	double mediumDeltaDuration = curve->Duration().InSecondsF();

	curve->UpdateTarget(base::Seconds(0.01f), gfx::PointF(0.f, 500.f));
	double largeDeltaDuration = curve->Duration().InSecondsF();

	EXPECT_GT(smallDeltaDuration, mediumDeltaDuration);
	EXPECT_GT(mediumDeltaDuration, largeDeltaDuration);

	curve->UpdateTarget(base::Seconds(0.01f), gfx::PointF(0.f, 5000.f));
	EXPECT_EQ(largeDeltaDuration, curve->Duration().InSecondsF());
	}

	TEST_F(ScrollOffsetAnimationCurveTest, LinearAnimation) {
	// Testing autoscroll downwards for a scroller of length 1000px.
	gfx::PointF current_offset(0.f, 0.f);
	gfx::PointF target_offset(0.f, 1000.f);
	std::unique_ptr<ScrollOffsetAnimationCurve> curve(
	ScrollOffsetAnimationCurveFactory::CreateLinearAnimationForTesting(
	target_offset));

	const float autoscroll_velocity = 800.f; // pixels per second.
	curve->SetInitialValue(current_offset, base::TimeDelta(),
	autoscroll_velocity);
	EXPECT_FLOAT_EQ(1.25f, curve->Duration().InSecondsF());

	// Test scrolling down from half way.
	current_offset = gfx::PointF(0.f, 500.f);
	curve->SetInitialValue(current_offset, base::TimeDelta(),
	autoscroll_velocity);
	EXPECT_FLOAT_EQ(0.625f, curve->Duration().InSecondsF());

	// Test scrolling down when max_offset is reached.
	current_offset = gfx::PointF(0.f, 1000.f);
	curve->SetInitialValue(current_offset, base::TimeDelta(),
	autoscroll_velocity);
	EXPECT_FLOAT_EQ(0.f, curve->Duration().InSecondsF());
	}

	TEST_F(ScrollOffsetAnimationCurveTest, CurveWithDelay) {
	std::unique_ptr<ScrollOffsetAnimationCurve> curve(
	ScrollOffsetAnimationCurveFactory::CreateEaseInOutAnimationForTesting(
	gfx::PointF(0.f, 100.f), DurationBehavior::kInverseDelta));
	double duration_in_seconds = kInverseDeltaMaxDuration / kDurationDivisor;
	double delay_in_seconds = 0.02;
	double curve_duration = duration_in_seconds - delay_in_seconds;

	curve->SetInitialValue(gfx::PointF(), base::Seconds(delay_in_seconds));
	EXPECT_NEAR(curve_duration, curve->Duration().InSecondsF(), 0.0002f);

	curve->UpdateTarget(base::Seconds(0.01f), gfx::PointF(0.f, 500.f));
	EXPECT_GT(curve_duration, curve->Duration().InSecondsF());
	EXPECT_EQ(gfx::PointF(0.f, 500.f), curve->target_value());
	}

	TEST_F(ScrollOffsetAnimationCurveTest, CurveWithLargeDelay) {
	DurationBehavior duration_hint = DurationBehavior::kInverseDelta;
	std::unique_ptr<ScrollOffsetAnimationCurve> curve(
	ScrollOffsetAnimationCurveFactory::CreateEaseInOutAnimationForTesting(
	gfx::PointF(0.f, 100.f), duration_hint));
	curve->SetInitialValue(gfx::PointF(), base::Seconds(0.2));
	EXPECT_EQ(0.f, curve->Duration().InSecondsF());

	// Re-targeting when animation duration is 0.
	curve->UpdateTarget(base::Seconds(-0.01), gfx::PointF(0.f, 300.f));
	double duration =
	curve
	->EaseInOutSegmentDuration(gfx::Vector2dF(0.f, 200.f), duration_hint,
	base::Seconds(0.01))
	.InSecondsF();
	EXPECT_EQ(duration, curve->Duration().InSecondsF());

	// Re-targeting before last_retarget_, the difference should be accounted for
	// in duration.
	curve->UpdateTarget(base::Seconds(-0.01), gfx::PointF(0.f, 500.f));
	duration = curve
	->EaseInOutSegmentDuration(gfx::Vector2dF(0.f, 500.f),
	duration_hint, base::Seconds(0.01))
	.InSecondsF();
	EXPECT_EQ(duration, curve->Duration().InSecondsF());

	EXPECT_POINTF_EQ(gfx::PointF(0.f, 500.f),
	curve->GetValue(base::Seconds(1.0)));
	}

	// This test verifies that if the last segment duration is zero, ::UpdateTarget
	// simply updates the total animation duration see crbug.com/645317.
	TEST_F(ScrollOffsetAnimationCurveTest, UpdateTargetZeroLastSegmentDuration) {
	DurationBehavior duration_hint = DurationBehavior::kInverseDelta;
	std::unique_ptr<ScrollOffsetAnimationCurve> curve(
	ScrollOffsetAnimationCurveFactory::CreateEaseInOutAnimationForTesting(
	gfx::PointF(0.f, 100.f), duration_hint));
	double duration_in_seconds = kInverseDeltaMaxDuration / kDurationDivisor;
	double delay_in_seconds = 0.02;
	double curve_duration = duration_in_seconds - delay_in_seconds;

	curve->SetInitialValue(gfx::PointF(), base::Seconds(delay_in_seconds));
	EXPECT_NEAR(curve_duration, curve->Duration().InSecondsF(), 0.0002f);

	// Re-target 1, this should set last_retarget_ to 0.05.
	gfx::Vector2dF new_delta =
	gfx::PointF(0.f, 200.f) - curve->GetValue(base::Seconds(0.05));
	double expected_duration =
	curve
	->EaseInOutSegmentDuration(new_delta, duration_hint,
	base::TimeDelta())
	.InSecondsF() +
	0.05;
	curve->UpdateTarget(base::Seconds(0.05), gfx::PointF(0.f, 200.f));
	EXPECT_NEAR(expected_duration, curve->Duration().InSecondsF(), 0.0002f);

	// Re-target 2, this should set total_animation_duration to t, which is
	// last_retarget_. This is what would cause the DCHECK failure in
	// crbug.com/645317.
	curve->UpdateTarget(base::Seconds(-0.145), gfx::PointF(0.f, 300.f));
	EXPECT_NEAR(0.05, curve->Duration().InSecondsF(), 0.0002f);

	// Re-target 3, this should set total_animation_duration based on new_delta.
	new_delta = gfx::PointF(0.f, 500.f) - curve->GetValue(base::Seconds(0.05));
	expected_duration = curve
	->EaseInOutSegmentDuration(new_delta, duration_hint,
	base::Seconds(0.15))
	.InSecondsF();
	curve->UpdateTarget(base::Seconds(-0.1), gfx::PointF(0.f, 500.f));
	EXPECT_NEAR(expected_duration, curve->Duration().InSecondsF(), 0.0002f);
	}

	class ScrollOffsetAnimationCurveTestWithProgrammaticOverride
	: public ::testing::Test {
	public:
	ScrollOffsetAnimationCurveTestWithProgrammaticOverride() {
	std::vector<base::test::FeatureRefAndParams> enabled_features = {
	{
	features::kProgrammaticScrollAnimationOverride,
	{
	{"cubic_bezier_x1", "0.42"}, //
	{"cubic_bezier_y1", "0.0"}, //
	{"cubic_bezier_x2", "0.58"}, //
	{"cubic_bezier_y2", "1.0"}, //
	{"max_animation_duration", "0.7s"}, //
	} //
	} //
	};
	scoped_feature_list_.InitWithFeaturesAndParameters(
	/enabled_features=/
	std::move(enabled_features),
	/disabled_features=/{});
	}
	~ScrollOffsetAnimationCurveTestWithProgrammaticOverride() override = default;

	private:
	base::test::ScopedFeatureList scoped_feature_list_;
	};

	TEST_F(ScrollOffsetAnimationCurveTestWithProgrammaticOverride, GetValue) {
	gfx::PointF initial_value(2.f, 40.f);
	gfx::PointF target_value(10.f, 20.f);
	std::unique_ptr<ScrollOffsetAnimationCurve> curve(
	ScrollOffsetAnimationCurveFactory::CreateAnimation(
	target_value, ScrollOffsetAnimationCurve::ScrollType::kProgrammatic));

	curve->SetInitialValue(initial_value);

	base::TimeDelta duration = curve->Duration();
	EXPECT_GT(curve->Duration().InSecondsF(), 0);
	EXPECT_LT(curve->Duration().InSecondsF(), 0.1);

	EXPECT_EQ(duration, curve->Duration());

	EXPECT_POINTF_EQ(initial_value, curve->GetValue(base::Seconds(-1.0)));
	EXPECT_POINTF_EQ(initial_value, curve->GetValue(base::TimeDelta()));
	EXPECT_POINTF_NEAR(gfx::PointF(6.f, 30.f), curve->GetValue(duration * 0.5f),
	0.001f);
	EXPECT_POINTF_EQ(target_value, curve->GetValue(duration));
	EXPECT_POINTF_EQ(target_value,
	curve->GetValue(duration + base::Seconds(1.0)));

	// Verify that GetValue takes the timing function into account.
	gfx::PointF value = curve->GetValue(duration * 0.25f);
	EXPECT_NEAR(3.033f, value.x(), 0.001f);
	EXPECT_NEAR(37.416f, value.y(), 0.001f);
	}

	TEST_F(ScrollOffsetAnimationCurveTestWithProgrammaticOverride,
	MaxAnimationDuration) {
	gfx::PointF initial_value(2.f, 40.f);
	gfx::PointF target_value(200000.f, 400000.f);
	std::unique_ptr<ScrollOffsetAnimationCurve> curve(
	ScrollOffsetAnimationCurveFactory::CreateAnimation(
	target_value, ScrollOffsetAnimationCurve::ScrollType::kProgrammatic));

	curve->SetInitialValue(initial_value);
	EXPECT_EQ(curve->Duration().InSecondsF(), 0.7);
	}

	} // namespace cc