Implement ui::TransformAnimationCurveAdapter::MaximumScale()

This ensures that cc will rasterize the animating layer at the maximum
scale, to avoid
1. blurriness during scaling-up animations (e.g. scale 1 -> 3),
2. too big raster scale (wasting memory) during small scale animations
(e.g. scale 0.1 -> 0.3).

Previously in the above cases, in simple cases (without ancestor
scales), scale 1 for the layer was used for raterization because
ui::TransformAnimationCurveAdapter failed to provide the maximum scale
of animations.

Also remove unused ui::InverseTransformCurveAdapter.

Bug: 1161586
Change-Id: Ieb876bc271c98627bd61370c93e806b44be0b868
Reviewed-on: https://chromium-review.googlesource.com/c/chromium/src/+/2605242
Commit-Queue: Xianzhu Wang <wangxianzhu@chromium.org>
Reviewed-by: Robert Flack <flackr@chromium.org>
Cr-Commit-Position: refs/heads/master@{#844659}

ui/compositor/transform_animation_curve_adapter.cc

@@ -5,6 +5,7 @@
 #include "ui/compositor/transform_animation_curve_adapter.h"
 
 #include "base/memory/ptr_util.h"
+#include "cc/base/math_util.h"
 
 namespace ui {
 
@@ -69,58 +70,16 @@ bool TransformAnimationCurveAdapter::PreservesAxisAlignment() const {
 }
 
 bool TransformAnimationCurveAdapter::MaximumScale(float* max_scale) const {
-  return false;
-}
-
-InverseTransformCurveAdapter::InverseTransformCurveAdapter(
-    TransformAnimationCurveAdapter base_curve,
-    gfx::Transform initial_value,
-    base::TimeDelta duration)
-    : base_curve_(base_curve),
-      initial_value_(initial_value),
-      initial_wrapped_value_(WrapTransform(initial_value)),
-      duration_(duration) {
-  effective_initial_value_ =
-      base_curve_.GetValue(base::TimeDelta()).Apply() * initial_value_;
-}
-
-InverseTransformCurveAdapter::~InverseTransformCurveAdapter() {
-}
-
-base::TimeDelta InverseTransformCurveAdapter::Duration() const {
-  return duration_;
-}
-
-std::unique_ptr<cc::AnimationCurve> InverseTransformCurveAdapter::Clone()
-    const {
-  return base::WrapUnique(
-      new InverseTransformCurveAdapter(base_curve_, initial_value_, duration_));
-}
-
-cc::TransformOperations InverseTransformCurveAdapter::GetValue(
-    base::TimeDelta t) const {
-  if (t <= base::TimeDelta())
-    return initial_wrapped_value_;
-
-  gfx::Transform base_transform = base_curve_.GetValue(t).Apply();
-  // Invert base
-  gfx::Transform to_return(gfx::Transform::kSkipInitialization);
-  bool is_invertible = base_transform.GetInverse(&to_return);
-  DCHECK(is_invertible);
-
-  to_return.PreconcatTransform(effective_initial_value_);
-
-  return WrapTransform(to_return);
-}
-
-bool InverseTransformCurveAdapter::PreservesAxisAlignment() const {
-  return (initial_value_.IsIdentity() ||
-          initial_value_.IsScaleOrTranslation()) &&
-         (base_curve_.PreservesAxisAlignment());
-}
-
-bool InverseTransformCurveAdapter::MaximumScale(float* max_scale) const {
-  return false;
+  constexpr float kInvalidScale = 0.f;
+  gfx::Vector2dF initial_scales =
+      cc::MathUtil::ComputeTransform2dScaleComponents(initial_value_,
+                                                      kInvalidScale);
+  gfx::Vector2dF target_scales =
+      cc::MathUtil::ComputeTransform2dScaleComponents(target_value_,
+                                                      kInvalidScale);
+  *max_scale = std::max({initial_scales.x(), initial_scales.y(),
+                         target_scales.x(), target_scales.y()});
+  return *max_scale != kInvalidScale;
 }
 
 }  // namespace ui

ui/compositor/transform_animation_curve_adapter.h

@@ -50,31 +50,6 @@ class COMPOSITOR_EXPORT TransformAnimationCurveAdapter
   DISALLOW_ASSIGN(TransformAnimationCurveAdapter);
 };
 
