Move temporary MathUtil wrappers to permanent home in gfx::Transform

cc/layer_sorter_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_sorter.h"
 
 #include "cc/layer_impl.h"
 #include "cc/math_util.h"
 #include "cc/single_thread_proxy.h"
 #include "testing/gtest/include/gtest/gtest.h"
@@ skipping 46 matching lines @@
     LayerSorter::ABCompareResult overlapResult;
     const float zThreshold = 0.1f;
     float weight = 0;
 
     gfx::Transform perspectiveMatrix;
     perspectiveMatrix.ApplyPerspectiveDepth(1000);
 
     // Two layers forming a right angle with a perspective viewing transform.
     gfx::Transform leftFaceMatrix;
     leftFaceMatrix.Translate3d(-1, 0, -5);
-    MathUtil::rotateAxisAngle(&leftFaceMatrix, 0, 1, 0, -90);
+    leftFaceMatrix.RotateAbout(gfx::Vector3dF::YAxis(), -90);
     leftFaceMatrix.Translate(-1, -1);
     LayerShape leftFace(2, 2, perspectiveMatrix * leftFaceMatrix);
     gfx::Transform frontFaceMatrix;
     frontFaceMatrix.Translate3d(0, 0, -4);
     frontFaceMatrix.Translate(-1, -1);
     LayerShape frontFace(2, 2, perspectiveMatrix * frontFaceMatrix);
 
     overlapResult = LayerSorter::checkOverlap(&frontFace, &leftFace, zThreshold, weight);
     EXPECT_EQ(LayerSorter::BBeforeA, overlapResult);
 }
 
 TEST(LayerSorterTest, IntersectingLayerOverlap)
 {
     LayerSorter::ABCompareResult overlapResult;
     const float zThreshold = 0.1f;
     float weight = 0;
 
     gfx::Transform perspectiveMatrix;
     perspectiveMatrix.ApplyPerspectiveDepth(1000);
 
     // Intersecting layers. An explicit order will be returned based on relative z
     // values at the overlapping features but the weight returned should be zero.
     gfx::Transform frontFaceMatrix;
     frontFaceMatrix.Translate3d(0, 0, -4);
     frontFaceMatrix.Translate(-1, -1);
     LayerShape frontFace(2, 2, perspectiveMatrix * frontFaceMatrix);
 
     gfx::Transform throughMatrix;
     throughMatrix.Translate3d(0, 0, -4);
-    MathUtil::rotateAxisAngle(&throughMatrix, 0, 1, 0, 45);
+    throughMatrix.RotateAbout(gfx::Vector3dF(0, 1, 0), 45);

[danakj, 2012/11/28 00:42:12]

yaxis?

     throughMatrix.Translate(-1, -1);
     LayerShape rotatedFace(2, 2, perspectiveMatrix * throughMatrix);
     overlapResult = LayerSorter::checkOverlap(&frontFace, &rotatedFace, zThreshold, weight);
     EXPECT_NE(LayerSorter::None, overlapResult);
     EXPECT_EQ(0, weight);
 }
 
 TEST(LayerSorterTest, LayersAtAngleOverlap)
 {
     LayerSorter::ABCompareResult overlapResult;
@@ skipping 16 matching lines @@
     transformA.Translate3d(-6, 0, 1);
     transformA.Translate(-4, -10);
     LayerShape layerA(8, 20, transformA);
 
     gfx::Transform transformB;
     transformB.Translate3d(6, 0, -1);
     transformB.Translate(-4, -10);
     LayerShape layerB(8, 20, transformB);
 
     gfx::Transform transformC;
-    MathUtil::rotateAxisAngle(&transformC, 0, 1, 0, 40);
+    transformC.RotateAbout(gfx::Vector3dF::YAxis(), 40);
     transformC.Translate(-4, -10);
     LayerShape layerC(8, 20, transformC);
 
     overlapResult = LayerSorter::checkOverlap(&layerA, &layerC, zThreshold, weight);
     EXPECT_EQ(LayerSorter::ABeforeB, overlapResult);
     overlapResult = LayerSorter::checkOverlap(&layerC, &layerB, zThreshold, weight);
     EXPECT_EQ(LayerSorter::ABeforeB, overlapResult);
     overlapResult = LayerSorter::checkOverlap(&layerA, &layerB, zThreshold, weight);
     EXPECT_EQ(LayerSorter::None, overlapResult);
 }
@@ skipping 108 matching lines @@
     ASSERT_EQ(static_cast<size_t>(5), layerList.size());
     EXPECT_EQ(3, layerList[0]->id());
     EXPECT_EQ(4, layerList[1]->id());
     EXPECT_EQ(1, layerList[2]->id());
     EXPECT_EQ(2, layerList[3]->id());
     EXPECT_EQ(5, layerList[4]->id());
 }
 
 }  // namespace
 }  // namespace cc