Migrate more functions from MathUtil to gfx::Transform

cc/layer_tree_host_common_unittest.cc

 // Copyright 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 "cc/layer_tree_host_common.h"
 
 #include "cc/content_layer.h"
 #include "cc/content_layer_client.h"
 #include "cc/layer.h"
 #include "cc/layer_animation_controller.h"
@@ skipping 300 matching lines @@
     //         scaling is used here again so that the correct sequence of transforms is properly tested.
     //         Note that preserves3D is false, but the sublayer matrix should retain its 3D properties when given to child.
     //         But then, the child also does not preserve3D. When it gives its hierarchy to the grandChild, it should be flattened to 2D.
     gfx::Transform parentSublayerMatrix;
     parentSublayerMatrix.Scale3d(10, 10, 3.3);
     gfx::Transform parentTranslationToCenter;
     parentTranslationToCenter.Translate(5, 6);
     // Sublayer matrix is applied to the center of the parent layer.
     parentCompositeTransform = parentTranslationToAnchor * parentLayerTransform * inverse(parentTranslationToAnchor)
             * parentTranslationToCenter * parentSublayerMatrix * inverse(parentTranslationToCenter);
-    gfx::Transform flattenedCompositeTransform = MathUtil::to2dTransform(parentCompositeTransform);
+    gfx::Transform flattenedCompositeTransform = parentCompositeTransform;
+    flattenedCompositeTransform.FlattenTo2d();
     setLayerPropertiesForTesting(parent.get(), parentLayerTransform, parentSublayerMatrix, gfx::PointF(0.25, 0.25), gfx::PointF(0, 0), gfx::Size(10, 12), false);
     setLayerPropertiesForTesting(child.get(), identityMatrix, identityMatrix, gfx::PointF(0, 0), gfx::PointF(0, 0), gfx::Size(16, 18), false);
     setLayerPropertiesForTesting(grandChild.get(), identityMatrix, identityMatrix, gfx::PointF(0, 0), gfx::PointF(0, 0), gfx::Size(76, 78), false);
     executeCalculateDrawProperties(root.get());
     EXPECT_TRANSFORMATION_MATRIX_EQ(parentCompositeTransform, child->drawTransform());
     EXPECT_TRANSFORMATION_MATRIX_EQ(parentCompositeTransform, child->screenSpaceTransform());
     EXPECT_TRANSFORMATION_MATRIX_EQ(flattenedCompositeTransform, grandChild->drawTransform());
     EXPECT_TRANSFORMATION_MATRIX_EQ(flattenedCompositeTransform, grandChild->screenSpaceTransform());
 
     // Case 5: same as Case 4, except that child does preserve 3D, so the grandChild should receive the non-flattened composite transform.
@@ skipping 394 matching lines @@
     // For layers that flatten their subtree, there should be an orthographic projection
     // (for x and y values) in the middle of the transform sequence. Note that the way the
     // code is currently implemented, it is not expected to use a canonical orthographic
     // projection.
 
     scoped_refptr<Layer> root = Layer::create();
     scoped_refptr<Layer> child = Layer::create();
     scoped_refptr<LayerWithForcedDrawsContent> grandChild = make_scoped_refptr(new LayerWithForcedDrawsContent());
 
     gfx::Transform rotationAboutYAxis;
