Interpolated rotations should end cleanly where possible.

ui/gfx/interpolated_transform_unittest.cc

 // Copyright (c) 2011 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 "ui/gfx/interpolated_transform.h"
 
 #include "base/basictypes.h"
 #include "testing/gtest/include/gtest/gtest.h"
+#include "ui/gfx/rect.h"
 
 namespace {
 
 void CheckApproximatelyEqual(const ui::Transform& lhs,
                              const ui::Transform& rhs) {
   for (int i = 0; i < 4; ++i) {
     for (int j = 0; j < 4; ++j) {
       EXPECT_FLOAT_EQ(lhs.matrix().get(i, j), rhs.matrix().get(i, j));
     }
   }
 }
 
 float NormalizeAngle(float angle) {
   while (angle < 0.0f) {
     angle += 360.0f;
   }
   while (angle > 360.0f) {
     angle -= 360.0f;
   }
   return angle;
 }
 
+const float EPSILON = 1e-6;
+
+// Ensures all entries are either 0, 1, or -1
+void MassageRotationMatrix(ui::Transform* transform) {
+  SkMatrix44& m = transform->matrix();
+  for (int i = 0; i < 3; ++i) {
+    for (int j = 0; j < 3; ++j) {
+      float entry = m.get(i, j);
+      if (fabs(entry) < EPSILON)
+        entry = 0;
+      else if (fabs(entry + 1) < EPSILON)
+        entry = -1;
+      else if (fabs(entry - 1) < EPSILON)
+        entry = 1;
+      m.set(i, j, entry);
+    }
+  }
+}
+
 } // namespace
 
 TEST(InterpolatedTransformTest, InterpolatedRotation) {
   ui::InterpolatedRotation interpolated_rotation(0, 100);
   ui::InterpolatedRotation interpolated_rotation_diff_start_end(
       0, 100, 100, 200);
 
   for (int i = 0; i <= 100; ++i) {
     ui::Transform rotation;
     rotation.SetRotate(i);
+
+    // If we're a multiple of 90 degrees, we must ensure that our matrix is
+    // 'clean' -- that is, that its entries are all 0, 1 or -1.
+    if (i % 90 == 0)
+      MassageRotationMatrix(&rotation);
+
     ui::Transform interpolated = interpolated_rotation.Interpolate(i / 100.0f);
     CheckApproximatelyEqual(rotation, interpolated);
     interpolated = interpolated_rotation_diff_start_end.Interpolate(i + 100);
     CheckApproximatelyEqual(rotation, interpolated);
   }
 }
 
 TEST(InterpolatedTransformTest, InterpolatedScale) {
   ui::InterpolatedScale interpolated_scale(gfx::Point3f(0, 0, 0),
                                            gfx::Point3f(100, 100, 100));
@@ skipping 79 matching lines @@
                                                         &rotation,
                                                         &scale);
     EXPECT_TRUE(success);
     EXPECT_FLOAT_EQ(translation.x(), degrees * 2);
     EXPECT_FLOAT_EQ(translation.y(), -degrees * 3);
     EXPECT_FLOAT_EQ(NormalizeAngle(rotation), degrees);
     EXPECT_FLOAT_EQ(scale.x(), degrees + 1);
     EXPECT_FLOAT_EQ(scale.y(), 2 * degrees + 1);
   }
 }
