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

cc/layers/layer_position_constraint_unittest.cc

 // Copyright 2013 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/layers/layer_position_constraint.h"
 
 #include <vector>
 
 #include "cc/layers/layer_impl.h"
 #include "cc/test/fake_impl_proxy.h"
 #include "cc/test/fake_layer_tree_host_impl.h"
 #include "cc/test/geometry_test_utils.h"
 #include "cc/test/test_shared_bitmap_manager.h"
 #include "cc/trees/layer_tree_host_common.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 namespace cc {
 namespace {
 
 void SetLayerPropertiesForTesting(LayerImpl* layer,
                                   const gfx::Transform& transform,
-                                  const gfx::PointF& anchor,
+                                  const gfx::Point3F& transform_origin,
                                   const gfx::PointF& position,
                                   const gfx::Size& bounds,
                                   bool flatten_transform,
                                   bool is_3d_sorted) {
   layer->SetTransform(transform);
-  layer->SetAnchorPoint(anchor);
+  layer->SetTransformOrigin(transform_origin);
   layer->SetPosition(position);
   layer->SetBounds(bounds);
   layer->SetShouldFlattenTransform(flatten_transform);
   layer->SetIs3dSorted(is_3d_sorted);
   layer->SetContentBounds(bounds);
 }
 
 void ExecuteCalculateDrawProperties(LayerImpl* root_layer,
                                     float device_scale_factor,
                                     float page_scale_factor,
@@ skipping 41 matching lines @@
     scoped_ptr<LayerImpl> scroll_layer =
         LayerImpl::Create(host_impl_.active_tree(), 1);
     scoped_ptr<LayerImpl> child =
         LayerImpl::Create(host_impl_.active_tree(), 2);
     scoped_ptr<LayerImpl> grand_child =
         LayerImpl::Create(host_impl_.active_tree(), 3);
     scoped_ptr<LayerImpl> great_grand_child =
         LayerImpl::Create(host_impl_.active_tree(), 4);
 
     gfx::Transform IdentityMatrix;
-    gfx::PointF anchor;
+    gfx::Point3F transform_origin;
     gfx::PointF position;
     gfx::Size bounds(200, 200);
     gfx::Size clip_bounds(100, 100);
     SetLayerPropertiesForTesting(scroll_layer.get(),
                                  IdentityMatrix,
-                                 anchor,
+                                 transform_origin,
                                  position,
                                  bounds,
                                  true,
                                  false);
     SetLayerPropertiesForTesting(child.get(),
                                  IdentityMatrix,
-                                 anchor,
+                                 transform_origin,
                                  position,
                                  bounds,
                                  true,
                                  false);
     SetLayerPropertiesForTesting(grand_child.get(),
                                  IdentityMatrix,
-                                 anchor,
+                                 transform_origin,
                                  position,
                                  bounds,
                                  true,
                                  false);
     SetLayerPropertiesForTesting(great_grand_child.get(),
                                  IdentityMatrix,
-                                 anchor,
+                                 transform_origin,
                                  position,
                                  bounds,
                                  true,
                                  false);
 
     root->SetBounds(clip_bounds);
     scroll_layer->SetScrollClipLayer(root->id());
     child->SetScrollClipLayer(root->id());
     grand_child->SetScrollClipLayer(root->id());
 
@@ skipping 606 matching lines @@
   LayerImpl* grand_child = child->children()[0];
   LayerImpl* great_grand_child = grand_child->children()[0];
 
   // Add one more layer to the test tree for this scenario.
   {
     gfx::Transform identity;
     scoped_ptr<LayerImpl> fixed_position_child =
         LayerImpl::Create(host_impl_.active_tree(), 5);
     SetLayerPropertiesForTesting(fixed_position_child.get(),
                                  identity,
-                                 gfx::PointF(),
+                                 gfx::Point3F(),
                                  gfx::PointF(),
                                  gfx::Size(100, 100),
                                  true,
                                  false);
     great_grand_child->AddChild(fixed_position_child.Pass());
   }
   LayerImpl* fixed_position_child = great_grand_child->children()[0];
 
   // Actually set up the scenario here.
   child->SetIsContainerForFixedPositionLayers(true);
@@ skipping 408 matching lines @@
                                   fixed_to_container1->draw_transform());
 
   EXPECT_TRANSFORMATION_MATRIX_EQ(expected_container2_transform,
                                   container2->draw_transform());
 
   EXPECT_TRANSFORMATION_MATRIX_EQ(expected_fixed_to_container2_transform,
                                   fixed_to_container2->draw_transform());
 }
 }  // namespace
 }  // namespace cc