Migrate most of cc/ from WebKit::WebTransformationMatrix to gfx::Transform

cc/damage_tracker_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/damage_tracker.h"
 
 #include "cc/layer_impl.h"
 #include "cc/layer_sorter.h"
 #include "cc/layer_tree_host_common.h"
 #include "cc/math_util.h"
 #include "cc/single_thread_proxy.h"
 #include "cc/test/geometry_test_utils.h"
 #include "testing/gtest/include/gtest/gtest.h"
 #include "third_party/skia/include/effects/SkBlurImageFilter.h"
 #include <public/WebFilterOperation.h>
 #include <public/WebFilterOperations.h>
 
 using namespace WebKit;
 using namespace WebKitTests;
 
+using gfx::Transform;
+
 namespace cc {
 namespace {
 
 void executeCalculateDrawTransformsAndVisibility(LayerImpl* root, std::vector<LayerImpl*>& renderSurfaceLayerList)
 {
     LayerSorter layerSorter;
     int dummyMaxTextureSize = 512;
 
     // Sanity check: The test itself should create the root layer's render surface, so
     //               that the surface (and its damage tracker) can persist across multiple
@@ skipping 247 matching lines @@
 }
 
 TEST_F(DamageTrackerTest, verifyDamageForTransformedLayer)
 {
     // If a layer is transformed, the damage rect should still enclose the entire
     // transformed layer.
 
     scoped_ptr<LayerImpl> root = createAndSetUpTestTreeWithOneSurface();
     LayerImpl* child = root->children()[0];
 
-    WebTransformationMatrix rotation;
-    rotation.rotate(45);
+    Transform rotation;
+    rotation.PreconcatRotate(45);
 
     clearDamageForAllSurfaces(root.get());
     child->setAnchorPoint(gfx::PointF(0.5, 0.5));
     child->setPosition(gfx::PointF(85, 85));
     emulateDrawingOneFrame(root.get());
 
     // Sanity check that the layer actually moved to (85, 85), damaging its old location and new location.
     gfx::RectF rootDamageRect = root->renderSurface()->damageTracker()->currentDamageRect();
     EXPECT_FLOAT_RECT_EQ(gfx::RectF(85, 85, 45, 45), rootDamageRect);
 
@@ skipping 21 matching lines @@
     //
     // The transform is constructed so that if w < 0 clipping is not performed, the
     // incorrect rect will be very small, specifically: position (500.972504, 498.544617) and size 0.056610 x 2.910767.
     // Instead, the correctly transformed rect should actually be very huge (i.e. in theory, -infinity on the left),
     // and positioned so that the right-most bound rect will be approximately 501 units in root surface space.
     //
 
     scoped_ptr<LayerImpl> root = createAndSetUpTestTreeWithOneSurface();
     LayerImpl* child = root->children()[0];
 
-    WebTransformationMatrix transform;
-    transform.translate3d(500, 500, 0);
-    transform.applyPerspective(1);
-    transform.rotate3d(0, 45, 0);
-    transform.translate3d(-50, -50, 0);
+    Transform transform;
+    transform.PreconcatTranslate3d(500, 500, 0);
+    transform.PreconcatPerspectiveDepth(1);
+    MathUtil::rotateEulerAngles(&transform, 0, 45, 0);
+    transform.PreconcatTranslate3d(-50, -50, 0);
 
     // Set up the child
     child->setPosition(gfx::PointF(0, 0));
     child->setBounds(gfx::Size(100, 100));
     child->setContentBounds(gfx::Size(100, 100));
     child->setTransform(transform);
     emulateDrawingOneFrame(root.get());
 
     // Sanity check that the child layer's bounds would actually get clipped by w < 0,
     // otherwise this test is not actually testing the intended scenario.
@@ skipping 480 matching lines @@
     child1->setOpacity(0.5);
     emulateDrawingOneFrame(root.get());
 
     // CASE 1: adding a reflection about the left edge of grandChild1.
     //
     clearDamageForAllSurfaces(root.get());
     {
         scoped_ptr<LayerImpl> grandChild1Replica = LayerImpl::create(7);
         grandChild1Replica->setPosition(gfx::PointF());
         grandChild1Replica->setAnchorPoint(gfx::PointF());
-        WebTransformationMatrix reflection;
-        reflection.scale3d(-1, 1, 1);
+        Transform reflection;
+        reflection.PreconcatScale3d(-1, 1, 1);
         grandChild1Replica->setTransform(reflection);
         grandChild1->setReplicaLayer(grandChild1Replica.Pass());
     }
     emulateDrawingOneFrame(root.get());
 
     gfx::RectF grandChildDamageRect = grandChild1->renderSurface()->damageTracker()->currentDamageRect();
     gfx::RectF childDamageRect = child1->renderSurface()->damageTracker()->currentDamageRect();
     gfx::RectF rootDamageRect = root->renderSurface()->damageTracker()->currentDamageRect();
 
     // The grandChild surface damage should not include its own replica. The child
@@ skipping 131 matching lines @@
     // Changes to a replica's mask should not damage the original surface, because it is
     // not masked. But it does damage the ancestor target surface.
 
     clearDamageForAllSurfaces(root.get());
 
     // Create a reflection about the left edge of grandChild1.
     {
         scoped_ptr<LayerImpl> grandChild1Replica = LayerImpl::create(6);
         grandChild1Replica->setPosition(gfx::PointF());
         grandChild1Replica->setAnchorPoint(gfx::PointF());
-        WebTransformationMatrix reflection;
-        reflection.scale3d(-1, 1, 1);
+        Transform reflection;
+        reflection.PreconcatScale3d(-1, 1, 1);
         grandChild1Replica->setTransform(reflection);
         grandChild1->setReplicaLayer(grandChild1Replica.Pass());
     }
     LayerImpl* grandChild1Replica = grandChild1->replicaLayer();
 
     // Set up the mask layer on the replica layer
     {
         scoped_ptr<LayerImpl> replicaMaskLayer = LayerImpl::create(7);
         replicaMaskLayer->setPosition(gfx::PointF());
         replicaMaskLayer->setAnchorPoint(gfx::PointF());
@@ skipping 40 matching lines @@
 
     // Verify that the correct replicaOriginTransform is used for the replicaMask;
     clearDamageForAllSurfaces(root.get());
 
     grandChild1->setAnchorPoint(gfx::PointF(1, 0)); // This is not exactly the anchor being tested, but by convention its expected to be the same as the replica's anchor point.
 
     {
         scoped_ptr<LayerImpl> grandChild1Replica = LayerImpl::create(6);
         grandChild1Replica->setPosition(gfx::PointF());
         grandChild1Replica->setAnchorPoint(gfx::PointF(1, 0)); // This is the anchor being tested.
-        WebTransformationMatrix reflection;
-        reflection.scale3d(-1, 1, 1);
+        Transform reflection;
+        reflection.PreconcatScale3d(-1, 1, 1);
         grandChild1Replica->setTransform(reflection);
         grandChild1->setReplicaLayer(grandChild1Replica.Pass());
     }
     LayerImpl* grandChild1Replica = grandChild1->replicaLayer();
 
     // Set up the mask layer on the replica layer
     {
         scoped_ptr<LayerImpl> replicaMaskLayer = LayerImpl::create(7);
         replicaMaskLayer->setPosition(gfx::PointF());
         replicaMaskLayer->setAnchorPoint(gfx::PointF()); // note, this is not the anchor being tested.
@@ skipping 87 matching lines @@
     EXPECT_TRUE(rootDamageRect.IsEmpty());
 
     // Damage should remain empty even after one frame, since there's yet no new damage
     emulateDrawingOneFrame(root.get());
     rootDamageRect = root->renderSurface()->damageTracker()->currentDamageRect();
     EXPECT_TRUE(rootDamageRect.IsEmpty());
 }
 
 }  // namespace
 }  // namespace cc