+
+ui::InterpolatedTransform* GetScreenRotation(int degrees, bool reversed) {
+  gfx::Point old_pivot;
+  gfx::Point new_pivot;
+
+  int width = 1920;
+  int height = 180;
+
+  switch (degrees) {
+    case 90:
+      new_pivot = gfx::Point(width, 0);
+      break;
+    case -90:
+      new_pivot = gfx::Point(0, height);
+      break;
+    case 180:
+    case 360:
+      new_pivot = old_pivot = gfx::Point(width / 2, height / 2);
+      break;
+  }
+
+  scoped_ptr<ui::InterpolatedTransform> rotation(
+      new ui::InterpolatedTransformAboutPivot(
+          old_pivot,
+          new ui::InterpolatedRotation(reversed ? degrees : 0,
+                                       reversed ? 0 : degrees)));
+
+  scoped_ptr<ui::InterpolatedTransform> translation(
+      new ui::InterpolatedTranslation(
+          gfx::Point(0, 0),
+          gfx::Point(new_pivot.x() - old_pivot.x(),
+                     new_pivot.y() - old_pivot.y())));
+
+  float scale_factor = 0.9f;
+  scoped_ptr<ui::InterpolatedTransform> scale_down(
+      new ui::InterpolatedScale(1.0f, scale_factor, 0.0f, 0.5f));
+
+  scoped_ptr<ui::InterpolatedTransform> scale_up(
+      new ui::InterpolatedScale(1.0f, 1.0f / scale_factor, 0.5f, 1.0f));
+
+  scoped_ptr<ui::InterpolatedTransform> to_return(
+      new ui::InterpolatedConstantTransform(ui::Transform()));
+
+  scale_up->SetChild(scale_down.release());
+  translation->SetChild(scale_up.release());
+  rotation->SetChild(translation.release());
+  to_return->SetChild(rotation.release());
+  to_return->SetReversed(reversed);
+
+  return to_return.release();
+}
+
+TEST(InterpolatedTransformTest, ScreenRotationEndsCleanly) {
+  for (int i = 0; i < 2; ++i) {
+    for (int degrees = -360; degrees <= 360; degrees += 90) {
+      const bool reversed = i == 1;
+      scoped_ptr<ui::InterpolatedTransform> screen_rotation(
+          GetScreenRotation(degrees, reversed));
+      ui::Transform interpolated = screen_rotation->Interpolate(1.0f);
+      SkMatrix44& m = interpolated.matrix();
+      // Upper-left 3x3 matrix should all be 0, 1 or -1.
+      for (int row = 0; row < 3; ++row) {
+        for (int col = 0; col < 3; ++col) {
+          float entry = m.get(row, col);
+          EXPECT_TRUE(entry == 0 || entry == 1 || entry == -1);
+        }
+      }
+    }
+  }
+}
+
+ui::InterpolatedTransform* GetMaximize() {
+  gfx::Rect target_bounds(0, 0, 1920, 1080);
+  gfx::Rect initial_bounds(30, 1000, 192, 108);
+
+  float scale_x = static_cast<float>(
+      target_bounds.height()) / initial_bounds.width();
+  float scale_y = static_cast<float>(
+      target_bounds.width()) / initial_bounds.height();
+
+  scoped_ptr<ui::InterpolatedTransform> scale(
+      new ui::InterpolatedScale(gfx::Point3f(1, 1, 1),
+                                gfx::Point3f(scale_x, scale_y, 1)));
+
+  scoped_ptr<ui::InterpolatedTransform> translation(
+      new ui::InterpolatedTranslation(
+          gfx::Point(),
+          gfx::Point(target_bounds.x() - initial_bounds.x(),
+                     target_bounds.y() - initial_bounds.y())));
+
+  scoped_ptr<ui::InterpolatedTransform> rotation(
+      new ui::InterpolatedRotation(0, 4.0f));
+
+  scoped_ptr<ui::InterpolatedTransform> rotation_about_pivot(
+      new ui::InterpolatedTransformAboutPivot(
+          gfx::Point(initial_bounds.width() * 0.5,
+                     initial_bounds.height() * 0.5),
+          rotation.release()));
+
+  scale->SetChild(translation.release());
+  rotation_about_pivot->SetChild(scale.release());
+
+  rotation_about_pivot->SetReversed(true);
+
+  return rotation_about_pivot.release();
+}
+
+TEST(InterpolatedTransformTest, MaximizeEndsCleanly) {
+  scoped_ptr<ui::InterpolatedTransform> maximize(GetMaximize());
+  ui::Transform interpolated = maximize->Interpolate(1.0f);
+  SkMatrix44& m = interpolated.matrix();
+  // Upper-left 3x3 matrix should all be 0, 1 or -1.
+  for (int row = 0; row < 3; ++row) {
+    for (int col = 0; col < 3; ++col) {
+      float entry = m.get(row, col);
+      EXPECT_TRUE(entry == 0 || entry == 1 || entry == -1);
+    }
+  }
+}
+