Get rid of graphics layer anchor points, and replace with transform origin.

cc/trees/layer_tree_impl_unittest.cc

 // Copyright 2014 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/trees/layer_tree_impl.h"
 
 #include "cc/layers/heads_up_display_layer_impl.h"
 #include "cc/layers/layer.h"
 #include "cc/test/fake_impl_proxy.h"
 #include "cc/test/fake_layer_tree_host_impl.h"
@@ skipping 30 matching lines @@
   TestSharedBitmapManager shared_bitmap_manager_;
   FakeImplProxy proxy_;
   scoped_ptr<FakeLayerTreeHostImpl> host_impl_;
 };
 
 TEST_F(LayerTreeImplTest, HitTestingForSingleLayer) {
   scoped_ptr<LayerImpl> root =
       LayerImpl::Create(host_impl().active_tree(), 12345);
 
   gfx::Transform identity_matrix;
-  gfx::PointF anchor;
+  gfx::Point3F transform_origin;
   gfx::PointF position;
   gfx::Size bounds(100, 100);
-  SetLayerPropertiesForTesting(
-      root.get(), identity_matrix, anchor, position, bounds, true, false);
+  SetLayerPropertiesForTesting(root.get(),
+                               identity_matrix,
+                               transform_origin,
+                               position,
+                               bounds,
+                               true,
+                               false);
   root->SetDrawsContent(true);
 
   host_impl().SetViewportSize(root->bounds());
   host_impl().active_tree()->SetRootLayer(root.Pass());
   host_impl().active_tree()->UpdateDrawProperties();
 
   // Sanity check the scenario we just created.
   ASSERT_EQ(1u, RenderSurfaceLayerList().size());
   ASSERT_EQ(1u, root_layer()->render_surface()->layer_list().size());
 
@@ skipping 22 matching lines @@
   EXPECT_EQ(12345, result_layer->id());
 }
 
 TEST_F(LayerTreeImplTest, HitTestingForSingleLayerAndHud) {
   scoped_ptr<LayerImpl> root =
       LayerImpl::Create(host_impl().active_tree(), 12345);
   scoped_ptr<HeadsUpDisplayLayerImpl> hud =
       HeadsUpDisplayLayerImpl::Create(host_impl().active_tree(), 11111);
 
   gfx::Transform identity_matrix;
-  gfx::PointF anchor;
+  gfx::Point3F transform_origin;
   gfx::PointF position;
   gfx::Size bounds(100, 100);
-  SetLayerPropertiesForTesting(
-      root.get(), identity_matrix, anchor, position, bounds, true, false);
+  SetLayerPropertiesForTesting(root.get(),
+                               identity_matrix,
+                               transform_origin,
+                               position,
+                               bounds,
+                               true,
+                               false);
   root->SetDrawsContent(true);
 
   // Create hud and add it as a child of root.
   gfx::Size hud_bounds(200, 200);
-  SetLayerPropertiesForTesting(
-      hud.get(), identity_matrix, anchor, position, hud_bounds, true, false);
+  SetLayerPropertiesForTesting(hud.get(),
+                               identity_matrix,
+                               transform_origin,
+                               position,
+                               hud_bounds,
+                               true,
+                               false);
   hud->SetDrawsContent(true);
 
   host_impl().active_tree()->set_hud_layer(hud.get());
   root->AddChild(hud.PassAs<LayerImpl>());
 
   host_impl().SetViewportSize(hud_bounds);
   host_impl().active_tree()->SetRootLayer(root.Pass());
   host_impl().active_tree()->UpdateDrawProperties();
 
   // Sanity check the scenario we just created.
@@ skipping 31 matching lines @@
       LayerImpl::Create(host_impl().active_tree(), 12345);
 
   gfx::Transform uninvertible_transform;
   uninvertible_transform.matrix().set(0, 0, 0.0);
   uninvertible_transform.matrix().set(1, 1, 0.0);
   uninvertible_transform.matrix().set(2, 2, 0.0);
   uninvertible_transform.matrix().set(3, 3, 0.0);
   ASSERT_FALSE(uninvertible_transform.IsInvertible());
 
   gfx::Transform identity_matrix;
-  gfx::PointF anchor;
+  gfx::Point3F transform_origin;
   gfx::PointF position;
   gfx::Size bounds(100, 100);
   SetLayerPropertiesForTesting(root.get(),
                                uninvertible_transform,
-                               anchor,
+                               transform_origin,
                                position,
                                bounds,
                                true,
                                false);
   root->SetDrawsContent(true);
 
   host_impl().SetViewportSize(root->bounds());
   host_impl().active_tree()->SetRootLayer(root.Pass());
   host_impl().active_tree()->UpdateDrawProperties();
   // Sanity check the scenario we just created.
@@ skipping 38 matching lines @@
   result_layer =
       host_impl().active_tree()->FindLayerThatIsHitByPoint(test_point);
   EXPECT_FALSE(result_layer);
 }
 
 TEST_F(LayerTreeImplTest, HitTestingForSinglePositionedLayer) {
   scoped_ptr<LayerImpl> root =
       LayerImpl::Create(host_impl().active_tree(), 12345);
 
   gfx::Transform identity_matrix;
-  gfx::PointF anchor;
+  gfx::Point3F transform_origin;
   // this layer is positioned, and hit testing should correctly know where the
   // layer is located.
   gfx::PointF position(50.f, 50.f);
   gfx::Size bounds(100, 100);
-  SetLayerPropertiesForTesting(
-      root.get(), identity_matrix, anchor, position, bounds, true, false);
+  SetLayerPropertiesForTesting(root.get(),
+                               identity_matrix,
+                               transform_origin,
+                               position,
+                               bounds,
+                               true,
+                               false);
   root->SetDrawsContent(true);
 
   host_impl().SetViewportSize(root->bounds());
   host_impl().active_tree()->SetRootLayer(root.Pass());
   host_impl().active_tree()->UpdateDrawProperties();
 
   // Sanity check the scenario we just created.
   ASSERT_EQ(1u, RenderSurfaceLayerList().size());
   ASSERT_EQ(1u, root_layer()->render_surface()->layer_list().size());
 
@@ skipping 26 matching lines @@
 
 TEST_F(LayerTreeImplTest, HitTestingForSingleRotatedLayer) {
   scoped_ptr<LayerImpl> root =
       LayerImpl::Create(host_impl().active_tree(), 12345);
 
   gfx::Transform identity_matrix;
   gfx::Transform rotation45_degrees_about_center;
   rotation45_degrees_about_center.Translate(50.0, 50.0);
   rotation45_degrees_about_center.RotateAboutZAxis(45.0);
   rotation45_degrees_about_center.Translate(-50.0, -50.0);
-  gfx::PointF anchor;
+  gfx::Point3F transform_origin;
   gfx::PointF position;
   gfx::Size bounds(100, 100);
   SetLayerPropertiesForTesting(root.get(),
                                rotation45_degrees_about_center,
-                               anchor,
+                               transform_origin,
                                position,
                                bounds,
                                true,
                                false);
   root->SetDrawsContent(true);
 
   host_impl().SetViewportSize(root->bounds());
   host_impl().active_tree()->SetRootLayer(root.Pass());
   host_impl().active_tree()->UpdateDrawProperties();
 
@@ skipping 42 matching lines @@
 
   // perspective_projection_about_center * translation_by_z is designed so that
   // the 100 x 100 layer becomes 50 x 50, and remains centered at (50, 50).
   gfx::Transform perspective_projection_about_center;
   perspective_projection_about_center.Translate(50.0, 50.0);
   perspective_projection_about_center.ApplyPerspectiveDepth(1.0);
   perspective_projection_about_center.Translate(-50.0, -50.0);
   gfx::Transform translation_by_z;
   translation_by_z.Translate3d(0.0, 0.0, -1.0);
 
-  gfx::PointF anchor;
+  gfx::Point3F transform_origin;
   gfx::PointF position;
   gfx::Size bounds(100, 100);
   SetLayerPropertiesForTesting(
       root.get(),
       perspective_projection_about_center * translation_by_z,
-      anchor,
+      transform_origin,
       position,
       bounds,
       true,
       false);
   root->SetDrawsContent(true);
 
   host_impl().SetViewportSize(root->bounds());
   host_impl().active_tree()->SetRootLayer(root.Pass());
   host_impl().active_tree()->UpdateDrawProperties();
 
@@ skipping 36 matching lines @@
   // non-identity transform between layer's content space and layer's origin
   // space. The hit testing code must take this into account.
   //
   // To test this, the layer is positioned at (25, 25), and is size (50, 50). If
   // contents scale is ignored, then hit testing will mis-interpret the visible
   // content rect as being larger than the actual bounds of the layer.
   //
   scoped_ptr<LayerImpl> root = LayerImpl::Create(host_impl().active_tree(), 1);
 
   gfx::Transform identity_matrix;
-  gfx::PointF anchor;
+  gfx::Point3F transform_origin;
 
   SetLayerPropertiesForTesting(root.get(),
                                identity_matrix,
-                               anchor,
+                               transform_origin,
                                gfx::PointF(),
                                gfx::Size(100, 100),
                                true,
                                false);
   {
     gfx::PointF position(25.f, 25.f);
     gfx::Size bounds(50, 50);
     scoped_ptr<LayerImpl> test_layer =
         LayerImpl::Create(host_impl().active_tree(), 12345);
     SetLayerPropertiesForTesting(test_layer.get(),
                                  identity_matrix,
-                                 anchor,
+                                 transform_origin,
                                  position,
                                  bounds,
                                  true,
                                  false);
 
     // override content bounds and contents scale
     test_layer->SetContentBounds(gfx::Size(100, 100));
     test_layer->SetContentsScale(2, 2);
 
     test_layer->SetDrawsContent(true);
@@ skipping 42 matching lines @@
       host_impl().active_tree()->FindLayerThatIsHitByPoint(test_point);
   ASSERT_TRUE(result_layer);
   EXPECT_EQ(12345, result_layer->id());
 }
 
 TEST_F(LayerTreeImplTest, HitTestingForSimpleClippedLayer) {
   // Test that hit-testing will only work for the visible portion of a layer,
   // and not the entire layer bounds. Here we just test the simple axis-aligned
   // case.
   gfx::Transform identity_matrix;
-  gfx::PointF anchor;
+  gfx::Point3F transform_origin;
 
   scoped_ptr<LayerImpl> root = LayerImpl::Create(host_impl().active_tree(), 1);
   SetLayerPropertiesForTesting(root.get(),
                                identity_matrix,
-                               anchor,
+                               transform_origin,
                                gfx::PointF(),
                                gfx::Size(100, 100),
                                true,
                                false);
   {
     scoped_ptr<LayerImpl> clipping_layer =
         LayerImpl::Create(host_impl().active_tree(), 123);
     // this layer is positioned, and hit testing should correctly know where the
     // layer is located.
     gfx::PointF position(25.f, 25.f);
     gfx::Size bounds(50, 50);
     SetLayerPropertiesForTesting(clipping_layer.get(),
                                  identity_matrix,
-                                 anchor,
+                                 transform_origin,
                                  position,
                                  bounds,
                                  true,
                                  false);
     clipping_layer->SetMasksToBounds(true);
 
     scoped_ptr<LayerImpl> child =
         LayerImpl::Create(host_impl().active_tree(), 456);
     position = gfx::PointF(-50.f, -50.f);
     bounds = gfx::Size(300, 300);
-    SetLayerPropertiesForTesting(
-        child.get(), identity_matrix, anchor, position, bounds, true, false);
+    SetLayerPropertiesForTesting(child.get(),
+                                 identity_matrix,
+                                 transform_origin,
+                                 position,
+                                 bounds,
+                                 true,
+                                 false);
     child->SetDrawsContent(true);
     clipping_layer->AddChild(child.Pass());
     root->AddChild(clipping_layer.Pass());
   }
 
   host_impl().SetViewportSize(root->bounds());
   host_impl().active_tree()->SetRootLayer(root.Pass());
   host_impl().active_tree()->UpdateDrawProperties();
 
   // Sanity check the scenario we just created.
@@ skipping 38 matching lines @@
   //
   // The child and grand_child layers are both initialized to clip the
   // rotated_leaf. The child layer is rotated about the top-left corner, so that
   // the root + child clips combined create a triangle. The rotated_leaf will
   // only be visible where it overlaps this triangle.
   //
   scoped_ptr<LayerImpl> root =
       LayerImpl::Create(host_impl().active_tree(), 123);
 
   gfx::Transform identity_matrix;
-  gfx::PointF anchor;
+  gfx::Point3F transform_origin;
   gfx::PointF position;
   gfx::Size bounds(100, 100);
-  SetLayerPropertiesForTesting(
-      root.get(), identity_matrix, anchor, position, bounds, true, false);
+  SetLayerPropertiesForTesting(root.get(),
+                               identity_matrix,
+                               transform_origin,
+                               position,
+                               bounds,
+                               true,
+                               false);
   root->SetMasksToBounds(true);
   {
     scoped_ptr<LayerImpl> child =
         LayerImpl::Create(host_impl().active_tree(), 456);
     scoped_ptr<LayerImpl> grand_child =
         LayerImpl::Create(host_impl().active_tree(), 789);
     scoped_ptr<LayerImpl> rotated_leaf =
         LayerImpl::Create(host_impl().active_tree(), 2468);
 
     position = gfx::PointF(10.f, 10.f);
     bounds = gfx::Size(80, 80);
-    SetLayerPropertiesForTesting(
-        child.get(), identity_matrix, anchor, position, bounds, true, false);
+    SetLayerPropertiesForTesting(child.get(),
+                                 identity_matrix,
+                                 transform_origin,
+                                 position,
+                                 bounds,
+                                 true,
+                                 false);
     child->SetMasksToBounds(true);
 
     gfx::Transform rotation45_degrees_about_corner;
     rotation45_degrees_about_corner.RotateAboutZAxis(45.0);
 
     // remember, positioned with respect to its parent which is already at 10,
     // 10
     position = gfx::PointF();
     bounds =
         gfx::Size(200, 200);  // to ensure it covers at least sqrt(2) * 100.
     SetLayerPropertiesForTesting(grand_child.get(),
                                  rotation45_degrees_about_corner,
-                                 anchor,
+                                 transform_origin,
                                  position,
                                  bounds,
                                  true,
                                  false);
     grand_child->SetMasksToBounds(true);
 
     // Rotates about the center of the layer
     gfx::Transform rotated_leaf_transform;
     rotated_leaf_transform.Translate(
         -10.0, -10.0);  // cancel out the grand_parent's position
     rotated_leaf_transform.RotateAboutZAxis(
         -45.0);  // cancel out the corner 45-degree rotation of the parent.
     rotated_leaf_transform.Translate(50.0, 50.0);
     rotated_leaf_transform.RotateAboutZAxis(45.0);
     rotated_leaf_transform.Translate(-50.0, -50.0);
     position = gfx::PointF();
     bounds = gfx::Size(100, 100);
     SetLayerPropertiesForTesting(rotated_leaf.get(),
                                  rotated_leaf_transform,
-                                 anchor,
+                                 transform_origin,
                                  position,
                                  bounds,
                                  true,
                                  false);
     rotated_leaf->SetDrawsContent(true);
 
     grand_child->AddChild(rotated_leaf.Pass());
     child->AddChild(grand_child.Pass());
     root->AddChild(child.Pass());
   }
@@ skipping 67 matching lines @@
   result_layer =
       host_impl().active_tree()->FindLayerThatIsHitByPoint(test_point);
   ASSERT_TRUE(result_layer);
   EXPECT_EQ(2468, result_layer->id());
 }
 
 TEST_F(LayerTreeImplTest, HitTestingForNonClippingIntermediateLayer) {
   // This test checks that hit testing code does not accidentally clip to layer
   // bounds for a layer that actually does not clip.
   gfx::Transform identity_matrix;
-  gfx::PointF anchor;
+  gfx::Point3F transform_origin;
 
   scoped_ptr<LayerImpl> root = LayerImpl::Create(host_impl().active_tree(), 1);
   SetLayerPropertiesForTesting(root.get(),
                                identity_matrix,
-                               anchor,
+                               transform_origin,
                                gfx::PointF(),
                                gfx::Size(100, 100),
                                true,
                                false);
   {
     scoped_ptr<LayerImpl> intermediate_layer =
         LayerImpl::Create(host_impl().active_tree(), 123);
     // this layer is positioned, and hit testing should correctly know where the
     // layer is located.
     gfx::PointF position(10.f, 10.f);
     gfx::Size bounds(50, 50);
     SetLayerPropertiesForTesting(intermediate_layer.get(),
                                  identity_matrix,
-                                 anchor,
+                                 transform_origin,
                                  position,
                                  bounds,
                                  true,
                                  false);
     // Sanity check the intermediate layer should not clip.
     ASSERT_FALSE(intermediate_layer->masks_to_bounds());
     ASSERT_FALSE(intermediate_layer->mask_layer());
 
     // The child of the intermediate_layer is translated so that it does not
     // overlap intermediate_layer at all.  If child is incorrectly clipped, we
     // would not be able to hit it successfully.
     scoped_ptr<LayerImpl> child =
         LayerImpl::Create(host_impl().active_tree(), 456);
     position = gfx::PointF(60.f, 60.f);  // 70, 70 in screen space
     bounds = gfx::Size(20, 20);
-    SetLayerPropertiesForTesting(
-        child.get(), identity_matrix, anchor, position, bounds, true, false);
+    SetLayerPropertiesForTesting(child.get(),
+                                 identity_matrix,
+                                 transform_origin,
+                                 position,
+                                 bounds,
+                                 true,
+                                 false);
     child->SetDrawsContent(true);
     intermediate_layer->AddChild(child.Pass());
     root->AddChild(intermediate_layer.Pass());
   }
 
   host_impl().SetViewportSize(root->bounds());
   host_impl().active_tree()->SetRootLayer(root.Pass());
   host_impl().active_tree()->UpdateDrawProperties();
 
   // Sanity check the scenario we just created.
@@ skipping 23 matching lines @@
   result_layer =
       host_impl().active_tree()->FindLayerThatIsHitByPoint(test_point);
   ASSERT_TRUE(result_layer);
   EXPECT_EQ(456, result_layer->id());
 }
 
 TEST_F(LayerTreeImplTest, HitTestingForMultipleLayers) {
   scoped_ptr<LayerImpl> root = LayerImpl::Create(host_impl().active_tree(), 1);
 
   gfx::Transform identity_matrix;
-  gfx::PointF anchor;
+  gfx::Point3F transform_origin;
   gfx::PointF position;
   gfx::Size bounds(100, 100);
-  SetLayerPropertiesForTesting(
-      root.get(), identity_matrix, anchor, position, bounds, true, false);
+  SetLayerPropertiesForTesting(root.get(),
+                               identity_matrix,
+                               transform_origin,
+                               position,
+                               bounds,
+                               true,
+                               false);
   root->SetDrawsContent(true);
   {
     // child 1 and child2 are initialized to overlap between x=50 and x=60.
     // grand_child is set to overlap both child1 and child2 between y=50 and
     // y=60.  The expected stacking order is: (front) child2, (second)
     // grand_child, (third) child1, and (back) the root layer behind all other
     // layers.
 
     scoped_ptr<LayerImpl> child1 =
         LayerImpl::Create(host_impl().active_tree(), 2);
     scoped_ptr<LayerImpl> child2 =
         LayerImpl::Create(host_impl().active_tree(), 3);
     scoped_ptr<LayerImpl> grand_child1 =
         LayerImpl::Create(host_impl().active_tree(), 4);
 
     position = gfx::PointF(10.f, 10.f);
     bounds = gfx::Size(50, 50);
-    SetLayerPropertiesForTesting(
-        child1.get(), identity_matrix, anchor, position, bounds, true, false);
+    SetLayerPropertiesForTesting(child1.get(),
+                                 identity_matrix,
+                                 transform_origin,
+                                 position,
+                                 bounds,
+                                 true,
+                                 false);
     child1->SetDrawsContent(true);
 
     position = gfx::PointF(50.f, 10.f);
     bounds = gfx::Size(50, 50);
-    SetLayerPropertiesForTesting(
-        child2.get(), identity_matrix, anchor, position, bounds, true, false);
+    SetLayerPropertiesForTesting(child2.get(),
+                                 identity_matrix,
+                                 transform_origin,
+                                 position,
+                                 bounds,
+                                 true,
+                                 false);
     child2->SetDrawsContent(true);
 
     // Remember that grand_child is positioned with respect to its parent (i.e.
     // child1).  In screen space, the intended position is (10, 50), with size
     // 100 x 50.
     position = gfx::PointF(0.f, 40.f);
     bounds = gfx::Size(100, 50);
     SetLayerPropertiesForTesting(grand_child1.get(),
                                  identity_matrix,
-                                 anchor,
+                                 transform_origin,
                                  position,
                                  bounds,
                                  true,
                                  false);
     grand_child1->SetDrawsContent(true);
 
     child1->AddChild(grand_child1.Pass());
     root->AddChild(child1.Pass());
     root->AddChild(child2.Pass());
   }
@@ skipping 64 matching lines @@
   result_layer =
       host_impl().active_tree()->FindLayerThatIsHitByPoint(test_point);
   ASSERT_TRUE(result_layer);
   EXPECT_EQ(4, result_layer->id());
 }
 
 TEST_F(LayerTreeImplTest, HitTestingForMultipleLayersAtVaryingDepths) {
   scoped_ptr<LayerImpl> root = LayerImpl::Create(host_impl().active_tree(), 1);
 
   gfx::Transform identity_matrix;
-  gfx::PointF anchor;
+  gfx::Point3F transform_origin;
   gfx::PointF position;
   gfx::Size bounds(100, 100);
-  SetLayerPropertiesForTesting(
-      root.get(), identity_matrix, anchor, position, bounds, true, false);
+  SetLayerPropertiesForTesting(root.get(),
+                               identity_matrix,
+                               transform_origin,
+                               position,
+                               bounds,
+                               true,
+                               false);
   root->SetDrawsContent(true);
   root->SetShouldFlattenTransform(false);
   root->SetIs3dSorted(true);
   {
     // child 1 and child2 are initialized to overlap between x=50 and x=60.
     // grand_child is set to overlap both child1 and child2 between y=50 and
     // y=60.  The expected stacking order is: (front) child2, (second)
     // grand_child, (third) child1, and (back) the root layer behind all other
     // layers.
 
     scoped_ptr<LayerImpl> child1 =
         LayerImpl::Create(host_impl().active_tree(), 2);
     scoped_ptr<LayerImpl> child2 =
         LayerImpl::Create(host_impl().active_tree(), 3);
     scoped_ptr<LayerImpl> grand_child1 =
         LayerImpl::Create(host_impl().active_tree(), 4);
 
     position = gfx::PointF(10.f, 10.f);
     bounds = gfx::Size(50, 50);
-    SetLayerPropertiesForTesting(
-        child1.get(), identity_matrix, anchor, position, bounds, true, false);
+    SetLayerPropertiesForTesting(child1.get(),
+                                 identity_matrix,
+                                 transform_origin,
+                                 position,
+                                 bounds,
+                                 true,
+                                 false);
     child1->SetDrawsContent(true);
     child1->SetShouldFlattenTransform(false);
     child1->SetIs3dSorted(true);
 
     position = gfx::PointF(50.f, 10.f);
     bounds = gfx::Size(50, 50);
     gfx::Transform translate_z;
     translate_z.Translate3d(0, 0, -10.f);
-    SetLayerPropertiesForTesting(
-        child2.get(), translate_z, anchor, position, bounds, true, false);
+    SetLayerPropertiesForTesting(child2.get(),
+                                 translate_z,
+                                 transform_origin,
+                                 position,
+                                 bounds,
+                                 true,
+                                 false);
     child2->SetDrawsContent(true);
     child2->SetShouldFlattenTransform(false);
     child2->SetIs3dSorted(true);
 
     // Remember that grand_child is positioned with respect to its parent (i.e.
     // child1).  In screen space, the intended position is (10, 50), with size
     // 100 x 50.
     position = gfx::PointF(0.f, 40.f);
     bounds = gfx::Size(100, 50);
     SetLayerPropertiesForTesting(grand_child1.get(),
                                  identity_matrix,
-                                 anchor,
+                                 transform_origin,
                                  position,
                                  bounds,
                                  true,
                                  false);
     grand_child1->SetDrawsContent(true);
     grand_child1->SetShouldFlattenTransform(false);
 
     child1->AddChild(grand_child1.Pass());
     root->AddChild(child1.Pass());
     root->AddChild(child2.Pass());
@@ skipping 71 matching lines @@
 }
 
 TEST_F(LayerTreeImplTest, HitTestingForMultipleLayerLists) {
   //
   // The geometry is set up similarly to the previous case, but
   // all layers are forced to be render surfaces now.
   //
   scoped_ptr<LayerImpl> root = LayerImpl::Create(host_impl().active_tree(), 1);
 
   gfx::Transform identity_matrix;
-  gfx::PointF anchor;
+  gfx::Point3F transform_origin;
   gfx::PointF position;
   gfx::Size bounds(100, 100);
-  SetLayerPropertiesForTesting(
-      root.get(), identity_matrix, anchor, position, bounds, true, false);
+  SetLayerPropertiesForTesting(root.get(),
+                               identity_matrix,
+                               transform_origin,
+                               position,
+                               bounds,
+                               true,
+                               false);
   root->SetDrawsContent(true);
   {
     // child 1 and child2 are initialized to overlap between x=50 and x=60.
     // grand_child is set to overlap both child1 and child2 between y=50 and
     // y=60.  The expected stacking order is: (front) child2, (second)
     // grand_child, (third) child1, and (back) the root layer behind all other
     // layers.
 
     scoped_ptr<LayerImpl> child1 =
         LayerImpl::Create(host_impl().active_tree(), 2);
     scoped_ptr<LayerImpl> child2 =
         LayerImpl::Create(host_impl().active_tree(), 3);
     scoped_ptr<LayerImpl> grand_child1 =
         LayerImpl::Create(host_impl().active_tree(), 4);
 
     position = gfx::PointF(10.f, 10.f);
     bounds = gfx::Size(50, 50);
-    SetLayerPropertiesForTesting(
-        child1.get(), identity_matrix, anchor, position, bounds, true, false);
+    SetLayerPropertiesForTesting(child1.get(),
+                                 identity_matrix,
+                                 transform_origin,
+                                 position,
+                                 bounds,
+                                 true,
+                                 false);
     child1->SetDrawsContent(true);
     child1->SetForceRenderSurface(true);
 
     position = gfx::PointF(50.f, 10.f);
     bounds = gfx::Size(50, 50);
-    SetLayerPropertiesForTesting(
-        child2.get(), identity_matrix, anchor, position, bounds, true, false);
+    SetLayerPropertiesForTesting(child2.get(),
+                                 identity_matrix,
+                                 transform_origin,
+                                 position,
+                                 bounds,
+                                 true,
+                                 false);
     child2->SetDrawsContent(true);
     child2->SetForceRenderSurface(true);
 
     // Remember that grand_child is positioned with respect to its parent (i.e.
     // child1).  In screen space, the intended position is (10, 50), with size
     // 100 x 50.
     position = gfx::PointF(0.f, 40.f);
     bounds = gfx::Size(100, 50);
     SetLayerPropertiesForTesting(grand_child1.get(),
                                  identity_matrix,
-                                 anchor,
+                                 transform_origin,
                                  position,
                                  bounds,
                                  true,
                                  false);
     grand_child1->SetDrawsContent(true);
     grand_child1->SetForceRenderSurface(true);
 
     child1->AddChild(grand_child1.Pass());
     root->AddChild(child1.Pass());
     root->AddChild(child2.Pass());
@@ skipping 74 matching lines @@
   ASSERT_TRUE(result_layer);
   EXPECT_EQ(4, result_layer->id());
 }
 
 TEST_F(LayerTreeImplTest, HitCheckingTouchHandlerRegionsForSingleLayer) {
   scoped_ptr<LayerImpl> root =
       LayerImpl::Create(host_impl().active_tree(), 12345);
 
   gfx::Transform identity_matrix;
   Region touch_handler_region(gfx::Rect(10, 10, 50, 50));
-  gfx::PointF anchor;
+  gfx::Point3F transform_origin;
   gfx::PointF position;
   gfx::Size bounds(100, 100);
-  SetLayerPropertiesForTesting(
-      root.get(), identity_matrix, anchor, position, bounds, true, false);
+  SetLayerPropertiesForTesting(root.get(),
+                               identity_matrix,
+                               transform_origin,
+                               position,
+                               bounds,
+                               true,
+                               false);
   root->SetDrawsContent(true);
 
   host_impl().SetViewportSize(root->bounds());
   host_impl().active_tree()->SetRootLayer(root.Pass());
   host_impl().active_tree()->UpdateDrawProperties();
 
   // Sanity check the scenario we just created.
   ASSERT_EQ(1u, RenderSurfaceLayerList().size());
   ASSERT_EQ(1u, root_layer()->render_surface()->layer_list().size());
 
@@ skipping 58 matching lines @@
 
   gfx::Transform uninvertible_transform;
   uninvertible_transform.matrix().set(0, 0, 0.0);
   uninvertible_transform.matrix().set(1, 1, 0.0);
   uninvertible_transform.matrix().set(2, 2, 0.0);
   uninvertible_transform.matrix().set(3, 3, 0.0);
   ASSERT_FALSE(uninvertible_transform.IsInvertible());
 
   gfx::Transform identity_matrix;
   Region touch_handler_region(gfx::Rect(10, 10, 50, 50));
-  gfx::PointF anchor;
+  gfx::Point3F transform_origin;
   gfx::PointF position;
   gfx::Size bounds(100, 100);
   SetLayerPropertiesForTesting(root.get(),
                                uninvertible_transform,
-                               anchor,
+                               transform_origin,
                                position,
                                bounds,
                                true,
                                false);
   root->SetDrawsContent(true);
   root->SetTouchEventHandlerRegion(touch_handler_region);
 
   host_impl().SetViewportSize(root->bounds());
   host_impl().active_tree()->SetRootLayer(root.Pass());
   host_impl().active_tree()->UpdateDrawProperties();
@@ skipping 50 matching lines @@
   EXPECT_FALSE(result_layer);
 }
 
 TEST_F(LayerTreeImplTest,
        HitCheckingTouchHandlerRegionsForSinglePositionedLayer) {
   scoped_ptr<LayerImpl> root =
       LayerImpl::Create(host_impl().active_tree(), 12345);
 
   gfx::Transform identity_matrix;
   Region touch_handler_region(gfx::Rect(10, 10, 50, 50));
-  gfx::PointF anchor;
+  gfx::Point3F transform_origin;
   // this layer is positioned, and hit testing should correctly know where the
   // layer is located.
   gfx::PointF position(50.f, 50.f);
   gfx::Size bounds(100, 100);
-  SetLayerPropertiesForTesting(
-      root.get(), identity_matrix, anchor, position, bounds, true, false);
+  SetLayerPropertiesForTesting(root.get(),
+                               identity_matrix,
+                               transform_origin,
+                               position,
+                               bounds,
+                               true,
+                               false);
   root->SetDrawsContent(true);
   root->SetTouchEventHandlerRegion(touch_handler_region);
 
   host_impl().SetViewportSize(root->bounds());
   host_impl().active_tree()->SetRootLayer(root.Pass());
   host_impl().active_tree()->UpdateDrawProperties();
 
   // Sanity check the scenario we just created.
   ASSERT_EQ(1u, RenderSurfaceLayerList().size());
   ASSERT_EQ(1u, root_layer()->render_surface()->layer_list().size());
@@ skipping 47 matching lines @@
   // non-identity transform between layer's content space and layer's origin
   // space. The hit testing code must take this into account.
   //
   // To test this, the layer is positioned at (25, 25), and is size (50, 50). If
   // contents scale is ignored, then hit checking will mis-interpret the visible
   // content rect as being larger than the actual bounds of the layer.
   //
   scoped_ptr<LayerImpl> root = LayerImpl::Create(host_impl().active_tree(), 1);
 
   gfx::Transform identity_matrix;
-  gfx::PointF anchor;
+  gfx::Point3F transform_origin;
 
   SetLayerPropertiesForTesting(root.get(),
                                identity_matrix,
-                               anchor,
+                               transform_origin,
                                gfx::PointF(),
                                gfx::Size(100, 100),
                                true,
                                false);
   {
     Region touch_handler_region(gfx::Rect(10, 10, 30, 30));
     gfx::PointF position(25.f, 25.f);
     gfx::Size bounds(50, 50);
     scoped_ptr<LayerImpl> test_layer =
         LayerImpl::Create(host_impl().active_tree(), 12345);
     SetLayerPropertiesForTesting(test_layer.get(),
                                  identity_matrix,
-                                 anchor,
+                                 transform_origin,
                                  position,
                                  bounds,
                                  true,
                                  false);
 
     // override content bounds and contents scale
     test_layer->SetContentBounds(gfx::Size(100, 100));
     test_layer->SetContentsScale(2, 2);
 
     test_layer->SetDrawsContent(true);
@@ skipping 66 matching lines @@
 }
 
 TEST_F(LayerTreeImplTest,
        HitCheckingTouchHandlerRegionsForSingleLayerWithDeviceScale) {
   // The layer's device_scale_factor and page_scale_factor should scale the
   // content rect and we should be able to hit the touch handler region by
   // scaling the points accordingly.
   scoped_ptr<LayerImpl> root = LayerImpl::Create(host_impl().active_tree(), 1);
 
   gfx::Transform identity_matrix;
-  gfx::PointF anchor;
+  gfx::Point3F transform_origin;
   // Set the bounds of the root layer big enough to fit the child when scaled.
   SetLayerPropertiesForTesting(root.get(),
                                identity_matrix,
-                               anchor,
+                               transform_origin,
                                gfx::PointF(),
                                gfx::Size(100, 100),
                                true,
                                false);
   {
     Region touch_handler_region(gfx::Rect(10, 10, 30, 30));
     gfx::PointF position(25.f, 25.f);
     gfx::Size bounds(50, 50);
     scoped_ptr<LayerImpl> test_layer =
         LayerImpl::Create(host_impl().active_tree(), 12345);
     SetLayerPropertiesForTesting(test_layer.get(),
                                  identity_matrix,
-                                 anchor,
+                                 transform_origin,
                                  position,
                                  bounds,
                                  true,
                                  false);
 
     test_layer->SetDrawsContent(true);
     test_layer->SetTouchEventHandlerRegion(touch_handler_region);
     root->AddChild(test_layer.Pass());
   }
 
@@ skipping 85 matching lines @@
           test_point);
   ASSERT_TRUE(result_layer);
   EXPECT_EQ(12345, result_layer->id());
 }
 
 TEST_F(LayerTreeImplTest, HitCheckingTouchHandlerRegionsForSimpleClippedLayer) {
   // Test that hit-checking will only work for the visible portion of a layer,
   // and not the entire layer bounds. Here we just test the simple axis-aligned
   // case.
   gfx::Transform identity_matrix;
-  gfx::PointF anchor;
+  gfx::Point3F transform_origin;
 
   scoped_ptr<LayerImpl> root = LayerImpl::Create(host_impl().active_tree(), 1);
   SetLayerPropertiesForTesting(root.get(),
                                identity_matrix,
-                               anchor,
+                               transform_origin,
                                gfx::PointF(),
                                gfx::Size(100, 100),
                                true,
                                false);
   {
     scoped_ptr<LayerImpl> clipping_layer =
         LayerImpl::Create(host_impl().active_tree(), 123);
     // this layer is positioned, and hit testing should correctly know where the
     // layer is located.
     gfx::PointF position(25.f, 25.f);
     gfx::Size bounds(50, 50);
     SetLayerPropertiesForTesting(clipping_layer.get(),
                                  identity_matrix,
-                                 anchor,
+                                 transform_origin,
                                  position,
                                  bounds,
                                  true,
                                  false);
     clipping_layer->SetMasksToBounds(true);
 
     scoped_ptr<LayerImpl> child =
         LayerImpl::Create(host_impl().active_tree(), 456);
     Region touch_handler_region(gfx::Rect(10, 10, 50, 50));
     position = gfx::PointF(-50.f, -50.f);
     bounds = gfx::Size(300, 300);
-    SetLayerPropertiesForTesting(
-        child.get(), identity_matrix, anchor, position, bounds, true, false);
+    SetLayerPropertiesForTesting(child.get(),
+                                 identity_matrix,
+                                 transform_origin,
+                                 position,
+                                 bounds,
+                                 true,
+                                 false);
     child->SetDrawsContent(true);
     child->SetTouchEventHandlerRegion(touch_handler_region);
     clipping_layer->AddChild(child.Pass());
     root->AddChild(clipping_layer.Pass());
   }
 
   host_impl().SetViewportSize(root->bounds());
   host_impl().active_tree()->SetRootLayer(root.Pass());
   host_impl().active_tree()->UpdateDrawProperties();
 
@@ skipping 37 matching lines @@
   test_point = gfx::Point(34, 34);
   result_layer =
       host_impl().active_tree()->FindLayerThatIsHitByPointInTouchHandlerRegion(
           test_point);
   ASSERT_TRUE(result_layer);
   EXPECT_EQ(456, result_layer->id());
 }
 
 TEST_F(LayerTreeImplTest, HitCheckingTouchHandlerOverlappingRegions) {
   gfx::Transform identity_matrix;
-  gfx::PointF anchor;
+  gfx::Point3F transform_origin;
 
   scoped_ptr<LayerImpl> root = LayerImpl::Create(host_impl().active_tree(), 1);
   SetLayerPropertiesForTesting(root.get(),
                                identity_matrix,
-                               anchor,
+                               transform_origin,
                                gfx::PointF(),
                                gfx::Size(100, 100),
                                true,
                                false);
   {
     scoped_ptr<LayerImpl> touch_layer =
         LayerImpl::Create(host_impl().active_tree(), 123);
     // this layer is positioned, and hit testing should correctly know where the
     // layer is located.
     gfx::PointF position;
     gfx::Size bounds(50, 50);
     SetLayerPropertiesForTesting(touch_layer.get(),
                                  identity_matrix,
-                                 anchor,
+                                 transform_origin,
                                  position,
                                  bounds,
                                  true,
                                  false);
     touch_layer->SetDrawsContent(true);
     touch_layer->SetTouchEventHandlerRegion(gfx::Rect(0, 0, 50, 50));
     root->AddChild(touch_layer.Pass());
   }
 
   {
     scoped_ptr<LayerImpl> notouch_layer =
         LayerImpl::Create(host_impl().active_tree(), 1234);
     // this layer is positioned, and hit testing should correctly know where the
     // layer is located.
     gfx::PointF position(0, 25);
     gfx::Size bounds(50, 50);
     SetLayerPropertiesForTesting(notouch_layer.get(),
                                  identity_matrix,
-                                 anchor,
+                                 transform_origin,
                                  position,
                                  bounds,
                                  true,
                                  false);
     notouch_layer->SetDrawsContent(true);
     root->AddChild(notouch_layer.Pass());
   }
 
   host_impl().SetViewportSize(root->bounds());
   host_impl().active_tree()->SetRootLayer(root.Pass());
@@ skipping 34 matching lines @@
 
   test_point = gfx::Point(35, 65);
   result_layer =
       host_impl().active_tree()->FindLayerThatIsHitByPointInTouchHandlerRegion(
           test_point);
   EXPECT_FALSE(result_layer);
 }
 
 }  // namespace
 }  // namespace cc