-    MathUtil::rotateEulerAngles(&rotationAboutYAxis, 0, 30, 0);
+    rotationAboutYAxis.RotateAboutYAxis(30);
 
     const gfx::Transform identityMatrix;
     setLayerPropertiesForTesting(root.get(), identityMatrix, identityMatrix, gfx::PointF(), gfx::PointF(), gfx::Size(100, 100), false);
     setLayerPropertiesForTesting(child.get(), rotationAboutYAxis, identityMatrix, gfx::PointF(), gfx::PointF(), gfx::Size(10, 10), false);
     setLayerPropertiesForTesting(grandChild.get(), rotationAboutYAxis, identityMatrix, gfx::PointF(), gfx::PointF(), gfx::Size(10, 10), false);
 
     root->addChild(child);
     child->addChild(grandChild);
     child->setForceRenderSurface(true);
 
     // No layers in this test should preserve 3d.
     ASSERT_FALSE(root->preserves3D());
     ASSERT_FALSE(child->preserves3D());
     ASSERT_FALSE(grandChild->preserves3D());
 
     gfx::Transform expectedChildDrawTransform = rotationAboutYAxis;
     gfx::Transform expectedChildScreenSpaceTransform = rotationAboutYAxis;
     gfx::Transform expectedGrandChildDrawTransform = rotationAboutYAxis; // draws onto child's renderSurface
-    gfx::Transform expectedGrandChildScreenSpaceTransform = MathUtil::to2dTransform(rotationAboutYAxis) * rotationAboutYAxis;
+    gfx::Transform flattenedRotationAboutY = rotationAboutYAxis;
+    flattenedRotationAboutY.FlattenTo2d();
+    gfx::Transform expectedGrandChildScreenSpaceTransform = flattenedRotationAboutY * rotationAboutYAxis;
 
     executeCalculateDrawProperties(root.get());
 
     // The child's drawTransform should have been taken by its surface.
     ASSERT_TRUE(child->renderSurface());
     EXPECT_TRANSFORMATION_MATRIX_EQ(expectedChildDrawTransform, child->renderSurface()->drawTransform());
     EXPECT_TRANSFORMATION_MATRIX_EQ(expectedChildScreenSpaceTransform, child->renderSurface()->screenSpaceTransform());
     EXPECT_TRANSFORMATION_MATRIX_EQ(identityMatrix, child->drawTransform());
     EXPECT_TRANSFORMATION_MATRIX_EQ(expectedChildScreenSpaceTransform, child->screenSpaceTransform());
     EXPECT_TRANSFORMATION_MATRIX_EQ(expectedGrandChildDrawTransform, grandChild->drawTransform());
@@ skipping 255 matching lines @@
     // is NOT the direct parent of the fixed-position layer, and the hierarchy has various
     // transforms that have to be processed in the correct order.
     FakeImplProxy proxy;
     FakeLayerTreeHostImpl hostImpl(&proxy);
     scoped_ptr<LayerImpl> root = createTreeForFixedPositionTests(&hostImpl);
     LayerImpl* child = root->children()[0];
     LayerImpl* grandChild = child->children()[0];
     LayerImpl* greatGrandChild = grandChild->children()[0];
 
     gfx::Transform rotationAboutZ;
-    MathUtil::rotateEulerAngles(&rotationAboutZ, 0, 0, 90);
+    rotationAboutZ.RotateAboutZAxis(90);
 
     child->setIsContainerForFixedPositionLayers(true);
     child->setTransform(rotationAboutZ);
     grandChild->setPosition(gfx::PointF(8, 6));
     grandChild->setTransform(rotationAboutZ);
     greatGrandChild->setFixedToContainerLayer(true); // greatGrandChild is positioned upside-down with respect to the renderTarget.
 
     // Case 1: scrollDelta of 0, 0
     child->setScrollDelta(gfx::Vector2d(0, 0));
     executeCalculateDrawProperties(root.get());
@@ skipping 41 matching lines @@
     // is NOT the direct parent of the fixed-position layer, and the hierarchy has various
     // transforms that have to be processed in the correct order.
     FakeImplProxy proxy;
     FakeLayerTreeHostImpl hostImpl(&proxy);
     scoped_ptr<LayerImpl> root = createTreeForFixedPositionTests(&hostImpl);
     LayerImpl* child = root->children()[0];
     LayerImpl* grandChild = child->children()[0];
     LayerImpl* greatGrandChild = grandChild->children()[0];
 
     gfx::Transform rotationAboutZ;
