cc: Fix draw transform computation for non-drawn layers

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.h"
 #include "cc/layers/layer_impl.h"
@@ skipping 32 matching lines @@
                                   bool flatten_transform) {
   layer->SetTransform(transform);
   layer->SetTransformOrigin(transform_origin);
   layer->SetPosition(position);
   layer->SetBounds(bounds);
   layer->SetShouldFlattenTransform(flatten_transform);
 }
 
 void ExecuteCalculateDrawProperties(LayerImpl* root_layer) {
   std::vector<LayerImpl*> dummy_render_surface_layer_list;
+  root_layer->layer_tree_impl()->IncrementRenderSurfaceListIdForTesting();
   LayerTreeHostCommon::CalcDrawPropsImplInputsForTesting inputs(
-      root_layer, root_layer->bounds(), &dummy_render_surface_layer_list);
+      root_layer, root_layer->bounds(), &dummy_render_surface_layer_list,
+      root_layer->layer_tree_impl()->current_render_surface_list_id());
   inputs.inner_viewport_scroll_layer =
       root_layer->layer_tree_impl()->InnerViewportScrollLayer();
   inputs.outer_viewport_scroll_layer =
       root_layer->layer_tree_impl()->OuterViewportScrollLayer();
   LayerTreeHostCommon::CalculateDrawProperties(&inputs);
 }
 
 class LayerPositionConstraintTest : public testing::Test {
  public:
   LayerPositionConstraintTest()
@@ skipping 152 matching lines @@
   CommitAndUpdateImplPointers();
 
   // Case 1: scroll delta of 0, 0
   child_impl_->SetScrollDelta(gfx::Vector2d(0, 0));
   ExecuteCalculateDrawProperties(root_impl_);
 
   gfx::Transform expected_child_transform;
   gfx::Transform expected_grand_child_transform = expected_child_transform;
 
   EXPECT_TRANSFORMATION_MATRIX_EQ(expected_child_transform,
-                                  child_impl_->draw_transform());
+                                  child_impl_->DrawTransform());
   EXPECT_TRANSFORMATION_MATRIX_EQ(expected_grand_child_transform,
-                                  grand_child_impl_->draw_transform());
+                                  grand_child_impl_->DrawTransform());
 
   // Case 2: scroll delta of 10, 10
   child_impl_->SetScrollDelta(gfx::Vector2d(10, 10));
   child_impl_->SetDrawsContent(true);
   ExecuteCalculateDrawProperties(root_impl_);
 
   // Here the child is affected by scroll delta, but the fixed position
   // grand_child should not be affected.
   expected_child_transform.MakeIdentity();
   expected_child_transform.Translate(-10.0, -10.0);
 
   EXPECT_TRANSFORMATION_MATRIX_EQ(expected_child_transform,
-                                  child_impl_->draw_transform());
+                                  child_impl_->DrawTransform());
   EXPECT_TRANSFORMATION_MATRIX_EQ(expected_grand_child_transform,
-                                  grand_child_impl_->draw_transform());
+                                  grand_child_impl_->DrawTransform());
 
   // Case 3: fixed-container size delta of 20, 20
   SetFixedContainerSizeDelta(child_impl_, gfx::Vector2d(20, 20));
   ExecuteCalculateDrawProperties(root_impl_);
 
   // Top-left fixed-position layer should not be affected by container size.
   EXPECT_TRANSFORMATION_MATRIX_EQ(expected_child_transform,
-                                  child_impl_->draw_transform());
+                                  child_impl_->DrawTransform());
   EXPECT_TRANSFORMATION_MATRIX_EQ(expected_grand_child_transform,
-                                  grand_child_impl_->draw_transform());
+                                  grand_child_impl_->DrawTransform());
 
   // Case 4: Bottom-right fixed-position layer.
   grand_child_->SetPositionConstraint(fixed_to_bottom_right_);
   CommitAndUpdateImplPointers();
 
   child_impl_->SetScrollDelta(gfx::Vector2d(10, 10));
   SetFixedContainerSizeDelta(child_impl_, gfx::Vector2d(20, 20));
   ExecuteCalculateDrawProperties(root_impl_);
 
   // Bottom-right fixed-position layer moves as container resizes.
   expected_grand_child_transform.MakeIdentity();
   // Apply size delta from the child(container) layer.
   expected_grand_child_transform.Translate(20.0, 20.0);
 
   EXPECT_TRANSFORMATION_MATRIX_EQ(expected_child_transform,
-                                  child_impl_->draw_transform());
+                                  child_impl_->DrawTransform());
   EXPECT_TRANSFORMATION_MATRIX_EQ(expected_grand_child_transform,
-                                  grand_child_impl_->draw_transform());
+                                  grand_child_impl_->DrawTransform());
 }
 
 TEST_F(LayerPositionConstraintTest,
      ScrollCompensationForFixedPositionLayerWithDistantContainer) {
   // This test checks for correct scroll compensation when the fixed-position
   // container is NOT the direct parent of the fixed-position layer.
   child_->SetIsContainerForFixedPositionLayers(true);
   grand_child_->SetPosition(gfx::PointF(8.f, 6.f));
   great_grand_child_->SetPositionConstraint(fixed_to_top_left_);
 
   CommitAndUpdateImplPointers();
 
   // Case 1: scroll delta of 0, 0
   child_impl_->SetScrollDelta(gfx::Vector2d(0, 0));
   child_impl_->SetDrawsContent(true);
   ExecuteCalculateDrawProperties(root_impl_);
 
   gfx::Transform expected_child_transform;
   gfx::Transform expected_grand_child_transform;
   expected_grand_child_transform.Translate(8.0, 6.0);
 
   gfx::Transform expected_great_grand_child_transform =
       expected_grand_child_transform;
 
   EXPECT_TRANSFORMATION_MATRIX_EQ(expected_child_transform,
-                                  child_impl_->draw_transform());
+                                  child_impl_->DrawTransform());
   EXPECT_TRANSFORMATION_MATRIX_EQ(expected_grand_child_transform,
-                                  grand_child_impl_->draw_transform());
+                                  grand_child_impl_->DrawTransform());
   EXPECT_TRANSFORMATION_MATRIX_EQ(expected_great_grand_child_transform,
-                                  great_grand_child_impl_->draw_transform());
+                                  great_grand_child_impl_->DrawTransform());
 
   // Case 2: scroll delta of 10, 10
   child_impl_->SetScrollDelta(gfx::Vector2d(10, 10));
   ExecuteCalculateDrawProperties(root_impl_);
 
   // Here the child and grand_child are affected by scroll delta, but the fixed
   // position great_grand_child should not be affected.
   expected_child_transform.MakeIdentity();
   expected_child_transform.Translate(-10.0, -10.0);
   expected_grand_child_transform.MakeIdentity();
   expected_grand_child_transform.Translate(-2.0, -4.0);
   EXPECT_TRANSFORMATION_MATRIX_EQ(expected_child_transform,
-                                  child_impl_->draw_transform());
+                                  child_impl_->DrawTransform());
   EXPECT_TRANSFORMATION_MATRIX_EQ(expected_grand_child_transform,
-                                  grand_child_impl_->draw_transform());
+                                  grand_child_impl_->DrawTransform());
   EXPECT_TRANSFORMATION_MATRIX_EQ(expected_great_grand_child_transform,
-                                  great_grand_child_impl_->draw_transform());
+                                  great_grand_child_impl_->DrawTransform());
 
   // Case 3: fixed-container size delta of 20, 20
   SetFixedContainerSizeDelta(child_impl_, gfx::Vector2d(20, 20));
   ExecuteCalculateDrawProperties(root_impl_);
 
   // Top-left fixed-position layer should not be affected by container size.
   EXPECT_TRANSFORMATION_MATRIX_EQ(expected_child_transform,
-                                  child_impl_->draw_transform());
+                                  child_impl_->DrawTransform());
   EXPECT_TRANSFORMATION_MATRIX_EQ(expected_grand_child_transform,
-                                  grand_child_impl_->draw_transform());
+                                  grand_child_impl_->DrawTransform());
   EXPECT_TRANSFORMATION_MATRIX_EQ(expected_great_grand_child_transform,
-                                  great_grand_child_impl_->draw_transform());
+                                  great_grand_child_impl_->DrawTransform());
 
   // Case 4: Bottom-right fixed-position layer.
   great_grand_child_->SetPositionConstraint(fixed_to_bottom_right_);
   CommitAndUpdateImplPointers();
   child_impl_->SetScrollDelta(gfx::Vector2d(10, 10));
   SetFixedContainerSizeDelta(child_impl_, gfx::Vector2d(20, 20));
   ExecuteCalculateDrawProperties(root_impl_);
 
   // Bottom-right fixed-position layer moves as container resizes.
   expected_great_grand_child_transform.MakeIdentity();
   // Apply size delta from the child(container) layer.
   expected_great_grand_child_transform.Translate(20.0, 20.0);
   // Apply layer position from the grand child layer.
   expected_great_grand_child_transform.Translate(8.0, 6.0);
 
   EXPECT_TRANSFORMATION_MATRIX_EQ(expected_child_transform,
-                                  child_impl_->draw_transform());
+                                  child_impl_->DrawTransform());
   EXPECT_TRANSFORMATION_MATRIX_EQ(expected_grand_child_transform,
-                                  grand_child_impl_->draw_transform());
+                                  grand_child_impl_->DrawTransform());
   EXPECT_TRANSFORMATION_MATRIX_EQ(expected_great_grand_child_transform,
-                                  great_grand_child_impl_->draw_transform());
+                                  great_grand_child_impl_->DrawTransform());
 }
 
 TEST_F(LayerPositionConstraintTest,
      ScrollCompensationForFixedPositionLayerWithMultipleScrollDeltas) {
   // This test checks for correct scroll compensation when the fixed-position
   // container has multiple ancestors that have nonzero scroll delta before
   // reaching the space where the layer is fixed.
   gfx::Transform rotation_about_z;
   rotation_about_z.RotateAboutZAxis(90.0);
 
@@ skipping 15 matching lines @@
   gfx::Transform expected_grand_child_transform;
   expected_grand_child_transform.PreconcatTransform(
       rotation_about_z);  // child's local transform is inherited
   // translation because of position occurs before layer's local transform.
   expected_grand_child_transform.Translate(8.0, 6.0);
 
   gfx::Transform expected_great_grand_child_transform =
       expected_grand_child_transform;
 
   EXPECT_TRANSFORMATION_MATRIX_EQ(expected_child_transform,
-                                  child_impl_->draw_transform());
+                                  child_impl_->DrawTransform());
   EXPECT_TRANSFORMATION_MATRIX_EQ(expected_grand_child_transform,
-                                  grand_child_impl_->draw_transform());
+                                  grand_child_impl_->DrawTransform());
   EXPECT_TRANSFORMATION_MATRIX_EQ(expected_great_grand_child_transform,
-                                  great_grand_child_impl_->draw_transform());
+                                  great_grand_child_impl_->DrawTransform());
 
   // Case 2: scroll delta of 10, 20
   child_impl_->SetScrollDelta(gfx::Vector2d(10, 0));
   grand_child_impl_->SetScrollDelta(gfx::Vector2d(5, 0));
   ExecuteCalculateDrawProperties(root_impl_);
 
   // Here the child and grand_child are affected by scroll delta, but the fixed
   // position great_grand_child should not be affected.
   expected_child_transform.MakeIdentity();
   expected_child_transform.PreconcatTransform(rotation_about_z);
   expected_child_transform.Translate(-10.0, 0.0);  // scroll delta
 
   expected_grand_child_transform.MakeIdentity();
   expected_grand_child_transform.PreconcatTransform(
       rotation_about_z);  // child's local transform is inherited
   expected_grand_child_transform.Translate(
       -10.0, 0.0);  // child's scroll delta is inherited
   expected_grand_child_transform.Translate(-5.0,
                                            0.0);  // grand_child's scroll delta
   // translation because of position
   expected_grand_child_transform.Translate(8.0, 6.0);
 
   EXPECT_TRANSFORMATION_MATRIX_EQ(expected_child_transform,
-                                  child_impl_->draw_transform());
+                                  child_impl_->DrawTransform());
   EXPECT_TRANSFORMATION_MATRIX_EQ(expected_grand_child_transform,
-                                  grand_child_impl_->draw_transform());
+                                  grand_child_impl_->DrawTransform());
   EXPECT_TRANSFORMATION_MATRIX_EQ(expected_great_grand_child_transform,
-                                  great_grand_child_impl_->draw_transform());
+                                  great_grand_child_impl_->DrawTransform());
 }
 
 TEST_F(LayerPositionConstraintTest,
      ScrollCompensationForFixedPositionWithIntermediateSurfaceAndTransforms) {
   // This test checks for correct scroll compensation when the fixed-position
   // container contributes to a different render surface than the fixed-position
   // layer. In this case, the surface draw transforms also have to be accounted
   // for when checking the scroll delta.
   child_->SetIsContainerForFixedPositionLayers(true);
   grand_child_->SetPosition(gfx::PointF(8.f, 6.f));
@@ skipping 11 matching lines @@
   ExecuteCalculateDrawProperties(root_impl_);
 
   gfx::Transform expected_child_transform;
   gfx::Transform expected_surface_draw_transform;
   expected_surface_draw_transform.Translate(8.0, 6.0);
   gfx::Transform expected_grand_child_transform;
   gfx::Transform expected_great_grand_child_transform;
   expected_great_grand_child_transform.PreconcatTransform(rotation_about_z);
   EXPECT_TRUE(grand_child_impl_->render_surface());
   EXPECT_TRANSFORMATION_MATRIX_EQ(expected_child_transform,
-                                  child_impl_->draw_transform());
+                                  child_impl_->DrawTransform());
   EXPECT_TRANSFORMATION_MATRIX_EQ(
       expected_surface_draw_transform,
       grand_child_impl_->render_surface()->draw_transform());
   EXPECT_TRANSFORMATION_MATRIX_EQ(expected_grand_child_transform,
-                                  grand_child_impl_->draw_transform());
+                                  grand_child_impl_->DrawTransform());
   EXPECT_TRANSFORMATION_MATRIX_EQ(expected_great_grand_child_transform,
-                                  great_grand_child_impl_->draw_transform());
+                                  great_grand_child_impl_->DrawTransform());
 
   // Case 2: scroll delta of 10, 30
   child_impl_->SetScrollDelta(gfx::Vector2d(10, 30));
   child_impl_->SetDrawsContent(true);
   ExecuteCalculateDrawProperties(root_impl_);
 
   // Here the grand_child remains unchanged, because it scrolls along with the
   // render surface, and the translation is actually in the render surface. But,
   // the fixed position great_grand_child is more awkward: its actually being
   // drawn with respect to the render surface, but it needs to remain fixed with
   // resepct to a container beyond that surface. So, the net result is that,
   // unlike previous tests where the fixed position layer's transform remains
   // unchanged, here the fixed position layer's transform explicitly contains
   // the translation that cancels out the scroll.
   expected_child_transform.MakeIdentity();
   expected_child_transform.Translate(-10.0, -30.0);  // scroll delta
 
   expected_surface_draw_transform.MakeIdentity();
   expected_surface_draw_transform.Translate(-10.0, -30.0);  // scroll delta
   expected_surface_draw_transform.Translate(8.0, 6.0);
 
   expected_great_grand_child_transform.MakeIdentity();
   // explicit canceling out the scroll delta that gets embedded in the fixed
   // position layer's surface.
   expected_great_grand_child_transform.Translate(10.0, 30.0);
   expected_great_grand_child_transform.PreconcatTransform(rotation_about_z);
 
   EXPECT_TRUE(grand_child_impl_->render_surface());
   EXPECT_TRANSFORMATION_MATRIX_EQ(expected_child_transform,
-                                  child_impl_->draw_transform());
+                                  child_impl_->DrawTransform());
   EXPECT_TRANSFORMATION_MATRIX_EQ(
       expected_surface_draw_transform,
       grand_child_impl_->render_surface()->draw_transform());
   EXPECT_TRANSFORMATION_MATRIX_EQ(expected_grand_child_transform,
-                                  grand_child_impl_->draw_transform());
+                                  grand_child_impl_->DrawTransform());
   EXPECT_TRANSFORMATION_MATRIX_EQ(expected_great_grand_child_transform,
-                                  great_grand_child_impl_->draw_transform());
+                                  great_grand_child_impl_->DrawTransform());
 
   // Case 3: fixed-container size delta of 20, 20
   SetFixedContainerSizeDelta(child_impl_, gfx::Vector2d(20, 20));
   ExecuteCalculateDrawProperties(root_impl_);
 
   // Top-left fixed-position layer should not be affected by container size.
   EXPECT_TRANSFORMATION_MATRIX_EQ(expected_child_transform,
-                                  child_impl_->draw_transform());
+                                  child_impl_->DrawTransform());
   EXPECT_TRANSFORMATION_MATRIX_EQ(expected_grand_child_transform,
-                                  grand_child_impl_->draw_transform());
+                                  grand_child_impl_->DrawTransform());
   EXPECT_TRANSFORMATION_MATRIX_EQ(expected_great_grand_child_transform,
-                                  great_grand_child_impl_->draw_transform());
+                                  great_grand_child_impl_->DrawTransform());
 
   // Case 4: Bottom-right fixed-position layer.
   great_grand_child_->SetPositionConstraint(fixed_to_bottom_right_);
 
   CommitAndUpdateImplPointers();
   child_impl_->SetScrollDelta(gfx::Vector2d(10, 30));
   SetFixedContainerSizeDelta(child_impl_, gfx::Vector2d(20, 20));
 
   ExecuteCalculateDrawProperties(root_impl_);
 
   // Bottom-right fixed-position layer moves as container resizes.
   expected_great_grand_child_transform.MakeIdentity();
   // explicit canceling out the scroll delta that gets embedded in the fixed
   // position layer's surface.
   expected_great_grand_child_transform.Translate(10.0, 30.0);
   // Also apply size delta in the child(container) layer space.
   expected_great_grand_child_transform.Translate(20.0, 20.0);
   expected_great_grand_child_transform.PreconcatTransform(rotation_about_z);
 
   EXPECT_TRANSFORMATION_MATRIX_EQ(expected_child_transform,
-                                  child_impl_->draw_transform());
+                                  child_impl_->DrawTransform());
   EXPECT_TRANSFORMATION_MATRIX_EQ(expected_grand_child_transform,
-                                  grand_child_impl_->draw_transform());
+                                  grand_child_impl_->DrawTransform());
   EXPECT_TRANSFORMATION_MATRIX_EQ(expected_great_grand_child_transform,
-                                  great_grand_child_impl_->draw_transform());
+                                  great_grand_child_impl_->DrawTransform());
 }
 
 TEST_F(LayerPositionConstraintTest,
      ScrollCompensationForFixedPositionLayerWithMultipleIntermediateSurfaces) {
   // This test checks for correct scroll compensation when the fixed-position
   // container contributes to a different render surface than the fixed-position
   // layer, with additional render surfaces in-between. This checks that the
   // conversion to ancestor surfaces is accumulated properly in the final matrix
   // transform.
 
@@ skipping 43 matching lines @@
   expected_great_grand_child_surface_draw_transform.Translate(40.0, 60.0);
 
   gfx::Transform expected_great_grand_child_transform;
 
   gfx::Transform expected_fixed_position_child_transform;
   expected_fixed_position_child_transform.PreconcatTransform(rotation_about_z);
 
   EXPECT_TRUE(grand_child_impl_->render_surface());
   EXPECT_TRUE(great_grand_child_impl_->render_surface());
   EXPECT_TRANSFORMATION_MATRIX_EQ(expected_child_transform,
-                                  child_impl_->draw_transform());
+                                  child_impl_->DrawTransform());
   EXPECT_TRANSFORMATION_MATRIX_EQ(
       expected_grand_child_surface_draw_transform,
       grand_child_impl_->render_surface()->draw_transform());
   EXPECT_TRANSFORMATION_MATRIX_EQ(expected_grand_child_transform,
-                                  grand_child_impl_->draw_transform());
+                                  grand_child_impl_->DrawTransform());
   EXPECT_TRANSFORMATION_MATRIX_EQ(
       expected_great_grand_child_surface_draw_transform,
       great_grand_child_impl_->render_surface()->draw_transform());
   EXPECT_TRANSFORMATION_MATRIX_EQ(expected_great_grand_child_transform,
-                                  great_grand_child_impl_->draw_transform());
+                                  great_grand_child_impl_->DrawTransform());
   EXPECT_TRANSFORMATION_MATRIX_EQ(expected_fixed_position_child_transform,
-                                  fixed_position_child_impl->draw_transform());
+                                  fixed_position_child_impl->DrawTransform());
 
   // Case 2: scroll delta of 10, 30
   child_impl_->SetScrollDelta(gfx::Vector2d(10, 30));
   ExecuteCalculateDrawProperties(root_impl_);
 
   expected_child_transform.MakeIdentity();
   expected_child_transform.Translate(-10.0, -30.0);  // scroll delta
 
   expected_grand_child_surface_draw_transform.MakeIdentity();
   expected_grand_child_surface_draw_transform.Translate(-10.0,
                                                         -30.0);  // scroll delta
   expected_grand_child_surface_draw_transform.Translate(8.0, 6.0);
 
   // grand_child, great_grand_child, and great_grand_child's surface are not
   // expected to change, since they are all not fixed, and they are all drawn
   // with respect to grand_child's surface that already has the scroll delta
   // accounted for.
 
   // But the great-great grandchild, "fixed_position_child", should have a
   // transform that explicitly cancels out the scroll delta.
   expected_fixed_position_child_transform.MakeIdentity();
   expected_fixed_position_child_transform.Translate(10.0, 30.0);
   expected_fixed_position_child_transform.PreconcatTransform(rotation_about_z);
 
   EXPECT_TRUE(grand_child_impl_->render_surface());
   EXPECT_TRUE(great_grand_child_impl_->render_surface());
   EXPECT_TRANSFORMATION_MATRIX_EQ(expected_child_transform,
-                                  child_impl_->draw_transform());
+                                  child_impl_->DrawTransform());
   EXPECT_TRANSFORMATION_MATRIX_EQ(
       expected_grand_child_surface_draw_transform,
       grand_child_impl_->render_surface()->draw_transform());
   EXPECT_TRANSFORMATION_MATRIX_EQ(expected_grand_child_transform,
-                                  grand_child_impl_->draw_transform());
+                                  grand_child_impl_->DrawTransform());
   EXPECT_TRANSFORMATION_MATRIX_EQ(
       expected_great_grand_child_surface_draw_transform,
       great_grand_child_impl_->render_surface()->draw_transform());
   EXPECT_TRANSFORMATION_MATRIX_EQ(expected_great_grand_child_transform,
-                                  great_grand_child_impl_->draw_transform());
+                                  great_grand_child_impl_->DrawTransform());
   EXPECT_TRANSFORMATION_MATRIX_EQ(expected_fixed_position_child_transform,
-                                  fixed_position_child_impl->draw_transform());
+                                  fixed_position_child_impl->DrawTransform());
 
   // Case 3: fixed-container size delta of 20, 20
   SetFixedContainerSizeDelta(child_impl_, gfx::Vector2d(20, 20));
   ExecuteCalculateDrawProperties(root_impl_);
 
   // Top-left fixed-position layer should not be affected by container size.
   EXPECT_TRANSFORMATION_MATRIX_EQ(expected_child_transform,
-                                  child_impl_->draw_transform());
+                                  child_impl_->DrawTransform());
   EXPECT_TRANSFORMATION_MATRIX_EQ(expected_grand_child_transform,
-                                  grand_child_impl_->draw_transform());
+                                  grand_child_impl_->DrawTransform());
   EXPECT_TRANSFORMATION_MATRIX_EQ(expected_great_grand_child_transform,
-                                  great_grand_child_impl_->draw_transform());
+                                  great_grand_child_impl_->DrawTransform());
   EXPECT_TRANSFORMATION_MATRIX_EQ(expected_fixed_position_child_transform,
-                                  fixed_position_child_impl->draw_transform());
+                                  fixed_position_child_impl->DrawTransform());
 
   // Case 4: Bottom-right fixed-position layer.
   fixed_position_child->SetPositionConstraint(fixed_to_bottom_right_);
   CommitAndUpdateImplPointers();
   fixed_position_child_impl = great_grand_child_impl_->children()[0].get();
   child_impl_->SetScrollDelta(gfx::Vector2d(10, 30));
   SetFixedContainerSizeDelta(child_impl_, gfx::Vector2d(20, 20));
   ExecuteCalculateDrawProperties(root_impl_);
 
   // Bottom-right fixed-position layer moves as container resizes.
   expected_fixed_position_child_transform.MakeIdentity();
   // explicit canceling out the scroll delta that gets embedded in the fixed
   // position layer's surface.
   expected_fixed_position_child_transform.Translate(10.0, 30.0);
   // Also apply size delta in the child(container) layer space.
   expected_fixed_position_child_transform.Translate(20.0, 20.0);
   expected_fixed_position_child_transform.PreconcatTransform(rotation_about_z);
 
   EXPECT_TRANSFORMATION_MATRIX_EQ(expected_child_transform,
-                                  child_impl_->draw_transform());
+                                  child_impl_->DrawTransform());
   EXPECT_TRANSFORMATION_MATRIX_EQ(expected_grand_child_transform,
-                                  grand_child_impl_->draw_transform());
+                                  grand_child_impl_->DrawTransform());
   EXPECT_TRANSFORMATION_MATRIX_EQ(expected_great_grand_child_transform,
-                                  great_grand_child_impl_->draw_transform());
+                                  great_grand_child_impl_->DrawTransform());
   EXPECT_TRANSFORMATION_MATRIX_EQ(expected_fixed_position_child_transform,
-                                  fixed_position_child_impl->draw_transform());
+                                  fixed_position_child_impl->DrawTransform());
 }
 
 TEST_F(
     LayerPositionConstraintTest,
     ScrollCompensationForFixedPositionLayerWithMultipleSurfacesAndTransforms) {
   // This test checks for correct scroll compensation when the fixed-position
   // container contributes to a different render surface than the fixed-position
   // layer, with additional render surfaces in-between, and the fixed-position
   // container is transformed. This checks that the conversion to ancestor
   // surfaces is accumulated properly in the final matrix transform.
@@ skipping 48 matching lines @@
   expected_great_grand_child_surface_draw_transform.Translate(40.0, 60.0);
 
   gfx::Transform expected_great_grand_child_transform;
 
   gfx::Transform expected_fixed_position_child_transform;
   expected_fixed_position_child_transform.PreconcatTransform(rotation_about_z);
 
   EXPECT_TRUE(grand_child_impl_->render_surface());
   EXPECT_TRUE(great_grand_child_impl_->render_surface());
   EXPECT_TRANSFORMATION_MATRIX_EQ(expected_child_transform,
-                                  child_impl_->draw_transform());
+                                  child_impl_->DrawTransform());
   EXPECT_TRANSFORMATION_MATRIX_EQ(
       expected_grand_child_surface_draw_transform,
       grand_child_impl_->render_surface()->draw_transform());
   EXPECT_TRANSFORMATION_MATRIX_EQ(expected_grand_child_transform,
-                                  grand_child_impl_->draw_transform());
+                                  grand_child_impl_->DrawTransform());
   EXPECT_TRANSFORMATION_MATRIX_EQ(
       expected_great_grand_child_surface_draw_transform,
       great_grand_child_impl_->render_surface()->draw_transform());
   EXPECT_TRANSFORMATION_MATRIX_EQ(expected_great_grand_child_transform,
-                                  great_grand_child_impl_->draw_transform());
+                                  great_grand_child_impl_->DrawTransform());
   EXPECT_TRANSFORMATION_MATRIX_EQ(expected_fixed_position_child_transform,
-                                  fixed_position_child_impl->draw_transform());
+                                  fixed_position_child_impl->DrawTransform());
 
   // Case 2: scroll delta of 10, 30
   child_impl_->SetScrollDelta(gfx::Vector2d(10, 30));
   ExecuteCalculateDrawProperties(root_impl_);
 
   expected_child_transform.MakeIdentity();
   expected_child_transform.PreconcatTransform(rotation_about_z);
   expected_child_transform.Translate(-10.0, -30.0);  // scroll delta
 
   expected_grand_child_surface_draw_transform.MakeIdentity();
