Finish migrating cc/ from WebKit::WebTransformationMatrix to gfx::Transform

webkit/compositor_bindings/web_transformation_matrix_unittest.cc

 // Copyright 2012 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.
 
 #define _USE_MATH_DEFINES
 #include <math.h>
 
-#include "cc/test/geometry_test_utils.h"
 #include "testing/gtest/include/gtest/gtest.h"
 #include "third_party/WebKit/Source/Platform/chromium/public/WebTransformationMatrix.h"
 
 #define EXPECT_ROW1_EQ(a, b, c, d, matrix)      \
     EXPECT_FLOAT_EQ((a), (matrix).m11());       \
     EXPECT_FLOAT_EQ((b), (matrix).m21());       \
     EXPECT_FLOAT_EQ((c), (matrix).m31());       \
     EXPECT_FLOAT_EQ((d), (matrix).m41());
 
 #define EXPECT_ROW2_EQ(a, b, c, d, matrix)      \
     EXPECT_FLOAT_EQ((a), (matrix).m12());       \
     EXPECT_FLOAT_EQ((b), (matrix).m22());       \
     EXPECT_FLOAT_EQ((c), (matrix).m32());       \
     EXPECT_FLOAT_EQ((d), (matrix).m42());
 
 #define EXPECT_ROW3_EQ(a, b, c, d, matrix)      \
     EXPECT_FLOAT_EQ((a), (matrix).m13());       \
     EXPECT_FLOAT_EQ((b), (matrix).m23());       \
     EXPECT_FLOAT_EQ((c), (matrix).m33());       \
     EXPECT_FLOAT_EQ((d), (matrix).m43());
 
 #define EXPECT_ROW4_EQ(a, b, c, d, matrix)      \
     EXPECT_FLOAT_EQ((a), (matrix).m14());       \
     EXPECT_FLOAT_EQ((b), (matrix).m24());       \
     EXPECT_FLOAT_EQ((c), (matrix).m34());       \
     EXPECT_FLOAT_EQ((d), (matrix).m44());
 
+#define EXPECT_WEB_TRANSFORMATION_MATRIX_EQ(expected, actual)        \
+    EXPECT_FLOAT_EQ((expected).m11(), (actual).m11());               \
+    EXPECT_FLOAT_EQ((expected).m12(), (actual).m12());               \
+    EXPECT_FLOAT_EQ((expected).m13(), (actual).m13());               \
+    EXPECT_FLOAT_EQ((expected).m14(), (actual).m14());               \
+    EXPECT_FLOAT_EQ((expected).m21(), (actual).m21());               \
+    EXPECT_FLOAT_EQ((expected).m22(), (actual).m22());               \
+    EXPECT_FLOAT_EQ((expected).m23(), (actual).m23());               \
+    EXPECT_FLOAT_EQ((expected).m24(), (actual).m24());               \
+    EXPECT_FLOAT_EQ((expected).m31(), (actual).m31());               \
+    EXPECT_FLOAT_EQ((expected).m32(), (actual).m32());               \
+    EXPECT_FLOAT_EQ((expected).m33(), (actual).m33());               \
+    EXPECT_FLOAT_EQ((expected).m34(), (actual).m34());               \
+    EXPECT_FLOAT_EQ((expected).m41(), (actual).m41());               \
+    EXPECT_FLOAT_EQ((expected).m42(), (actual).m42());               \
+    EXPECT_FLOAT_EQ((expected).m43(), (actual).m43());               \
+    EXPECT_FLOAT_EQ((expected).m44(), (actual).m44());
+
 // Checking float values for equality close to zero is not robust using EXPECT_FLOAT_EQ
 // (see gtest documentation). So, to verify rotation matrices, we must use a looser
 // absolute error threshold in some places.
 #define EXPECT_ROW1_NEAR(a, b, c, d, matrix, errorThreshold)      \
     EXPECT_NEAR((a), (matrix).m11(), (errorThreshold));           \
     EXPECT_NEAR((b), (matrix).m21(), (errorThreshold));           \
     EXPECT_NEAR((c), (matrix).m31(), (errorThreshold));           \
     EXPECT_NEAR((d), (matrix).m41(), (errorThreshold));
 
 #define EXPECT_ROW2_NEAR(a, b, c, d, matrix, errorThreshold)      \