-    MathUtil::rotateEulerAngles(&rotationAboutZ, 0, 0, 90);
+    rotationAboutZ.RotateAboutZAxis(90);
 
     child->setIsContainerForFixedPositionLayers(true);
     child->setTransform(rotationAboutZ);
     grandChild->setPosition(gfx::PointF(8, 6));
     grandChild->setTransform(rotationAboutZ);
     greatGrandChild->setFixedToContainerLayer(true); // greatGrandChild is positioned upside-down with respect to the renderTarget.
 
     // Case 1: scrollDelta of 0, 0
     child->setScrollDelta(gfx::Vector2d(0, 0));
     executeCalculateDrawProperties(root.get());
@@ skipping 47 matching lines @@
     LayerImpl* grandChild = child->children()[0];
     LayerImpl* greatGrandChild = grandChild->children()[0];
 
     child->setIsContainerForFixedPositionLayers(true);
     grandChild->setPosition(gfx::PointF(8, 6));
     grandChild->setForceRenderSurface(true);
     greatGrandChild->setFixedToContainerLayer(true);
     greatGrandChild->setDrawsContent(true);
 
     gfx::Transform rotationAboutZ;
-    MathUtil::rotateEulerAngles(&rotationAboutZ, 0, 0, 90);
+    rotationAboutZ.RotateAboutZAxis(90);
     grandChild->setTransform(rotationAboutZ);
 
     // Case 1: scrollDelta of 0, 0
     child->setScrollDelta(gfx::Vector2d(0, 0));
     executeCalculateDrawProperties(root.get());
 
     gfx::Transform expectedChildTransform;
     gfx::Transform expectedSurfaceDrawTransform;
     expectedSurfaceDrawTransform.Translate(8, 6);
     expectedSurfaceDrawTransform.PreconcatTransform(rotationAboutZ);
@@ skipping 69 matching lines @@
     greatGrandChild->setForceRenderSurface(true);
     fixedPositionChild->setFixedToContainerLayer(true);
     fixedPositionChild->setDrawsContent(true);
 
     // The additional rotations, which are non-commutative with translations, help to
     // verify that we have correct order-of-operations in the final scroll compensation.
     // Note that rotating about the center of the layer ensures we do not accidentally
     // clip away layers that we want to test.
     gfx::Transform rotationAboutZ;
     rotationAboutZ.Translate(50, 50);
-    MathUtil::rotateEulerAngles(&rotationAboutZ, 0, 0, 90);
+    rotationAboutZ.RotateAboutZAxis(90);
     rotationAboutZ.Translate(-50, -50);
     grandChild->setTransform(rotationAboutZ);
     greatGrandChild->setTransform(rotationAboutZ);
 
     // Case 1: scrollDelta of 0, 0
     child->setScrollDelta(gfx::Vector2d(0, 0));
     executeCalculateDrawProperties(root.get());
 
     gfx::Transform expectedChildTransform;
 
@@ skipping 150 matching lines @@
     // This test checks scroll compensation when a fixed-position layer does not find any
     // ancestor that is a "containerForFixedPositionLayers". In this situation, the layer should
     // be fixed to the viewport -- not the rootLayer, which may have transforms of its own.
     FakeImplProxy proxy;
     FakeLayerTreeHostImpl hostImpl(&proxy);
     scoped_ptr<LayerImpl> root = createTreeForFixedPositionTests(&hostImpl);
     LayerImpl* child = root->children()[0];
     LayerImpl* grandChild = child->children()[0];
 
     gfx::Transform rotationByZ;
-    MathUtil::rotateEulerAngles(&rotationByZ, 0, 0, 90);
+    rotationByZ.RotateAboutZAxis(90);
 
     root->setTransform(rotationByZ);
     grandChild->setFixedToContainerLayer(true);
 
     // Case 1: root scrollDelta of 0, 0
     root->setScrollDelta(gfx::Vector2d(0, 0));
     executeCalculateDrawProperties(root.get());
 
     gfx::Transform identityMatrix;
 