@@ skipping 12 matching lines @@
   // transform that explicitly cancels out the scroll delta.
   expected_fixed_position_child_transform.MakeIdentity();
   // explicit canceling out the scroll delta that gets embedded in the fixed
   // position layer's surface.
   expected_fixed_position_child_transform.Translate(10.0, 30.0);
   expected_fixed_position_child_transform.PreconcatTransform(rotation_about_z);
 
   EXPECT_TRUE(grand_child_impl_->render_surface());
   EXPECT_TRUE(great_grand_child_impl_->render_surface());
   EXPECT_TRANSFORMATION_MATRIX_EQ(expected_child_transform,
-                                  child_impl_->draw_transform());
+                                  child_impl_->DrawTransform());
   EXPECT_TRANSFORMATION_MATRIX_EQ(
       expected_grand_child_surface_draw_transform,
       grand_child_impl_->render_surface()->draw_transform());
   EXPECT_TRANSFORMATION_MATRIX_EQ(expected_grand_child_transform,
-                                  grand_child_impl_->draw_transform());
+                                  grand_child_impl_->DrawTransform());
   EXPECT_TRANSFORMATION_MATRIX_EQ(
       expected_great_grand_child_surface_draw_transform,
       great_grand_child_impl_->render_surface()->draw_transform());
   EXPECT_TRANSFORMATION_MATRIX_EQ(expected_great_grand_child_transform,
-                                  great_grand_child_impl_->draw_transform());
+                                  great_grand_child_impl_->DrawTransform());
   EXPECT_TRANSFORMATION_MATRIX_EQ(expected_fixed_position_child_transform,
-                                  fixed_position_child_impl->draw_transform());
+                                  fixed_position_child_impl->DrawTransform());
 }
 
 TEST_F(LayerPositionConstraintTest,
      ScrollCompensationForFixedPositionLayerWithContainerLayerThatHasSurface) {
   // This test checks for correct scroll compensation when the fixed-position
   // container itself has a render surface. In this case, the container layer
   // should be treated like a layer that contributes to a render target, and
   // that render target is completely irrelevant; it should not affect the
   // scroll compensation.
   child_->SetIsContainerForFixedPositionLayers(true);
   child_->SetForceRenderSurface(true);
   grand_child_->SetPositionConstraint(fixed_to_top_left_);
 
   CommitAndUpdateImplPointers();
 
   // Case 1: scroll delta of 0, 0
   child_impl_->SetScrollDelta(gfx::Vector2d(0, 0));
   ExecuteCalculateDrawProperties(root_impl_);
 
   gfx::Transform expected_surface_draw_transform;
   gfx::Transform expected_child_transform;
   gfx::Transform expected_grand_child_transform;
   EXPECT_TRUE(child_impl_->render_surface());
   EXPECT_TRANSFORMATION_MATRIX_EQ(
       expected_surface_draw_transform,
       child_impl_->render_surface()->draw_transform());
   EXPECT_TRANSFORMATION_MATRIX_EQ(expected_child_transform,
-                                  child_impl_->draw_transform());
+                                  child_impl_->DrawTransform());
   EXPECT_TRANSFORMATION_MATRIX_EQ(expected_grand_child_transform,
-                                  grand_child_impl_->draw_transform());
+                                  grand_child_impl_->DrawTransform());
 
   // Case 2: scroll delta of 10, 10
   child_impl_->SetScrollDelta(gfx::Vector2d(10, 10));
   ExecuteCalculateDrawProperties(root_impl_);
 
   // The surface is translated by scroll delta, the child transform doesn't
   // change because it scrolls along with the surface, but the fixed position
   // grand_child needs to compensate for the scroll translation.
   expected_surface_draw_transform.MakeIdentity();
   expected_surface_draw_transform.Translate(-10.0, -10.0);
   expected_grand_child_transform.MakeIdentity();
   expected_grand_child_transform.Translate(10.0, 10.0);
 
   EXPECT_TRUE(child_impl_->render_surface());
   EXPECT_TRANSFORMATION_MATRIX_EQ(
       expected_surface_draw_transform,
       child_impl_->render_surface()->draw_transform());
   EXPECT_TRANSFORMATION_MATRIX_EQ(expected_child_transform,
-                                  child_impl_->draw_transform());
+                                  child_impl_->DrawTransform());
   EXPECT_TRANSFORMATION_MATRIX_EQ(expected_grand_child_transform,
-                                  grand_child_impl_->draw_transform());
+                                  grand_child_impl_->DrawTransform());
 
   // Case 3: fixed-container size delta of 20, 20
   SetFixedContainerSizeDelta(child_impl_, gfx::Vector2d(20, 20));
   ExecuteCalculateDrawProperties(root_impl_);
 
   // Top-left fixed-position layer should not be affected by container size.
   EXPECT_TRANSFORMATION_MATRIX_EQ(expected_child_transform,
-                                  child_impl_->draw_transform());
+                                  child_impl_->DrawTransform());
   EXPECT_TRANSFORMATION_MATRIX_EQ(expected_grand_child_transform,
-                                  grand_child_impl_->draw_transform());
+                                  grand_child_impl_->DrawTransform());
 
   // Case 4: Bottom-right fixed-position layer.
   grand_child_->SetPositionConstraint(fixed_to_bottom_right_);
   CommitAndUpdateImplPointers();
   child_impl_->SetScrollDelta(gfx::Vector2d(10, 10));
   SetFixedContainerSizeDelta(child_impl_, gfx::Vector2d(20, 20));
   ExecuteCalculateDrawProperties(root_impl_);
 
   // Bottom-right fixed-position layer moves as container resizes.
   expected_grand_child_transform.MakeIdentity();
   // The surface is translated by scroll delta, the child transform doesn't
   // change because it scrolls along with the surface, but the fixed position
   // grand_child needs to compensate for the scroll translation.
   expected_grand_child_transform.Translate(10.0, 10.0);
   // Apply size delta from the child(container) layer.
   expected_grand_child_transform.Translate(20.0, 20.0);
 
   EXPECT_TRANSFORMATION_MATRIX_EQ(expected_child_transform,
-                                  child_impl_->draw_transform());
+                                  child_impl_->DrawTransform());
   EXPECT_TRANSFORMATION_MATRIX_EQ(expected_grand_child_transform,
-                                  grand_child_impl_->draw_transform());
+                                  grand_child_impl_->DrawTransform());
 }
 
 TEST_F(LayerPositionConstraintTest,
      ScrollCompensationForFixedPositionLayerThatIsAlsoFixedPositionContainer) {
   // This test checks the scenario where a fixed-position layer also happens to
   // be a container itself for a descendant fixed position layer. In particular,
   // the layer should not accidentally be fixed to itself.
   child_->SetIsContainerForFixedPositionLayers(true);
   grand_child_->SetPositionConstraint(fixed_to_top_left_);
 
   // This should not confuse the grand_child. If correct, the grand_child would
   // still be considered fixed to its container (i.e. "child").
   grand_child_->SetIsContainerForFixedPositionLayers(true);
 
   CommitAndUpdateImplPointers();
 
   // Case 1: scroll delta of 0, 0
   child_impl_->SetScrollDelta(gfx::Vector2d(0, 0));
   child_impl_->SetDrawsContent(true);
   ExecuteCalculateDrawProperties(root_impl_);
 
   gfx::Transform expected_child_transform;
   gfx::Transform expected_grand_child_transform;
   EXPECT_TRANSFORMATION_MATRIX_EQ(expected_child_transform,
-                                  child_impl_->draw_transform());
+                                  child_impl_->DrawTransform());
   EXPECT_TRANSFORMATION_MATRIX_EQ(expected_grand_child_transform,
-                                  grand_child_impl_->draw_transform());
+                                  grand_child_impl_->DrawTransform());
 
   // Case 2: scroll delta of 10, 10
   child_impl_->SetScrollDelta(gfx::Vector2d(10, 10));
   ExecuteCalculateDrawProperties(root_impl_);
 
   // Here the child is affected by scroll delta, but the fixed position
   // grand_child should not be affected.
   expected_child_transform.MakeIdentity();
   expected_child_transform.Translate(-10.0, -10.0);
   EXPECT_TRANSFORMATION_MATRIX_EQ(expected_child_transform,
-                                  child_impl_->draw_transform());
+                                  child_impl_->DrawTransform());
   EXPECT_TRANSFORMATION_MATRIX_EQ(expected_grand_child_transform,
-                                  grand_child_impl_->draw_transform());
+                                  grand_child_impl_->DrawTransform());
 
   // Case 3: fixed-container size delta of 20, 20
   SetFixedContainerSizeDelta(child_impl_, gfx::Vector2d(20, 20));
   ExecuteCalculateDrawProperties(root_impl_);
 
   // Top-left fixed-position layer should not be affected by container size.
   EXPECT_TRANSFORMATION_MATRIX_EQ(expected_child_transform,
-                                  child_impl_->draw_transform());
+                                  child_impl_->DrawTransform());
   EXPECT_TRANSFORMATION_MATRIX_EQ(expected_grand_child_transform,
-                                  grand_child_impl_->draw_transform());
+                                  grand_child_impl_->DrawTransform());
 
   // Case 4: Bottom-right fixed-position layer.
   grand_child_->SetPositionConstraint(fixed_to_bottom_right_);
   CommitAndUpdateImplPointers();
   child_impl_->SetScrollDelta(gfx::Vector2d(10, 10));
   SetFixedContainerSizeDelta(child_impl_, gfx::Vector2d(20, 20));
 
   ExecuteCalculateDrawProperties(root_impl_);
 
   // Bottom-right fixed-position layer moves as container resizes.
   expected_grand_child_transform.MakeIdentity();
   // Apply size delta from the child(container) layer.
   expected_grand_child_transform.Translate(20.0, 20.0);
 
   EXPECT_TRANSFORMATION_MATRIX_EQ(expected_child_transform,
-                                  child_impl_->draw_transform());
+                                  child_impl_->DrawTransform());
   EXPECT_TRANSFORMATION_MATRIX_EQ(expected_grand_child_transform,
-                                  grand_child_impl_->draw_transform());
+                                  grand_child_impl_->DrawTransform());
 }
 
 TEST_F(LayerPositionConstraintTest,
      ScrollCompensationForFixedWithinFixedWithSameContainer) {
   // This test checks scroll compensation for a fixed-position layer that is
   // inside of another fixed-position layer and both share the same container.
   // In this situation, the parent fixed-position layer will receive
   // the scroll compensation, and the child fixed-position layer does not
   // need to compensate further.
   child_->SetIsContainerForFixedPositionLayers(true);
@@ skipping 13 matching lines @@
 
   // Here the child is affected by scroll delta, but the fixed position
   // grand_child should not be affected.
   gfx::Transform expected_child_transform;
   expected_child_transform.Translate(-10.0, -10.0);
 
   gfx::Transform expected_grand_child_transform;
   gfx::Transform expected_great_grand_child_transform;
 
   EXPECT_TRANSFORMATION_MATRIX_EQ(expected_child_transform,
-                                  child_impl_->draw_transform());
+                                  child_impl_->DrawTransform());
   EXPECT_TRANSFORMATION_MATRIX_EQ(expected_grand_child_transform,
-                                  grand_child_impl_->draw_transform());
+                                  grand_child_impl_->DrawTransform());
   EXPECT_TRANSFORMATION_MATRIX_EQ(expected_great_grand_child_transform,
-                                  great_grand_child_impl_->draw_transform());
+                                  great_grand_child_impl_->DrawTransform());
 
   // Case 2: sizeDelta
   child_impl_->SetScrollDelta(gfx::Vector2d(0, 0));
   SetFixedContainerSizeDelta(child_impl_, gfx::Vector2d(20, 20));
   ExecuteCalculateDrawProperties(root_impl_);
 
   expected_child_transform.MakeIdentity();
 
   expected_grand_child_transform.MakeIdentity();
 
   // Fixed to bottom-right, size-delta compensation is applied.
   expected_great_grand_child_transform.MakeIdentity();
   expected_great_grand_child_transform.Translate(20.0, 20.0);
 
   EXPECT_TRANSFORMATION_MATRIX_EQ(expected_child_transform,
-                                  child_impl_->draw_transform());
+                                  child_impl_->DrawTransform());
   EXPECT_TRANSFORMATION_MATRIX_EQ(expected_grand_child_transform,
-                                  grand_child_impl_->draw_transform());
+                                  grand_child_impl_->DrawTransform());
   EXPECT_TRANSFORMATION_MATRIX_EQ(expected_great_grand_child_transform,
-                                  great_grand_child_impl_->draw_transform());
+                                  great_grand_child_impl_->DrawTransform());
 }
 
 TEST_F(LayerPositionConstraintTest,
      ScrollCompensationForFixedWithinFixedWithInterveningContainer) {
   // This test checks scroll compensation for a fixed-position layer that is
   // inside of another fixed-position layer, but they have different fixed
   // position containers. In this situation, the child fixed-position element
   // would still have to compensate with respect to its container.
 
   // Add one more layer to the hierarchy for this test.
@@ skipping 27 matching lines @@
 
   // Since the container is a descendant of the fixed layer above,
   // the expected draw transform for container2 would not
   // include the scrollDelta that was applied to container1.
   gfx::Transform expected_container2_transform;
   expected_container2_transform.Translate(-30.0, 0.0);
 
   gfx::Transform expected_fixed_to_container2_transform;
 
   EXPECT_TRANSFORMATION_MATRIX_EQ(expected_container1_transform,
-                                  container1->draw_transform());
+                                  container1->DrawTransform());
 
   EXPECT_TRANSFORMATION_MATRIX_EQ(expected_fixed_to_container1_transform,
-                                  fixed_to_container1->draw_transform());
+                                  fixed_to_container1->DrawTransform());
 
   EXPECT_TRANSFORMATION_MATRIX_EQ(expected_container2_transform,
-                                  container2->draw_transform());
+                                  container2->DrawTransform());
 
   EXPECT_TRANSFORMATION_MATRIX_EQ(expected_fixed_to_container2_transform,
-                                  fixed_to_container2->draw_transform());
+                                  fixed_to_container2->DrawTransform());
 }
 
 TEST_F(LayerPositionConstraintTest,
        ScrollCompensationForInnerViewportBoundsDelta) {
   // This test checks for correct scroll compensation when the fixed-position
   // container is the inner viewport scroll layer and has non-zero bounds delta.
   scoped_refptr<Layer> fixed_child =
       make_scoped_refptr(new LayerWithForcedDrawsContent(layer_settings_));
   fixed_child->SetBounds(gfx::Size(300, 300));
   scroll_layer_->AddChild(fixed_child);
   fixed_child->SetPositionConstraint(fixed_to_top_left_);
 
   CommitAndUpdateImplPointers();
 
   LayerImpl* fixed_child_impl =
       root_impl_->layer_tree_impl()->FindActiveTreeLayerById(fixed_child->id());
 
   // Case 1: fixed-container size delta of 20, 20
   scroll_layer_impl_->SetScrollDelta(gfx::Vector2d(10, 10));
   scroll_layer_impl_->SetDrawsContent(true);
   SetFixedContainerSizeDelta(scroll_layer_impl_, gfx::Vector2d(20, 20));
   gfx::Transform expected_scroll_layer_transform;
   expected_scroll_layer_transform.Translate(-10.0, -10.0);
   gfx::Transform expected_fixed_child_transform;
 
   ExecuteCalculateDrawProperties(root_impl_);
 
   // Top-left fixed-position layer should not be affected by container size.
   EXPECT_TRANSFORMATION_MATRIX_EQ(expected_scroll_layer_transform,
-                                  scroll_layer_impl_->draw_transform());
+                                  scroll_layer_impl_->DrawTransform());
   EXPECT_TRANSFORMATION_MATRIX_EQ(expected_fixed_child_transform,
-                                  fixed_child_impl->draw_transform());
+                                  fixed_child_impl->DrawTransform());
 
   // Case 2: Bottom-right fixed-position layer.
   fixed_child->SetPositionConstraint(fixed_to_bottom_right_);
   CommitAndUpdateImplPointers();
   fixed_child_impl =
       root_impl_->layer_tree_impl()->FindActiveTreeLayerById(fixed_child->id());
 
   scroll_layer_impl_->SetScrollDelta(gfx::Vector2d(10, 10));
   SetFixedContainerSizeDelta(scroll_layer_impl_, gfx::Vector2d(20, 20));
   ExecuteCalculateDrawProperties(root_impl_);
 
   // Bottom-right fixed-position layer moves as container resizes.
   expected_fixed_child_transform.MakeIdentity();
   // Apply size delta.
   expected_fixed_child_transform.Translate(20.0, 20.0);
 
   EXPECT_TRANSFORMATION_MATRIX_EQ(expected_scroll_layer_transform,
-                                  scroll_layer_impl_->draw_transform());
+                                  scroll_layer_impl_->DrawTransform());
   EXPECT_TRANSFORMATION_MATRIX_EQ(expected_fixed_child_transform,
-                                  fixed_child_impl->draw_transform());
+                                  fixed_child_impl->DrawTransform());
 }
 
 void VerifySerializeAndDeserializeProto(bool is_fixed_position,
                                         bool is_fixed_to_right_edge,
                                         bool is_fixed_to_bottom_edge) {
   LayerPositionConstraint constraint;
   constraint.set_is_fixed_position(is_fixed_position);
   constraint.set_is_fixed_to_right_edge(is_fixed_to_right_edge);
   constraint.set_is_fixed_to_bottom_edge(is_fixed_to_bottom_edge);
   proto::LayerPositionConstraint proto;
@@ skipping 10 matching lines @@
   VerifySerializeAndDeserializeProto(true, false, true);
   VerifySerializeAndDeserializeProto(true, false, false);
   VerifySerializeAndDeserializeProto(false, true, true);
   VerifySerializeAndDeserializeProto(false, true, false);
   VerifySerializeAndDeserializeProto(false, false, true);
   VerifySerializeAndDeserializeProto(false, false, false);
 }
 
 }  // namespace
 }  // namespace cc