@@ skipping 941 matching lines @@
 TEST(WebTransformationMatrixTest, verifyBlendForTranslation)
 {
     WebTransformationMatrix from;
     from.translate3d(100, 200, 100);
 
     WebTransformationMatrix to;
 
     to.makeIdentity();
     to.translate3d(200, 100, 300);
     to.blend(from, 0);
-    EXPECT_TRANSFORMATION_MATRIX_EQ(from, to);
+    EXPECT_WEB_TRANSFORMATION_MATRIX_EQ(from, to);
 
     to.makeIdentity();
     to.translate3d(200, 100, 300);
     to.blend(from, 0.25);
     EXPECT_ROW1_EQ(1, 0, 0, 125, to);
     EXPECT_ROW2_EQ(0, 1, 0, 175, to);
     EXPECT_ROW3_EQ(0, 0, 1, 150, to);
     EXPECT_ROW4_EQ(0, 0, 0,  1,  to);
 
     to.makeIdentity();
@@ skipping 16 matching lines @@
 TEST(WebTransformationMatrixTest, verifyBlendForScale)
 {
     WebTransformationMatrix from;
     from.scale3d(100, 200, 100);
 
     WebTransformationMatrix to;
 
     to.makeIdentity();
     to.scale3d(200, 100, 300);
     to.blend(from, 0);
-    EXPECT_TRANSFORMATION_MATRIX_EQ(from, to);
+    EXPECT_WEB_TRANSFORMATION_MATRIX_EQ(from, to);
 
     to.makeIdentity();
     to.scale3d(200, 100, 300);
     to.blend(from, 0.25);
     EXPECT_ROW1_EQ(125, 0,  0,  0, to);
     EXPECT_ROW2_EQ(0,  175, 0,  0, to);
     EXPECT_ROW3_EQ(0,   0, 150, 0, to);
     EXPECT_ROW4_EQ(0,   0,  0,  1, to);
 
     to.makeIdentity();
@@ skipping 16 matching lines @@
 TEST(WebTransformationMatrixTest, verifyBlendForSkewX)
 {
     WebTransformationMatrix from;
     from.skewX(0);
 
     WebTransformationMatrix to;
 
     to.makeIdentity();
     to.skewX(45);
     to.blend(from, 0);
-    EXPECT_TRANSFORMATION_MATRIX_EQ(from, to);
+    EXPECT_WEB_TRANSFORMATION_MATRIX_EQ(from, to);
 
     to.makeIdentity();
     to.skewX(45);
     to.blend(from, 0.5);
     EXPECT_ROW1_EQ(1, 0.5, 0, 0, to);
     EXPECT_ROW2_EQ(0,  1,  0, 0, to);
     EXPECT_ROW3_EQ(0,  0,  1, 0, to);
     EXPECT_ROW4_EQ(0,  0,  0, 1, to);
 
     to.makeIdentity();
@@ skipping 28 matching lines @@
     // implementation just happens to decompose those test matrices intuitively.
 
     WebTransformationMatrix from;
     from.skewY(0);
 
     WebTransformationMatrix to;
 
     to.makeIdentity();
     to.skewY(45);
     to.blend(from, 0);
-    EXPECT_TRANSFORMATION_MATRIX_EQ(from, to);
+    EXPECT_WEB_TRANSFORMATION_MATRIX_EQ(from, to);
 
     to.makeIdentity();
     to.skewY(45);
     to.blend(from, 0.25);
     EXPECT_ROW1_NEAR(1.0823489449280947471976333, 0.0464370719145053845178239, 0, 0, to, LOOSE_ERROR_THRESHOLD);
     EXPECT_ROW2_NEAR(0.2152925909665224513123150, 0.9541702441750861130032035, 0, 0, to, LOOSE_ERROR_THRESHOLD);
     EXPECT_ROW3_EQ(0, 0, 1, 0, to);
     EXPECT_ROW4_EQ(0, 0, 0, 1, to);
 
     to.makeIdentity();
@@ skipping 21 matching lines @@
     // against manually specified matrices from Euler angles.
 
     WebTransformationMatrix from;
     from.rotate3d(1, 0, 0, 0);
 
     WebTransformationMatrix to;
 
     to.makeIdentity();
     to.rotate3d(1, 0, 0, 90);
     to.blend(from, 0);
-    EXPECT_TRANSFORMATION_MATRIX_EQ(from, to);
+    EXPECT_WEB_TRANSFORMATION_MATRIX_EQ(from, to);
 
     double expectedRotationAngle = 22.5 * M_PI / 180.0;
     to.makeIdentity();
     to.rotate3d(1, 0, 0, 90);
     to.blend(from, 0.25);
     EXPECT_ROW1_NEAR(1, 0, 0, 0, to, ERROR_THRESHOLD);
     EXPECT_ROW2_NEAR(0, cos(expectedRotationAngle), -sin(expectedRotationAngle), 0, to, ERROR_THRESHOLD);
     EXPECT_ROW3_NEAR(0, sin(expectedRotationAngle),  cos(expectedRotationAngle), 0, to, ERROR_THRESHOLD);
     EXPECT_ROW4_EQ(0, 0, 0, 1, to);
 
@@ skipping 18 matching lines @@
 TEST(WebTransformationMatrixTest, verifyBlendForRotationAboutY)
 {
     WebTransformationMatrix from;
     from.rotate3d(0, 1, 0, 0);
 
     WebTransformationMatrix to;
 
     to.makeIdentity();
     to.rotate3d(0, 1, 0, 90);
     to.blend(from, 0);
-    EXPECT_TRANSFORMATION_MATRIX_EQ(from, to);
+    EXPECT_WEB_TRANSFORMATION_MATRIX_EQ(from, to);
 
     double expectedRotationAngle = 22.5 * M_PI / 180.0;
     to.makeIdentity();
     to.rotate3d(0, 1, 0, 90);
     to.blend(from, 0.25);
     EXPECT_ROW1_NEAR(cos(expectedRotationAngle),  0, sin(expectedRotationAngle), 0, to, ERROR_THRESHOLD);
     EXPECT_ROW2_NEAR(0, 1, 0, 0, to, ERROR_THRESHOLD);
     EXPECT_ROW3_NEAR(-sin(expectedRotationAngle), 0, cos(expectedRotationAngle), 0, to, ERROR_THRESHOLD);
     EXPECT_ROW4_EQ(0, 0, 0, 1, to);
 
@@ skipping 18 matching lines @@
 TEST(WebTransformationMatrixTest, verifyBlendForRotationAboutZ)
 {
     WebTransformationMatrix from;
     from.rotate3d(0, 0, 1, 0);
 
     WebTransformationMatrix to;
 
     to.makeIdentity();
     to.rotate3d(0, 0, 1, 90);
     to.blend(from, 0);
-    EXPECT_TRANSFORMATION_MATRIX_EQ(from, to);
+    EXPECT_WEB_TRANSFORMATION_MATRIX_EQ(from, to);
 
     double expectedRotationAngle = 22.5 * M_PI / 180.0;
     to.makeIdentity();
     to.rotate3d(0, 0, 1, 90);
     to.blend(from, 0.25);
     EXPECT_ROW1_NEAR(cos(expectedRotationAngle), -sin(expectedRotationAngle), 0, 0, to, ERROR_THRESHOLD);
     EXPECT_ROW2_NEAR(sin(expectedRotationAngle),  cos(expectedRotationAngle), 0, 0, to, ERROR_THRESHOLD);
     EXPECT_ROW3_NEAR(0, 0, 1, 0, to, ERROR_THRESHOLD);
     EXPECT_ROW4_EQ(0, 0, 0, 1, to);
 
@@ skipping 32 matching lines @@
 
     WebTransformationMatrix expectedEndOfAnimation;
     expectedEndOfAnimation.applyPerspective(1);
     expectedEndOfAnimation.translate3d(10, 20, 30);
     expectedEndOfAnimation.rotate3d(0, 0, 1, 25);
     expectedEndOfAnimation.skewY(45);
     expectedEndOfAnimation.scale3d(6, 7, 8);
     
     to = expectedEndOfAnimation;
     to.blend(from, 0);
-    EXPECT_TRANSFORMATION_MATRIX_EQ(from, to);
+    EXPECT_WEB_TRANSFORMATION_MATRIX_EQ(from, to);
 
     to = expectedEndOfAnimation;
     to.blend(from, 1);
 
     // Recomposing the matrix results in a normalized matrix, so to verify we need to
     // normalize the expectedEndOfAnimation before comparing elements. Normalizing means
     // dividing everything by expectedEndOfAnimation.m44().
     WebTransformationMatrix normalizedExpectedEndOfAnimation = expectedEndOfAnimation;
     WebTransformationMatrix normalizationMatrix;
     normalizationMatrix.setM11(1 / expectedEndOfAnimation.m44());
     normalizationMatrix.setM22(1 / expectedEndOfAnimation.m44());
     normalizationMatrix.setM33(1 / expectedEndOfAnimation.m44());
     normalizationMatrix.setM44(1 / expectedEndOfAnimation.m44());
     normalizedExpectedEndOfAnimation.multiply(normalizationMatrix);
 
-    EXPECT_TRANSFORMATION_MATRIX_EQ(normalizedExpectedEndOfAnimation, to);
+    EXPECT_WEB_TRANSFORMATION_MATRIX_EQ(normalizedExpectedEndOfAnimation, to);
 }
 
 } // namespace