@@ skipping 606 matching lines @@
 TEST(LayerTreeHostCommonTest, verifyVisibleRectFor3dOrthographicTransform)
 {
     // Test that the calculateVisibleRect() function works correctly for 3d transforms.
 
     gfx::Rect targetSurfaceRect = gfx::Rect(gfx::Point(0, 0), gfx::Size(100, 100));
     gfx::Rect layerContentRect = gfx::Rect(gfx::Point(0, 0), gfx::Size(100, 100));
     gfx::Transform layerToSurfaceTransform;
 
     // Case 1: Orthographic projection of a layer rotated about y-axis by 45 degrees, should be fully contained in the renderSurface.
     layerToSurfaceTransform.MakeIdentity();
-    MathUtil::rotateEulerAngles(&layerToSurfaceTransform, 0, 45, 0);
+    layerToSurfaceTransform.RotateAboutYAxis(45);
     gfx::Rect expected = gfx::Rect(gfx::Point(0, 0), gfx::Size(100, 100));
     gfx::Rect actual = LayerTreeHostCommon::calculateVisibleRect(targetSurfaceRect, layerContentRect, layerToSurfaceTransform);
     EXPECT_RECT_EQ(expected, actual);
 
     // Case 2: Orthographic projection of a layer rotated about y-axis by 45 degrees, but
     //         shifted to the side so only the right-half the layer would be visible on
     //         the surface.
     double halfWidthOfRotatedLayer = (100 / sqrt(2.0)) * 0.5; // 100 is the un-rotated layer width; divided by sqrt(2) is the rotated width.
     layerToSurfaceTransform.MakeIdentity();
     layerToSurfaceTransform.Translate(-halfWidthOfRotatedLayer, 0);
-    MathUtil::rotateEulerAngles(&layerToSurfaceTransform, 0, 45, 0); // rotates about the left edge of the layer
+    layerToSurfaceTransform.RotateAboutYAxis(45); // rotates about the left edge of the layer
     expected = gfx::Rect(gfx::Point(50, 0), gfx::Size(50, 100)); // right half of the layer.
     actual = LayerTreeHostCommon::calculateVisibleRect(targetSurfaceRect, layerContentRect, layerToSurfaceTransform);
     EXPECT_RECT_EQ(expected, actual);
 }
 
 TEST(LayerTreeHostCommonTest, verifyVisibleRectFor3dPerspectiveTransform)
 {
     // Test the calculateVisibleRect() function works correctly when the layer has a
     // perspective projection onto the target surface.
 
@@ skipping 40 matching lines @@
     // flattened to the surface.
 
     gfx::Rect targetSurfaceRect = gfx::Rect(gfx::Point(0, 0), gfx::Size(100, 100));
     gfx::Rect layerContentRect = gfx::Rect(gfx::Point(0, 0), gfx::Size(100, 100));
     gfx::Transform layerToSurfaceTransform;
 
     // This sequence of transforms effectively rotates the layer about the y-axis at the
     // center of the layer.
     layerToSurfaceTransform.MakeIdentity();
     layerToSurfaceTransform.Translate(50, 0);
-    MathUtil::rotateEulerAngles(&layerToSurfaceTransform, 0, 45, 0);
+    layerToSurfaceTransform.RotateAboutYAxis(45);
     layerToSurfaceTransform.Translate(-50, 0);
 
     gfx::Rect expected = gfx::Rect(gfx::Point(0, 0), gfx::Size(100, 100));
     gfx::Rect actual = LayerTreeHostCommon::calculateVisibleRect(targetSurfaceRect, layerContentRect, layerToSurfaceTransform);
     EXPECT_RECT_EQ(expected, actual);
 }
 
 TEST(LayerTreeHostCommonTest, verifyVisibleRectFor3dPerspectiveWhenClippedByW)
 {
     // Test the calculateVisibleRect() function works correctly when projecting a surface
     // onto a layer, but the layer is partially behind the camera (not just behind the
     // projection plane). In this case, the cartesian coordinates may seem to be valid,
     // but actually they are not. The visibleRect needs to be properly clipped by the
     // w = 0 plane in homogeneous coordinates before converting to cartesian coordinates.
 
     gfx::Rect targetSurfaceRect = gfx::Rect(gfx::Point(-50, -50), gfx::Size(100, 100));
     gfx::Rect layerContentRect = gfx::Rect(gfx::Point(-10, -1), gfx::Size(20, 2));
     gfx::Transform layerToSurfaceTransform;
 
     // The layer is positioned so that the right half of the layer should be in front of
     // the camera, while the other half is behind the surface's projection plane. The
     // following sequence of transforms applies the perspective and rotation about the
     // center of the layer.
     layerToSurfaceTransform.MakeIdentity();
     layerToSurfaceTransform.ApplyPerspectiveDepth(1);
     layerToSurfaceTransform.Translate3d(-2, 0, 1);
-    MathUtil::rotateEulerAngles(&layerToSurfaceTransform, 0, 45, 0);
+    layerToSurfaceTransform.RotateAboutYAxis(45);
 
     // Sanity check that this transform does indeed cause w < 0 when applying the
     // transform, otherwise this code is not testing the intended scenario.
     bool clipped = false;
     MathUtil::mapQuad(layerToSurfaceTransform, gfx::QuadF(gfx::RectF(layerContentRect)), clipped);
     ASSERT_TRUE(clipped);
 
     int expectedXPosition = 0;
     int expectedWidth = 10;
     gfx::Rect actual = LayerTreeHostCommon::calculateVisibleRect(targetSurfaceRect, layerContentRect, layerToSurfaceTransform);
     EXPECT_EQ(expectedXPosition, actual.x());
     EXPECT_EQ(expectedWidth, actual.width());
 }
 
 TEST(LayerTreeHostCommonTest, verifyVisibleRectForPerspectiveUnprojection)
 {
     // To determine visibleRect in layer space, there needs to be an un-projection from
     // surface space to layer space. When the original transform was a perspective
     // projection that was clipped, it returns a rect that encloses the clipped bounds.
     // Un-projecting this new rect may require clipping again.
 
     // This sequence of transforms causes one corner of the layer to protrude across the w = 0 plane, and should be clipped.
     gfx::Rect targetSurfaceRect = gfx::Rect(gfx::Point(-50, -50), gfx::Size(100, 100));
     gfx::Rect layerContentRect = gfx::Rect(gfx::Point(-10, -10), gfx::Size(20, 20));
     gfx::Transform layerToSurfaceTransform;
     layerToSurfaceTransform.MakeIdentity();
     layerToSurfaceTransform.ApplyPerspectiveDepth(1);
     layerToSurfaceTransform.Translate3d(0, 0, -5);
-    MathUtil::rotateEulerAngles(&layerToSurfaceTransform, 0, 45, 0);
-    MathUtil::rotateEulerAngles(&layerToSurfaceTransform, 80, 0, 0);
+    layerToSurfaceTransform.RotateAboutYAxis(45);
+    layerToSurfaceTransform.RotateAboutXAxis(80);
 
     // Sanity check that un-projection does indeed cause w < 0, otherwise this code is not
     // testing the intended scenario.
     bool clipped = false;
     gfx::RectF clippedRect = MathUtil::mapClippedRect(layerToSurfaceTransform, layerContentRect);
     MathUtil::projectQuad(inverse(layerToSurfaceTransform), gfx::QuadF(clippedRect), clipped);
     ASSERT_TRUE(clipped);
 
     // Only the corner of the layer is not visible on the surface because of being
     // clipped. But, the net result of rounding visible region to an axis-aligned rect is
@@ skipping 857 matching lines @@
 
 TEST(LayerTreeHostCommonTest, verifyHitTestingForSingleRotatedLayer)
 {
     FakeImplProxy proxy;
     FakeLayerTreeHostImpl hostImpl(&proxy);
     scoped_ptr<LayerImpl> root = LayerImpl::create(hostImpl.activeTree(), 12345);
 
     gfx::Transform identityMatrix;
     gfx::Transform rotation45DegreesAboutCenter;
     rotation45DegreesAboutCenter.Translate(50, 50);
-    MathUtil::rotateEulerAngles(&rotation45DegreesAboutCenter, 0, 0, 45);
+    rotation45DegreesAboutCenter.RotateAboutZAxis(45);
     rotation45DegreesAboutCenter.Translate(-50, -50);
     gfx::PointF anchor(0, 0);
     gfx::PointF position(0, 0);
     gfx::Size bounds(100, 100);
     setLayerPropertiesForTesting(root.get(), rotation45DegreesAboutCenter, identityMatrix, anchor, position, bounds, false);
     root->setDrawsContent(true);
 
     std::vector<LayerImpl*> renderSurfaceLayerList;
     int dummyMaxTextureSize = 512;
     LayerTreeHostCommon::calculateDrawProperties(root.get(), root->bounds(), 1, 1, dummyMaxTextureSize, false, renderSurfaceLayerList);
@@ skipping 238 matching lines @@
         scoped_ptr<LayerImpl> child = LayerImpl::create(hostImpl.activeTree(), 456);
         scoped_ptr<LayerImpl> grandChild = LayerImpl::create(hostImpl.activeTree(), 789);
         scoped_ptr<LayerImpl> rotatedLeaf = LayerImpl::create(hostImpl.activeTree(), 2468);
 
         position = gfx::PointF(10, 10);
         bounds = gfx::Size(80, 80);
         setLayerPropertiesForTesting(child.get(), identityMatrix, identityMatrix, anchor, position, bounds, false);
         child->setMasksToBounds(true);
 
         gfx::Transform rotation45DegreesAboutCorner;
-        MathUtil::rotateEulerAngles(&rotation45DegreesAboutCorner, 0, 0, 45);
+        rotation45DegreesAboutCorner.RotateAboutZAxis(45);
 
         position = gfx::PointF(0, 0); // remember, positioned with respect to its parent which is already at 10, 10
         bounds = gfx::Size(200, 200); // to ensure it covers at least sqrt(2) * 100.
         setLayerPropertiesForTesting(grandChild.get(), rotation45DegreesAboutCorner, identityMatrix, anchor, position, bounds, false);
         grandChild->setMasksToBounds(true);
 
         // Rotates about the center of the layer
         gfx::Transform rotatedLeafTransform;
         rotatedLeafTransform.Translate(-10, -10); // cancel out the grandParent's position
-        MathUtil::rotateEulerAngles(&rotatedLeafTransform, 0, 0, -45); // cancel out the corner 45-degree rotation of the parent.
+        rotatedLeafTransform.RotateAboutZAxis(-45); // cancel out the corner 45-degree rotation of the parent.
         rotatedLeafTransform.Translate(50, 50);
-        MathUtil::rotateEulerAngles(&rotatedLeafTransform, 0, 0, 45);
+        rotatedLeafTransform.RotateAboutZAxis(45);
         rotatedLeafTransform.Translate(-50, -50);
         position = gfx::PointF(0, 0);
         bounds = gfx::Size(100, 100);
         setLayerPropertiesForTesting(rotatedLeaf.get(), rotatedLeafTransform, identityMatrix, anchor, position, bounds, false);
         rotatedLeaf->setDrawsContent(true);
 
         grandChild->addChild(rotatedLeaf.Pass());
         child->addChild(grandChild.Pass());
         root->addChild(child.Pass());
     }
@@ skipping 1654 matching lines @@
     EXPECT_EQ(m_canUseLCDText, m_grandChild->canUseLCDText());
 }
 
 INSTANTIATE_TEST_CASE_P(LayerTreeHostCommonTest,
                         LCDTextTest,
                         testing::Combine(testing::Bool(),
                                          testing::Bool()));
 
 }  // namespace
 }  // namespace cc