-class COMPOSITOR_EXPORT InverseTransformCurveAdapter
-    : public cc::TransformAnimationCurve {
- public:
-  InverseTransformCurveAdapter(TransformAnimationCurveAdapter base_curve,
-                               gfx::Transform initial_value,
-                               base::TimeDelta duration);
-
-  ~InverseTransformCurveAdapter() override;
-
-  base::TimeDelta Duration() const override;
-  std::unique_ptr<AnimationCurve> Clone() const override;
-  cc::TransformOperations GetValue(base::TimeDelta t) const override;
-  bool PreservesAxisAlignment() const override;
-  bool MaximumScale(float* max_scale) const override;
-
- private:
-  TransformAnimationCurveAdapter base_curve_;
-  gfx::Transform initial_value_;
-  cc::TransformOperations initial_wrapped_value_;
-  gfx::Transform effective_initial_value_;
-  base::TimeDelta duration_;
-
-  DISALLOW_ASSIGN(InverseTransformCurveAdapter);
-};
-
 }  // namespace ui
 
 #endif  // UI_COMPOSITOR_TRANSFORM_ANIMATION_CURVE_ADAPTER_H_

ui/compositor/transform_animation_curve_adapter_unittest.cc

@@ -4,52 +4,58 @@
 
 #include "ui/compositor/transform_animation_curve_adapter.h"
 
-#include <sstream>
-
 #include "base/time/time.h"
 #include "testing/gtest/include/gtest/gtest.h"
-#include "ui/compositor/test/test_utils.h"
 
 namespace ui {
 
 namespace {
 
-// Check that the inverse transform curve gives the gives a transform that when
-// applied on top of the parent transform gives the original transform
-TEST(InverseTransformCurveAdapterTest, InversesTransform) {
-  gfx::Transform parent_start, parent_target;
-  parent_start.Scale(0.5, 3.0);
-  parent_start.Translate(-20.0, 30.0);
-  parent_target.Translate(0, 100);
-
-  gfx::Transform child_transform;
-  child_transform.Rotate(-30.0);
-
-  base::TimeDelta duration = base::TimeDelta::FromSeconds(1);
-
-  const gfx::Transform effective_child_transform =
-      parent_start * child_transform;
-
-  TransformAnimationCurveAdapter parent_curve(gfx::Tween::LINEAR, parent_start,
-                                              parent_target, duration);
-
-  InverseTransformCurveAdapter child_curve(parent_curve, child_transform,
-                                           duration);
-  static const int kSteps = 1000;
-  double step = 1.0 / kSteps;
-  for (int i = 0; i <= kSteps; ++i) {
-    base::TimeDelta time_step = duration * (i * step);
-    std::ostringstream message;
-    message << "Step " << i << " of " << kSteps;
-    SCOPED_TRACE(message.str());
-    gfx::Transform progress_parent_transform =
-        parent_curve.GetValue(time_step).Apply();
-    gfx::Transform progress_child_transform =
-        child_curve.GetValue(time_step).Apply();
-    CheckApproximatelyEqual(
-        effective_child_transform,
-        progress_parent_transform * progress_child_transform);
-  }
+TEST(TransformAnimationCurveAdapterTest, MaximumAnimationScale) {
+  auto duration = base::TimeDelta::FromSeconds(1);
+  float kArbitraryScale = 123.f;
+  float scale = kArbitraryScale;
+  EXPECT_TRUE(TransformAnimationCurveAdapter(gfx::Tween::LINEAR,
+                                             gfx::Transform(), gfx::Transform(),
+                                             duration)
+                  .MaximumScale(&scale));
+  EXPECT_EQ(1.0f, scale);
+
+  gfx::Transform initial;
+  gfx::Transform target;
+  initial.Scale(1.0f, 2.0f);
+  target.Scale(3.0f, 4.0f);
+  scale = kArbitraryScale;
+  EXPECT_TRUE(TransformAnimationCurveAdapter(gfx::Tween::LINEAR, initial,
+                                             target, duration)
+                  .MaximumScale(&scale));
+  EXPECT_EQ(4.0f, scale);
+
+  scale = kArbitraryScale;
+  EXPECT_TRUE(TransformAnimationCurveAdapter(gfx::Tween::LINEAR, target,
+                                             initial, duration)
+                  .MaximumScale(&scale));
+  EXPECT_EQ(4.0f, scale);
+
+  target.ApplyPerspectiveDepth(2.0f);
+  scale = kArbitraryScale;
+  EXPECT_TRUE(TransformAnimationCurveAdapter(gfx::Tween::LINEAR, initial,
+                                             target, duration)
+                  .MaximumScale(&scale));
+  EXPECT_EQ(2.0f, scale);
+  scale = kArbitraryScale;
+  EXPECT_TRUE(TransformAnimationCurveAdapter(gfx::Tween::LINEAR, target,
+                                             initial, duration)
+                  .MaximumScale(&scale));
+  EXPECT_EQ(2.0f, scale);
+
+  initial.ApplyPerspectiveDepth(3.0f);
+  EXPECT_FALSE(TransformAnimationCurveAdapter(gfx::Tween::LINEAR, initial,
+                                              target, duration)
+                   .MaximumScale(&scale));
+  EXPECT_FALSE(TransformAnimationCurveAdapter(gfx::Tween::LINEAR, target,
+                                              initial, duration)
+                   .MaximumScale(&scale));
 }
 
 }  // namespace