cc: Fix draw transform computation for non-drawn layers

cc/trees/layer_tree_host_common_unittest.cc

 // Copyright 2011 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "cc/trees/layer_tree_host_common.h"
 
 #include <algorithm>
 #include <set>
 #include <vector>
 
@@ skipping 153 matching lines @@
   child->SetOpacity(0.f);
   SetLayerPropertiesForTesting(grand_child, identity_matrix, gfx::Point3F(),
                                gfx::PointF(10, 10), gfx::Size(100, 100), true,
                                false, false);
   grand_child->SetTouchEventHandlerRegion(gfx::Rect(0, 0, 100, 100));
 
   ExecuteCalculateDrawProperties(parent);
 
   // Check that we've computed draw properties for the subtree rooted at
   // |child|.
-  EXPECT_FALSE(child->draw_transform().IsIdentity());
-  EXPECT_FALSE(grand_child->draw_transform().IsIdentity());
+  EXPECT_FALSE(child->draw_properties().target_space_transform.IsIdentity());
+  EXPECT_FALSE(
+      grand_child->draw_properties().target_space_transform.IsIdentity());
 }
 
 TEST_F(LayerTreeHostCommonTest, TransformsForSingleLayer) {
   gfx::Transform identity_matrix;
   scoped_refptr<Layer> layer = Layer::Create(layer_settings());
 
   scoped_refptr<Layer> root = Layer::Create(layer_settings());
   SetLayerPropertiesForTesting(root.get(), identity_matrix, gfx::Point3F(),
                                gfx::PointF(), gfx::Size(1, 2), true, false);
   root->AddChild(layer);
@@ skipping 143 matching lines @@
       root.get(), kDeviceScale, kPageScale, scroll_layer->parent());
   gfx::Transform expected_transform = identity_matrix;
   gfx::PointF sub_layer_screen_position = kScrollLayerPosition - kScrollDelta;
   expected_transform.Translate(MathUtil::Round(sub_layer_screen_position.x() *
                                                kPageScale * kDeviceScale),
                                MathUtil::Round(sub_layer_screen_position.y() *
                                                kPageScale * kDeviceScale));
   expected_transform.Scale(kPageScale * kDeviceScale,
                            kPageScale * kDeviceScale);
   EXPECT_TRANSFORMATION_MATRIX_EQ(expected_transform,
-                                  sublayer->draw_transform());
+                                  sublayer->DrawTransform());
   EXPECT_TRANSFORMATION_MATRIX_EQ(expected_transform,
                                   sublayer->screen_space_transform());
 
   gfx::Transform arbitrary_translate;
   const float kTranslateX = 10.6f;
   const float kTranslateY = 20.6f;
   arbitrary_translate.Translate(kTranslateX, kTranslateY);
   SetLayerPropertiesForTesting(scroll_layer, arbitrary_translate,
                                gfx::Point3F(), gfx::PointF(), gfx::Size(10, 20),
                                true, false, false);
   root->layer_tree_impl()->property_trees()->needs_rebuild = true;
   ExecuteCalculateDrawProperties(
       root.get(), kDeviceScale, kPageScale, scroll_layer->parent());
   expected_transform.MakeIdentity();
   expected_transform.Translate(
       MathUtil::Round(kTranslateX * kPageScale * kDeviceScale +
                       sub_layer_screen_position.x() * kPageScale *
                           kDeviceScale),
       MathUtil::Round(kTranslateY * kPageScale * kDeviceScale +
                       sub_layer_screen_position.y() * kPageScale *
                           kDeviceScale));
   expected_transform.Scale(kPageScale * kDeviceScale,
                            kPageScale * kDeviceScale);
   EXPECT_TRANSFORMATION_MATRIX_EQ(expected_transform,
-                                  sublayer->draw_transform());
+                                  sublayer->DrawTransform());
 }
 
 TEST_F(LayerTreeHostCommonTest, TransformsForSimpleHierarchy) {
   gfx::Transform identity_matrix;
   scoped_refptr<Layer> root = Layer::Create(layer_settings());
   scoped_refptr<Layer> parent = Layer::Create(layer_settings());
   scoped_refptr<Layer> child = Layer::Create(layer_settings());
   scoped_refptr<Layer> grand_child = Layer::Create(layer_settings());
   root->AddChild(parent);
   parent->AddChild(child);
@@ skipping 129 matching lines @@
                                false);
   ExecuteCalculateDrawProperties(root);
 
   // Render surface should have been created now.
   ASSERT_TRUE(child->render_surface());
   ASSERT_EQ(child, child->render_target());
 
   // The child layer's draw transform should refer to its new render surface.
   // The screen-space transform, however, should still refer to the root.
   EXPECT_TRANSFORMATION_MATRIX_EQ(surface_sublayer_transform,
-                                  child->draw_transform());
+                                  child->DrawTransform());
   EXPECT_TRANSFORMATION_MATRIX_EQ(parent_composite_transform,
                                   child->screen_space_transform());
 
   // Because the grand_child is the only drawable content, the child's render
   // surface will tighten its bounds to the grand_child.  The scale at which the
   // surface's subtree is drawn must be removed from the composite transform.
   EXPECT_TRANSFORMATION_MATRIX_EQ(
       surface_sublayer_composite_transform,
       child->render_target()->render_surface()->draw_transform());
 
@@ skipping 38 matching lines @@
   expected_grand_child_screen_space_transform.Rotate(45.0);
   expected_grand_child_screen_space_transform.Translate(2.0, 2.0);
 
   // First compute draw properties with separate surfaces enabled.
   ExecuteCalculateDrawProperties(root);
 
   // The grand child's draw transform should be its offset wrt the child.
   gfx::Transform expected_grand_child_draw_transform;
   expected_grand_child_draw_transform.Translate(2.0, 2.0);
   EXPECT_TRANSFORMATION_MATRIX_EQ(expected_grand_child_draw_transform,
-                                  grand_child->draw_transform());
+                                  grand_child->DrawTransform());
   EXPECT_TRANSFORMATION_MATRIX_EQ(expected_grand_child_screen_space_transform,
                                   grand_child->screen_space_transform());
 
   ExecuteCalculateDrawPropertiesWithoutSeparateSurfaces(root);
 
   // With separate surfaces disabled, the grand child's draw transform should be
   // the same as its screen space transform.
   EXPECT_TRANSFORMATION_MATRIX_EQ(expected_grand_child_screen_space_transform,
-                                  grand_child->draw_transform());
+                                  grand_child->DrawTransform());
   EXPECT_TRANSFORMATION_MATRIX_EQ(expected_grand_child_screen_space_transform,
                                   grand_child->screen_space_transform());
 }
 
 TEST_F(LayerTreeHostCommonTest, TransformsForReplica) {
   LayerImpl* root = root_layer();
   LayerImpl* parent = AddChildToRoot<LayerImpl>();
   LayerImpl* child = AddChild<LayerImpl>(parent);
   LayerImpl* grand_child = AddChild<LayerImpl>(child);
   grand_child->SetDrawsContent(true);
@@ skipping 210 matching lines @@
   EXPECT_EQ(render_surface1, child_of_rs1->render_target());
   EXPECT_EQ(render_surface1, grand_child_of_rs1->render_target());
 
   EXPECT_EQ(render_surface2, render_surface2->render_target());
   EXPECT_EQ(render_surface2, child_of_rs2->render_target());
   EXPECT_EQ(render_surface2, grand_child_of_rs2->render_target());
 
   // Verify layer draw transforms note that draw transforms are described with
   // respect to the nearest ancestor render surface but screen space transforms
   // are described with respect to the root.
-  EXPECT_TRANSFORMATION_MATRIX_EQ(A, parent->draw_transform());
-  EXPECT_TRANSFORMATION_MATRIX_EQ(A * A, child_of_root->draw_transform());
+  EXPECT_TRANSFORMATION_MATRIX_EQ(A, parent->DrawTransform());
+  EXPECT_TRANSFORMATION_MATRIX_EQ(A * A, child_of_root->DrawTransform());
   EXPECT_TRANSFORMATION_MATRIX_EQ(A * A * A,
-                                  grand_child_of_root->draw_transform());
+                                  grand_child_of_root->DrawTransform());
 
-  EXPECT_TRANSFORMATION_MATRIX_EQ(SS1, render_surface1->draw_transform());
-  EXPECT_TRANSFORMATION_MATRIX_EQ(SS1 * A, child_of_rs1->draw_transform());
+  EXPECT_TRANSFORMATION_MATRIX_EQ(SS1, render_surface1->DrawTransform());
+  EXPECT_TRANSFORMATION_MATRIX_EQ(SS1 * A, child_of_rs1->DrawTransform());
   EXPECT_TRANSFORMATION_MATRIX_EQ(SS1 * A * A,
-                                  grand_child_of_rs1->draw_transform());
+                                  grand_child_of_rs1->DrawTransform());
 
-  EXPECT_TRANSFORMATION_MATRIX_EQ(SS2, render_surface2->draw_transform());
-  EXPECT_TRANSFORMATION_MATRIX_EQ(SS2 * A, child_of_rs2->draw_transform());
+  EXPECT_TRANSFORMATION_MATRIX_EQ(SS2, render_surface2->DrawTransform());
+  EXPECT_TRANSFORMATION_MATRIX_EQ(SS2 * A, child_of_rs2->DrawTransform());
   EXPECT_TRANSFORMATION_MATRIX_EQ(SS2 * A * A,
-                                  grand_child_of_rs2->draw_transform());
+                                  grand_child_of_rs2->DrawTransform());
 
   // Verify layer screen-space transforms
   //
   EXPECT_TRANSFORMATION_MATRIX_EQ(A, parent->screen_space_transform());
   EXPECT_TRANSFORMATION_MATRIX_EQ(A * A,
                                   child_of_root->screen_space_transform());
   EXPECT_TRANSFORMATION_MATRIX_EQ(
       A * A * A, grand_child_of_root->screen_space_transform());
 
   EXPECT_TRANSFORMATION_MATRIX_EQ(A * A,
@@ skipping 112 matching lines @@
 
   ExecuteCalculateDrawProperties(root);
 
   // The child's draw transform should have been taken by its surface.
   ASSERT_TRUE(child->render_surface());
   EXPECT_TRANSFORMATION_MATRIX_EQ(expected_child_draw_transform,
                                   child->render_surface()->draw_transform());
   EXPECT_TRANSFORMATION_MATRIX_EQ(
       expected_child_screen_space_transform,
       child->render_surface()->screen_space_transform());
-  EXPECT_TRANSFORMATION_MATRIX_EQ(identity_matrix, child->draw_transform());
+  EXPECT_TRANSFORMATION_MATRIX_EQ(identity_matrix, child->DrawTransform());
   EXPECT_TRANSFORMATION_MATRIX_EQ(expected_child_screen_space_transform,
                                   child->screen_space_transform());
   EXPECT_TRANSFORMATION_MATRIX_EQ(expected_grand_child_draw_transform,
-                                  grand_child->draw_transform());
+                                  grand_child->DrawTransform());
   EXPECT_TRANSFORMATION_MATRIX_EQ(expected_grand_child_screen_space_transform,
                                   grand_child->screen_space_transform());
   EXPECT_TRANSFORMATION_MATRIX_EQ(expected_great_grand_child_draw_transform,
-                                  great_grand_child->draw_transform());
+                                  great_grand_child->DrawTransform());
   EXPECT_TRANSFORMATION_MATRIX_EQ(
       expected_great_grand_child_screen_space_transform,
       great_grand_child->screen_space_transform());
 }
 
 TEST_F(LayerTreeHostCommonTest, LayerFullyContainedWithinClipInTargetSpace) {
   scoped_refptr<Layer> root = Layer::Create(layer_settings());
   scoped_refptr<Layer> child = Layer::Create(layer_settings());
   scoped_refptr<LayerWithForcedDrawsContent> grand_child =
       make_scoped_refptr(new LayerWithForcedDrawsContent(layer_settings()));
@@ skipping 56 matching lines @@
   SetLayerPropertiesForTesting(grand_child, identity_matrix, gfx::Point3F(),
                                gfx::PointF(), gfx::Size(10, 10), true, false,
                                false);
 
   ExecuteCalculateDrawProperties(root);
 
   ASSERT_TRUE(child->has_render_surface());
   // This is the real test, the rest are sanity checks.
   EXPECT_TRANSFORMATION_MATRIX_EQ(identity_matrix,
                                   child->render_surface()->draw_transform());
-  EXPECT_TRANSFORMATION_MATRIX_EQ(identity_matrix, child->draw_transform());
+  EXPECT_TRANSFORMATION_MATRIX_EQ(identity_matrix, child->DrawTransform());
   EXPECT_TRANSFORMATION_MATRIX_EQ(identity_matrix,
-                                  grand_child->draw_transform());
+                                  grand_child->DrawTransform());
 }
 
 TEST_F(LayerTreeHostCommonTest, TransformAboveRootLayer) {
   // Transformations applied at the root of the tree should be forwarded
   // to child layers instead of applied to the root RenderSurface.
   const gfx::Transform identity_matrix;
   LayerImpl* root = root_layer();
   root->SetDrawsContent(true);
   LayerImpl* child = AddChild<LayerImpl>(root);
   child->SetDrawsContent(true);
 
   child->SetScrollClipLayer(root->id());
 
   SetLayerPropertiesForTesting(root, identity_matrix, gfx::Point3F(),
                                gfx::PointF(), gfx::Size(20, 20), true, false,
                                true);
   SetLayerPropertiesForTesting(child, identity_matrix, gfx::Point3F(),
                                gfx::PointF(), gfx::Size(20, 20), true, false,
                                false);
 
   gfx::Transform translate;
   translate.Translate(50, 50);
   {
     LayerImplList render_surface_layer_list_impl;
+    root->layer_tree_impl()->IncrementRenderSurfaceListIdForTesting();
     LayerTreeHostCommon::CalcDrawPropsImplInputsForTesting inputs(
-        root, root->bounds(), translate, &render_surface_layer_list_impl);
+        root, root->bounds(), translate, &render_surface_layer_list_impl,
+        root->layer_tree_impl()->current_render_surface_list_id());
     inputs.property_trees->needs_rebuild = true;
     LayerTreeHostCommon::CalculateDrawProperties(&inputs);
     EXPECT_EQ(translate, root->draw_properties().target_space_transform);
     EXPECT_EQ(translate, child->draw_properties().target_space_transform);
     EXPECT_EQ(identity_matrix, root->render_surface()->draw_transform());
   }
 
   gfx::Transform scale;
   scale.Scale(2, 2);
   {
     LayerImplList render_surface_layer_list_impl;
+    root->layer_tree_impl()->IncrementRenderSurfaceListIdForTesting();
     LayerTreeHostCommon::CalcDrawPropsImplInputsForTesting inputs(
-        root, root->bounds(), scale, &render_surface_layer_list_impl);
+        root, root->bounds(), scale, &render_surface_layer_list_impl,
+        root->layer_tree_impl()->current_render_surface_list_id());
     inputs.property_trees->needs_rebuild = true;
     LayerTreeHostCommon::CalculateDrawProperties(&inputs);
     EXPECT_EQ(scale, root->draw_properties().target_space_transform);
     EXPECT_EQ(scale, child->draw_properties().target_space_transform);
     EXPECT_EQ(identity_matrix, root->render_surface()->draw_transform());
   }
 
   gfx::Transform rotate;
   rotate.Rotate(2);
   {
     LayerImplList render_surface_layer_list_impl;
+    root->layer_tree_impl()->IncrementRenderSurfaceListIdForTesting();
     LayerTreeHostCommon::CalcDrawPropsImplInputsForTesting inputs(
-        root, root->bounds(), rotate, &render_surface_layer_list_impl);
+        root, root->bounds(), rotate, &render_surface_layer_list_impl,
+        root->layer_tree_impl()->current_render_surface_list_id());
     inputs.property_trees->needs_rebuild = true;
     LayerTreeHostCommon::CalculateDrawProperties(&inputs);
     EXPECT_EQ(rotate, root->draw_properties().target_space_transform);
     EXPECT_EQ(rotate, child->draw_properties().target_space_transform);
     EXPECT_EQ(identity_matrix, root->render_surface()->draw_transform());
   }
 
   gfx::Transform composite;
   composite.ConcatTransform(translate);
   composite.ConcatTransform(scale);
   composite.ConcatTransform(rotate);
   {
     LayerImplList render_surface_layer_list_impl;
+    root->layer_tree_impl()->IncrementRenderSurfaceListIdForTesting();
     LayerTreeHostCommon::CalcDrawPropsImplInputsForTesting inputs(
-        root, root->bounds(), composite, &render_surface_layer_list_impl);
+        root, root->bounds(), composite, &render_surface_layer_list_impl,
+        root->layer_tree_impl()->current_render_surface_list_id());
     inputs.property_trees->needs_rebuild = true;
     LayerTreeHostCommon::CalculateDrawProperties(&inputs);
     EXPECT_EQ(composite, root->draw_properties().target_space_transform);
     EXPECT_EQ(composite, child->draw_properties().target_space_transform);
     EXPECT_EQ(identity_matrix, root->render_surface()->draw_transform());
   }
 
   // Verify it composes correctly with device scale.
   float device_scale_factor = 1.5f;
 
   {
     LayerImplList render_surface_layer_list_impl;
+    root->layer_tree_impl()->IncrementRenderSurfaceListIdForTesting();
     LayerTreeHostCommon::CalcDrawPropsImplInputsForTesting inputs(
-        root, root->bounds(), translate, &render_surface_layer_list_impl);
+        root, root->bounds(), translate, &render_surface_layer_list_impl,
+        root->layer_tree_impl()->current_render_surface_list_id());
     inputs.device_scale_factor = device_scale_factor;
     inputs.property_trees->needs_rebuild = true;
     LayerTreeHostCommon::CalculateDrawProperties(&inputs);
     gfx::Transform device_scaled_translate = translate;
     device_scaled_translate.Scale(device_scale_factor, device_scale_factor);
     EXPECT_EQ(device_scaled_translate,
               root->draw_properties().target_space_transform);
     EXPECT_EQ(device_scaled_translate,
               child->draw_properties().target_space_transform);
     EXPECT_EQ(identity_matrix, root->render_surface()->draw_transform());
   }
 
   // Verify it composes correctly with page scale.
   float page_scale_factor = 2.f;
 
   {
     LayerImplList render_surface_layer_list_impl;
+    root->layer_tree_impl()->IncrementRenderSurfaceListIdForTesting();
     LayerTreeHostCommon::CalcDrawPropsImplInputsForTesting inputs(
-        root, root->bounds(), translate, &render_surface_layer_list_impl);
+        root, root->bounds(), translate, &render_surface_layer_list_impl,
+        root->layer_tree_impl()->current_render_surface_list_id());
     inputs.page_scale_factor = page_scale_factor;
     inputs.page_scale_layer = root;
     inputs.property_trees->needs_rebuild = true;
     LayerTreeHostCommon::CalculateDrawProperties(&inputs);
     gfx::Transform page_scaled_translate = translate;
     page_scaled_translate.Scale(page_scale_factor, page_scale_factor);
     EXPECT_EQ(page_scaled_translate,
               root->draw_properties().target_space_transform);
     EXPECT_EQ(page_scaled_translate,
               child->draw_properties().target_space_transform);
     EXPECT_EQ(identity_matrix, root->render_surface()->draw_transform());
   }
 
   // Verify that it composes correctly with transforms directly on root layer.
   root->SetTransform(composite);
 
   {
     LayerImplList render_surface_layer_list_impl;
+    root->layer_tree_impl()->IncrementRenderSurfaceListIdForTesting();
     LayerTreeHostCommon::CalcDrawPropsImplInputsForTesting inputs(
-        root, root->bounds(), composite, &render_surface_layer_list_impl);
+        root, root->bounds(), composite, &render_surface_layer_list_impl,
+        root->layer_tree_impl()->current_render_surface_list_id());
     inputs.property_trees->needs_rebuild = true;
     LayerTreeHostCommon::CalculateDrawProperties(&inputs);
     gfx::Transform compositeSquared = composite;
     compositeSquared.ConcatTransform(composite);
     EXPECT_TRANSFORMATION_MATRIX_EQ(
         compositeSquared, root->draw_properties().target_space_transform);
     EXPECT_TRANSFORMATION_MATRIX_EQ(
         compositeSquared, child->draw_properties().target_space_transform);
     EXPECT_EQ(identity_matrix, root->render_surface()->draw_transform());
   }
@@ skipping 38 matching lines @@
   const gfx::Transform identity_matrix;
   SetLayerPropertiesForTesting(render_surface1, identity_matrix, gfx::Point3F(),
                                gfx::PointF(), gfx::Size(10, 10), true, false,
                                true);
   SetLayerPropertiesForTesting(child, identity_matrix, gfx::Point3F(),
                                gfx::PointF(), gfx::Size(10, 10), true, false,
                                false);
   render_surface1->SetOpacity(0.f);
 
   LayerImplList render_surface_layer_list;
+  parent->layer_tree_impl()->IncrementRenderSurfaceListIdForTesting();
   LayerTreeHostCommon::CalcDrawPropsImplInputsForTesting inputs(
-      parent, parent->bounds(), &render_surface_layer_list);
+      parent, parent->bounds(), &render_surface_layer_list,
+      parent->layer_tree_impl()->current_render_surface_list_id());
   inputs.can_adjust_raster_scales = true;
   LayerTreeHostCommon::CalculateDrawProperties(&inputs);
 
   // Since the layer is transparent, render_surface1->render_surface() should
   // not have gotten added anywhere.  Also, the drawable content rect should not
   // have been extended by the children.
   ASSERT_TRUE(parent->render_surface());
   EXPECT_EQ(0U, parent->render_surface()->layer_list().size());
   EXPECT_EQ(1U, render_surface_layer_list.size());
   EXPECT_EQ(parent->id(), render_surface_layer_list.at(0)->id());
@@ skipping 16 matching lines @@
                                true);
   SetLayerPropertiesForTesting(child, identity_matrix, gfx::Point3F(),
                                gfx::PointF(), gfx::Size(10, 10), true, false,
                                false);
   render_surface1->SetOpacity(0.f);
   FilterOperations filters;
   filters.Append(FilterOperation::CreateBlurFilter(1.5f));
   render_surface1->SetBackgroundFilters(filters);
 
   LayerImplList render_surface_layer_list;
+  parent->layer_tree_impl()->IncrementRenderSurfaceListIdForTesting();
   LayerTreeHostCommon::CalcDrawPropsImplInputsForTesting inputs(
-      parent, parent->bounds(), &render_surface_layer_list);
+      parent, parent->bounds(), &render_surface_layer_list,
+      parent->layer_tree_impl()->current_render_surface_list_id());
   inputs.can_adjust_raster_scales = true;
   LayerTreeHostCommon::CalculateDrawProperties(&inputs);
 
   // The layer is fully transparent, but has a background filter, so it
   // shouldn't be skipped.
   ASSERT_TRUE(parent->render_surface());
   EXPECT_EQ(1U, parent->render_surface()->layer_list().size());
   EXPECT_EQ(2U, render_surface_layer_list.size());
   EXPECT_EQ(gfx::RectF(0, 0, 10, 10),
             parent->render_surface()->DrawableContentRect());
@@ skipping 208 matching lines @@
 
   gfx::Transform flattened_rotation_about_y = rotation_about_y_axis;
   flattened_rotation_about_y.FlattenTo2d();
 
   ExecuteCalculateDrawProperties(root);
 
   EXPECT_TRUE(parent->render_surface());
   EXPECT_FALSE(child->render_surface());
   EXPECT_FALSE(grand_child->render_surface());
 
-  EXPECT_TRANSFORMATION_MATRIX_EQ(identity_matrix, child->draw_transform());
+  EXPECT_TRANSFORMATION_MATRIX_EQ(identity_matrix, child->DrawTransform());
   EXPECT_TRANSFORMATION_MATRIX_EQ(identity_matrix,
-                                  grand_child->draw_transform());
+                                  grand_child->DrawTransform());
 
   // The screen-space transform inherited by |child| and |grand_child| should
   // have been flattened at their render target. In particular, the fact that
   // |grand_child| happens to preserve 3d shouldn't affect this flattening.
   EXPECT_TRANSFORMATION_MATRIX_EQ(flattened_rotation_about_y,
                                   child->screen_space_transform());
   EXPECT_TRANSFORMATION_MATRIX_EQ(flattened_rotation_about_y,
                                   grand_child->screen_space_transform());
 }
 
@@ skipping 692 matching lines @@
   gfx::Transform expected_leaf_draw_transform_with_surfaces;
   expected_leaf_draw_transform_with_surfaces.Translate(16.0, 16.0);
 
   gfx::Transform expected_leaf_draw_transform_without_surfaces;
   expected_leaf_draw_transform_without_surfaces.Translate(30.0, 30.0);
 
   ExecuteCalculateDrawProperties(root);
   EXPECT_EQ(gfx::Rect(16, 16, 2000, 2000), leaf_node->clip_rect());
   EXPECT_EQ(gfx::Rect(16, 16, 2000, 2000), leaf_node->drawable_content_rect());
   EXPECT_EQ(expected_leaf_draw_transform_with_surfaces,
-            leaf_node->draw_transform());
+            leaf_node->DrawTransform());
 
   ExecuteCalculateDrawPropertiesWithoutSeparateSurfaces(root);
   EXPECT_EQ(gfx::Rect(6, 6, 396, 396), leaf_node->clip_rect());
   EXPECT_EQ(gfx::Rect(30, 30, 372, 372), leaf_node->drawable_content_rect());
   EXPECT_EQ(expected_leaf_draw_transform_without_surfaces,
-            leaf_node->draw_transform());
+            leaf_node->DrawTransform());
 
   ExecuteCalculateDrawProperties(root);
   EXPECT_EQ(gfx::Rect(16, 16, 2000, 2000), leaf_node->clip_rect());
   EXPECT_EQ(gfx::Rect(16, 16, 2000, 2000), leaf_node->drawable_content_rect());
   EXPECT_EQ(expected_leaf_draw_transform_with_surfaces,
-            leaf_node->draw_transform());
+            leaf_node->DrawTransform());
 }
 
 TEST_F(LayerTreeHostCommonTest, AnimationsForRenderSurfaceHierarchy) {
   LayerImpl* parent = root_layer();
   LayerImpl* render_surface1 = AddChildToRoot<LayerImpl>();
   LayerImpl* child_of_rs1 = AddChild<LayerImpl>(render_surface1);
   LayerImpl* grand_child_of_rs1 = AddChild<LayerImpl>(child_of_rs1);
   LayerImpl* render_surface2 = AddChild<LayerImpl>(render_surface1);
   LayerImpl* child_of_rs2 = AddChild<LayerImpl>(render_surface2);
   LayerImpl* grand_child_of_rs2 = AddChild<LayerImpl>(child_of_rs2);
@@ skipping 885 matching lines @@
                                gfx::PointF(5.f, 5.f), gfx::Size(50, 50), true,
                                false, false);
   SetLayerPropertiesForTesting(child2, identity_matrix, gfx::Point3F(),
                                gfx::PointF(75.f, 75.f), gfx::Size(50, 50), true,
                                false, false);
   SetLayerPropertiesForTesting(child3, identity_matrix, gfx::Point3F(),
                                gfx::PointF(125.f, 125.f), gfx::Size(50, 50),
                                true, false, false);
 
   LayerImplList render_surface_layer_list_impl;
+  root->layer_tree_impl()->IncrementRenderSurfaceListIdForTesting();
   // Now set the root render surface an empty clip.
   LayerTreeHostCommon::CalcDrawPropsImplInputsForTesting inputs(
-      root, gfx::Size(), &render_surface_layer_list_impl);
+      root, gfx::Size(), &render_surface_layer_list_impl,
+      root->layer_tree_impl()->current_render_surface_list_id());
 
   LayerTreeHostCommon::CalculateDrawProperties(&inputs);
   ASSERT_TRUE(root->render_surface());
   EXPECT_FALSE(root->is_clipped());
 
   gfx::Rect empty;
   EXPECT_EQ(empty, root->render_surface()->clip_rect());
   EXPECT_TRUE(root->render_surface()->is_clipped());
 
   // Visible content rect calculation will check if the target surface is
@@ skipping 81 matching lines @@
                                gfx::PointF(10.f, 10.f), gfx::Size(100, 100),
                                false, true, false);
   SetLayerPropertiesForTesting(grand_child, rotation, gfx::Point3F(),
                                gfx::PointF(), gfx::Size(100, 100), false, true,
                                false);
 
   ExecuteCalculateDrawProperties(root);
 
   // Though all layers have invertible transforms, matrix multiplication using
   // floating-point math makes the draw transform uninvertible.
-  EXPECT_FALSE(grand_child->draw_transform().IsInvertible());
+  EXPECT_FALSE(grand_child->DrawTransform().IsInvertible());
 
   // CalcDrawProps only skips a subtree when a layer's own transform is
   // uninvertible, not when its draw transform is invertible, since CDP makes
   // skipping decisions before computing a layer's draw transform. Property
   // trees make skipping decisions after computing draw transforms, so could be
   // made to skip layers with an uninvertible draw transform (once CDP is
   // deleted).
   EXPECT_EQ(gfx::Rect(grand_child->bounds()),
             grand_child->visible_layer_rect());
 }
@@ skipping 47 matching lines @@
   host_impl.InitializeRenderer(output_surface.get());
   host_impl.active_tree()->BuildPropertyTreesForTesting();
   bool update_lcd_text = false;
   host_impl.active_tree()->UpdateDrawProperties(update_lcd_text);
 
   LayerImpl* grand_child_ptr =
       host_impl.active_tree()->root_layer()->children()[0]->children()[0].get();
 
   // Though all layers have invertible transforms, matrix multiplication using
   // floating-point math makes the draw transform uninvertible.
-  EXPECT_FALSE(grand_child_ptr->draw_transform().IsInvertible());
+  EXPECT_FALSE(grand_child_ptr->DrawTransform().IsInvertible());
 
   // Since |grand_child| has an uninvertible draw transform, it is treated as
   // unoccluded (even though |occluding_child| comes later in draw order, and
   // hence potentially occludes it).
   gfx::Rect layer_bounds = gfx::Rect(grand_child_ptr->bounds());
   EXPECT_EQ(
       layer_bounds,
       grand_child_ptr->draw_properties()
           .occlusion_in_content_space.GetUnoccludedContentRect(layer_bounds));
 }
@@ skipping 1159 matching lines @@
   EXPECT_IDEAL_SCALE_EQ(device_scale_factor, child2);
 
   EXPECT_EQ(1u, render_surface_layer_list_impl()->size());
 
   // Verify parent transforms
   gfx::Transform expected_parent_transform;
   expected_parent_transform.Scale(device_scale_factor, device_scale_factor);
   EXPECT_TRANSFORMATION_MATRIX_EQ(expected_parent_transform,
                                   parent->screen_space_transform());
   EXPECT_TRANSFORMATION_MATRIX_EQ(expected_parent_transform,
-                                  parent->draw_transform());
+                                  parent->DrawTransform());
 
   // Verify results of transformed parent rects
   gfx::RectF parent_bounds(gfx::SizeF(parent->bounds()));
 
   gfx::RectF parent_draw_rect =
-      MathUtil::MapClippedRect(parent->draw_transform(), parent_bounds);
+      MathUtil::MapClippedRect(parent->DrawTransform(), parent_bounds);
   gfx::RectF parent_screen_space_rect =
       MathUtil::MapClippedRect(parent->screen_space_transform(), parent_bounds);
 
   gfx::RectF expected_parent_draw_rect(gfx::SizeF(parent->bounds()));
   expected_parent_draw_rect.Scale(device_scale_factor);
   EXPECT_FLOAT_RECT_EQ(expected_parent_draw_rect, parent_draw_rect);
   EXPECT_FLOAT_RECT_EQ(expected_parent_draw_rect, parent_screen_space_rect);
 
   // Verify child and child2 transforms. They should match.
   gfx::Transform expected_child_transform;
   expected_child_transform.Scale(device_scale_factor, device_scale_factor);
   expected_child_transform.Translate(child->position().x(),
                                      child->position().y());
   EXPECT_TRANSFORMATION_MATRIX_EQ(expected_child_transform,
-                                  child->draw_transform());
+                                  child->DrawTransform());
   EXPECT_TRANSFORMATION_MATRIX_EQ(expected_child_transform,
                                   child->screen_space_transform());
   EXPECT_TRANSFORMATION_MATRIX_EQ(expected_child_transform,
-                                  child2->draw_transform());
+                                  child2->DrawTransform());
   EXPECT_TRANSFORMATION_MATRIX_EQ(expected_child_transform,
                                   child2->screen_space_transform());
 
   // Verify results of transformed child and child2 rects. They should
   // match.
   gfx::RectF child_bounds(gfx::SizeF(child->bounds()));
 
   gfx::RectF child_draw_rect =
-      MathUtil::MapClippedRect(child->draw_transform(), child_bounds);
+      MathUtil::MapClippedRect(child->DrawTransform(), child_bounds);
   gfx::RectF child_screen_space_rect =
       MathUtil::MapClippedRect(child->screen_space_transform(), child_bounds);
 
   gfx::RectF child2_draw_rect =
-      MathUtil::MapClippedRect(child2->draw_transform(), child_bounds);
+      MathUtil::MapClippedRect(child2->DrawTransform(), child_bounds);
   gfx::RectF child2_screen_space_rect =
       MathUtil::MapClippedRect(child2->screen_space_transform(), child_bounds);
 
   gfx::RectF expected_child_draw_rect(child->position(),
                                       gfx::SizeF(child->bounds()));
   expected_child_draw_rect.Scale(device_scale_factor);
   EXPECT_FLOAT_RECT_EQ(expected_child_draw_rect, child_draw_rect);
   EXPECT_FLOAT_RECT_EQ(expected_child_draw_rect, child_screen_space_rect);
   EXPECT_FLOAT_RECT_EQ(expected_child_draw_rect, child2_draw_rect);
   EXPECT_FLOAT_RECT_EQ(expected_child_draw_rect, child2_screen_space_rect);
@@ skipping 58 matching lines @@
   EXPECT_FLOAT_EQ(max_2d_scale,
                   std::max(target_space_transform_scales.x(),
                            target_space_transform_scales.y()));
 
   EXPECT_EQ(3u, render_surface_layer_list_impl()->size());
 
   gfx::Transform expected_parent_draw_transform;
   expected_parent_draw_transform.Scale(device_scale_factor * page_scale_factor,
                                        device_scale_factor * page_scale_factor);
   EXPECT_TRANSFORMATION_MATRIX_EQ(expected_parent_draw_transform,
-                                  parent->draw_transform());
+                                  parent->DrawTransform());
 
   // The scale for the perspective surface is not known, so it is rendered 1:1
   // with the screen, and then scaled during drawing.
   gfx::Transform expected_perspective_surface_draw_transform;
   expected_perspective_surface_draw_transform.Translate(
       device_scale_factor * page_scale_factor *
       perspective_surface->position().x(),
       device_scale_factor * page_scale_factor *
       perspective_surface->position().y());
   expected_perspective_surface_draw_transform.PreconcatTransform(
       perspective_matrix);
   expected_perspective_surface_draw_transform.PreconcatTransform(
       scale_small_matrix);
   gfx::Transform expected_perspective_surface_layer_draw_transform;
   expected_perspective_surface_layer_draw_transform.Scale(
       device_scale_factor * page_scale_factor,
       device_scale_factor * page_scale_factor);
   EXPECT_TRANSFORMATION_MATRIX_EQ(
       expected_perspective_surface_draw_transform,
       perspective_surface->render_surface()->draw_transform());
   EXPECT_TRANSFORMATION_MATRIX_EQ(
       expected_perspective_surface_layer_draw_transform,
-      perspective_surface->draw_transform());
+      perspective_surface->DrawTransform());
 }
 
 TEST_F(LayerTreeHostCommonScalingTest, SmallIdealScale) {
   gfx::Transform parent_scale_matrix;
   SkMScalar initial_parent_scale = 1.75;
   parent_scale_matrix.Scale(initial_parent_scale, initial_parent_scale);
 
   gfx::Transform child_scale_matrix;
   SkMScalar initial_child_scale = 0.25;
   child_scale_matrix.Scale(initial_child_scale, initial_child_scale);
@@ skipping 106 matching lines @@
 
   // We should have two render surfaces. The root's render surface and child's
   // render surface (it needs one because it has a replica layer).
   EXPECT_EQ(2u, render_surface_layer_list_impl()->size());
 
   gfx::Transform expected_parent_transform;
   expected_parent_transform.Scale(device_scale_factor, device_scale_factor);
   EXPECT_TRANSFORMATION_MATRIX_EQ(expected_parent_transform,
                                   parent->screen_space_transform());
   EXPECT_TRANSFORMATION_MATRIX_EQ(expected_parent_transform,
-                                  parent->draw_transform());
+                                  parent->DrawTransform());
 
   gfx::Transform expected_draw_transform;
   expected_draw_transform.Scale(device_scale_factor, device_scale_factor);
   EXPECT_TRANSFORMATION_MATRIX_EQ(expected_draw_transform,
-                                  child->draw_transform());
+                                  child->DrawTransform());
 
   gfx::Transform expected_screen_space_transform;
   expected_screen_space_transform.Scale(device_scale_factor,
                                         device_scale_factor);
   expected_screen_space_transform.Translate(child->position().x(),
                                             child->position().y());
   EXPECT_TRANSFORMATION_MATRIX_EQ(expected_screen_space_transform,
                                   child->screen_space_transform());
 
   gfx::Transform expected_duplicate_child_draw_transform =
-      child->draw_transform();
-  EXPECT_TRANSFORMATION_MATRIX_EQ(child->draw_transform(),
-                                  duplicate_child_non_owner->draw_transform());
+      child->DrawTransform();
+  EXPECT_TRANSFORMATION_MATRIX_EQ(child->DrawTransform(),
+                                  duplicate_child_non_owner->DrawTransform());
   EXPECT_TRANSFORMATION_MATRIX_EQ(
       child->screen_space_transform(),
       duplicate_child_non_owner->screen_space_transform());
   EXPECT_EQ(child->drawable_content_rect(),
             duplicate_child_non_owner->drawable_content_rect());
   EXPECT_EQ(child->bounds(), duplicate_child_non_owner->bounds());
 
   gfx::Transform expected_render_surface_draw_transform;
   expected_render_surface_draw_transform.Translate(
       device_scale_factor * child->position().x(),
@@ skipping 182 matching lines @@
   child->SetOpacity(0.0f);
 
   // Add opacity animation.
   AddOpacityTransitionToController(
       child->layer_animation_controller(), 10.0, 0.0f, 1.0f, false);
 
   root->AddChild(std::move(child));
   root->SetHasRenderSurface(true);
 
   LayerImplList render_surface_layer_list;
+  root->layer_tree_impl()->IncrementRenderSurfaceListIdForTesting();
   LayerTreeHostCommon::CalcDrawPropsImplInputsForTesting inputs(
-      root.get(), root->bounds(), &render_surface_layer_list);
+      root.get(), root->bounds(), &render_surface_layer_list,
+      root->layer_tree_impl()->current_render_surface_list_id());
   inputs.can_adjust_raster_scales = true;
   LayerTreeHostCommon::CalculateDrawProperties(&inputs);
 
   // We should have one render surface and two layers. The child
   // layer should be included even though it is transparent.
   ASSERT_EQ(1u, render_surface_layer_list.size());
   ASSERT_EQ(2u, root->render_surface()->layer_list().size());
 }
 
 using LCDTextTestParam = std::tr1::tuple<bool, bool, bool>;
@@ skipping 249 matching lines @@
                                gfx::Point3F(), gfx::PointF(), gfx::Size(30, 30),
                                true, false, false);
   grand_child->SetDrawsContent(true);
   grand_child->SetHideLayerAndSubtree(true);
 
   child->AddChild(std::move(grand_child));
   root->AddChild(std::move(child));
   root->SetHasRenderSurface(true);
 
   LayerImplList render_surface_layer_list;
+  root->layer_tree_impl()->IncrementRenderSurfaceListIdForTesting();
   LayerTreeHostCommon::CalcDrawPropsImplInputsForTesting inputs(
-      root.get(), root->bounds(), &render_surface_layer_list);
+      root.get(), root->bounds(), &render_surface_layer_list,
+      root->layer_tree_impl()->current_render_surface_list_id());
   inputs.can_adjust_raster_scales = true;
   LayerTreeHostCommon::CalculateDrawProperties(&inputs);
 
   // We should have one render surface and two layers. The grand child has
   // hidden itself.
   ASSERT_EQ(1u, render_surface_layer_list.size());
   ASSERT_EQ(2u, root->render_surface()->layer_list().size());
   EXPECT_EQ(1, root->render_surface()->layer_list().at(0)->id());
   EXPECT_EQ(2, root->render_surface()->layer_list().at(1)->id());
 }
@@ skipping 24 matching lines @@
       LayerImpl::Create(host_impl.pending_tree(), 3);
   SetLayerPropertiesForTesting(grand_child.get(), identity_matrix,
                                gfx::Point3F(), gfx::PointF(), gfx::Size(30, 30),
                                true, false, false);
   grand_child->SetDrawsContent(true);
 
   child->AddChild(std::move(grand_child));
   root->AddChild(std::move(child));
 
   LayerImplList render_surface_layer_list;
+  root->layer_tree_impl()->IncrementRenderSurfaceListIdForTesting();
   LayerTreeHostCommon::CalcDrawPropsImplInputsForTesting inputs(
-      root.get(), root->bounds(), &render_surface_layer_list);
+      root.get(), root->bounds(), &render_surface_layer_list,
+      root->layer_tree_impl()->current_render_surface_list_id());
   inputs.can_adjust_raster_scales = true;
   LayerTreeHostCommon::CalculateDrawProperties(&inputs);
 
   // We should have one render surface and one layers. The child has
   // hidden itself and the grand child.
   ASSERT_EQ(1u, render_surface_layer_list.size());
   ASSERT_EQ(1u, root->render_surface()->layer_list().size());
   EXPECT_EQ(1, root->render_surface()->layer_list().at(0)->id());
 }
 
@@ skipping 77 matching lines @@
   copy_grand_parent_sibling_before_layer->SetHideLayerAndSubtree(true);
   copy_grand_parent_sibling_after_layer->SetHideLayerAndSubtree(true);
 
   std::vector<scoped_ptr<CopyOutputRequest>> copy_requests;
   copy_requests.push_back(
       CopyOutputRequest::CreateRequest(base::Bind(&EmptyCopyOutputCallback)));
   copy_layer->PassCopyRequests(&copy_requests);
   EXPECT_TRUE(copy_layer->HasCopyRequest());
 
   LayerImplList render_surface_layer_list;
+  root->layer_tree_impl()->IncrementRenderSurfaceListIdForTesting();
   LayerTreeHostCommon::CalcDrawPropsImplInputsForTesting inputs(
-      root.get(), root->bounds(), &render_surface_layer_list);
+      root.get(), root->bounds(), &render_surface_layer_list,
+      root->layer_tree_impl()->current_render_surface_list_id());
   inputs.can_adjust_raster_scales = true;
   LayerTreeHostCommon::CalculateDrawProperties(&inputs);
 
   EXPECT_GT(root->num_layer_or_descendants_with_copy_request(), 0);
   EXPECT_GT(
       copy_grand_parent_layer->num_layer_or_descendants_with_copy_request(), 0);
   EXPECT_GT(copy_parent_layer->num_layer_or_descendants_with_copy_request(), 0);
   EXPECT_GT(copy_layer->num_layer_or_descendants_with_copy_request(), 0);
   EXPECT_EQ(copy_child_layer->num_layer_or_descendants_with_copy_request(), 0);
   EXPECT_EQ(copy_grand_parent_sibling_before_layer
@@ skipping 74 matching lines @@
   copy_requests.push_back(
       CopyOutputRequest::CreateRequest(base::Bind(&EmptyCopyOutputCallback)));
   copy_layer->PassCopyRequests(&copy_requests);
   EXPECT_TRUE(copy_layer->HasCopyRequest());
 
   copy_layer->AddChild(std::move(copy_child));
   copy_parent->AddChild(std::move(copy_layer));
   root->AddChild(std::move(copy_parent));
 
   LayerImplList render_surface_layer_list;
+  root->layer_tree_impl()->IncrementRenderSurfaceListIdForTesting();
   LayerTreeHostCommon::CalcDrawPropsImplInputsForTesting inputs(
-      root.get(), root->bounds(), &render_surface_layer_list);
+      root.get(), root->bounds(), &render_surface_layer_list,
+      root->layer_tree_impl()->current_render_surface_list_id());
   inputs.can_adjust_raster_scales = true;
   LayerTreeHostCommon::CalculateDrawProperties(&inputs);
 
   // We should have two render surface, as the others are clipped out.
   ASSERT_EQ(2u, render_surface_layer_list.size());
   EXPECT_EQ(root->id(), render_surface_layer_list.at(0)->id());
 
   // The root render surface should only have 2 contributing layer, since the
   // other layers are empty/clipped away.
   ASSERT_EQ(2u, root->render_surface()->layer_list().size());
@@ skipping 549 matching lines @@
   child2->Set3dSortingContextId(1);
   child3->Set3dSortingContextId(1);
 
   child2->AddChild(std::move(child3));
   child1->AddChild(std::move(child2));
   root->AddChild(std::move(child1));
 
   {
     LayerImplList render_surface_layer_list;
     FakeLayerTreeHostImpl::RecursiveUpdateNumChildren(root.get());
+    root->layer_tree_impl()->IncrementRenderSurfaceListIdForTesting();
     LayerTreeHostCommon::CalcDrawPropsImplInputsForTesting inputs(
-        root.get(), root->bounds(), &render_surface_layer_list);
+        root.get(), root->bounds(), &render_surface_layer_list,
+        root->layer_tree_impl()->current_render_surface_list_id());
     inputs.can_render_to_separate_surface = true;
     LayerTreeHostCommon::CalculateDrawProperties(&inputs);
 
     EXPECT_EQ(2u, render_surface_layer_list.size());
 
     int count_represents_target_render_surface = 0;
     int count_represents_contributing_render_surface = 0;
     int count_represents_itself = 0;
     LayerIterator end = LayerIterator::End(&render_surface_layer_list);
     for (LayerIterator it = LayerIterator::Begin(&render_surface_layer_list);
          it != end; ++it) {
       if (it.represents_target_render_surface())
         count_represents_target_render_surface++;
       if (it.represents_contributing_render_surface())
         count_represents_contributing_render_surface++;
       if (it.represents_itself())
         count_represents_itself++;
     }
 
     // Two render surfaces.
     EXPECT_EQ(2, count_represents_target_render_surface);
     // Second render surface contributes to root render surface.
     EXPECT_EQ(1, count_represents_contributing_render_surface);
     // All 4 layers represent itself.
     EXPECT_EQ(4, count_represents_itself);
   }
 
   {
     LayerImplList render_surface_layer_list;
+    root->layer_tree_impl()->IncrementRenderSurfaceListIdForTesting();
     LayerTreeHostCommon::CalcDrawPropsImplInputsForTesting inputs(
-        root.get(), root->bounds(), &render_surface_layer_list);
+        root.get(), root->bounds(), &render_surface_layer_list,
+        root->layer_tree_impl()->current_render_surface_list_id());
     inputs.can_render_to_separate_surface = false;
     LayerTreeHostCommon::CalculateDrawProperties(&inputs);
 
     EXPECT_EQ(1u, render_surface_layer_list.size());
 
     int count_represents_target_render_surface = 0;
     int count_represents_contributing_render_surface = 0;
     int count_represents_itself = 0;
     LayerIterator end = LayerIterator::End(&render_surface_layer_list);
     for (LayerIterator it = LayerIterator::Begin(&render_surface_layer_list);
@@ skipping 562 matching lines @@
   scroller->AddChild(std::move(fixed));
   container->AddChild(std::move(scroller));
   root->AddChild(std::move(container));
 
   // Rounded to integers already.
   {
     gfx::Vector2dF scroll_delta(3.0, 5.0);
     scroll_layer->SetScrollDelta(scroll_delta);
 
     LayerImplList render_surface_layer_list;
+    root->layer_tree_impl()->IncrementRenderSurfaceListIdForTesting();
     LayerTreeHostCommon::CalcDrawPropsImplInputsForTesting inputs(
-        root.get(), root->bounds(), &render_surface_layer_list);
+        root.get(), root->bounds(), &render_surface_layer_list,
+        root->layer_tree_impl()->current_render_surface_list_id());
     LayerTreeHostCommon::CalculateDrawProperties(&inputs);
 
     EXPECT_TRANSFORMATION_MATRIX_EQ(
         container_layer->draw_properties().screen_space_transform,
         fixed_layer->draw_properties().screen_space_transform);
     EXPECT_VECTOR_EQ(
         fixed_layer->draw_properties().screen_space_transform.To2dTranslation(),
         container_offset);
     EXPECT_VECTOR_EQ(scroll_layer->draw_properties()
                          .screen_space_transform.To2dTranslation(),
                      container_offset - scroll_delta);
   }
 
   // Scroll delta requiring rounding.
   {
     gfx::Vector2dF scroll_delta(4.1f, 8.1f);
     scroll_layer->SetScrollDelta(scroll_delta);
 
     gfx::Vector2dF rounded_scroll_delta(4.f, 8.f);
 
     LayerImplList render_surface_layer_list;
+    root->layer_tree_impl()->IncrementRenderSurfaceListIdForTesting();
     LayerTreeHostCommon::CalcDrawPropsImplInputsForTesting inputs(
-        root.get(), root->bounds(), &render_surface_layer_list);
+        root.get(), root->bounds(), &render_surface_layer_list,
+        root->layer_tree_impl()->current_render_surface_list_id());
     LayerTreeHostCommon::CalculateDrawProperties(&inputs);
 
     EXPECT_TRANSFORMATION_MATRIX_EQ(
         container_layer->draw_properties().screen_space_transform,
         fixed_layer->draw_properties().screen_space_transform);
     EXPECT_VECTOR_EQ(
         fixed_layer->draw_properties().screen_space_transform.To2dTranslation(),
         container_offset);
     EXPECT_VECTOR_EQ(scroll_layer->draw_properties()
                          .screen_space_transform.To2dTranslation(),
                      container_offset - rounded_scroll_delta);
   }
 
   // Scale is applied earlier in the tree.
   {
     gfx::Transform scaled_container_transform = container_transform;
     scaled_container_transform.Scale3d(2.0, 2.0, 1.0);
     container_layer->SetTransform(scaled_container_transform);
     root->layer_tree_impl()->property_trees()->needs_rebuild = true;
     root->layer_tree_impl()
         ->property_trees()
         ->transform_tree.set_source_to_parent_updates_allowed(true);
 
     gfx::Vector2dF scroll_delta(4.5f, 8.5f);
     scroll_layer->SetScrollDelta(scroll_delta);
 
     LayerImplList render_surface_layer_list;
+    root->layer_tree_impl()->IncrementRenderSurfaceListIdForTesting();
     LayerTreeHostCommon::CalcDrawPropsImplInputsForTesting inputs(
-        root.get(), root->bounds(), &render_surface_layer_list);
+        root.get(), root->bounds(), &render_surface_layer_list,
+        root->layer_tree_impl()->current_render_surface_list_id());
     LayerTreeHostCommon::CalculateDrawProperties(&inputs);
 
     EXPECT_TRANSFORMATION_MATRIX_EQ(
         container_layer->draw_properties().screen_space_transform,
         fixed_layer->draw_properties().screen_space_transform);
     EXPECT_VECTOR_EQ(
         fixed_layer->draw_properties().screen_space_transform.To2dTranslation(),
         container_offset);
 
     container_layer->SetTransform(container_transform);
@@ skipping 62 matching lines @@
                                false, false);
   scroll_layer->PushScrollOffsetFromMainThread(scroll_offset);
   scroll_layer->SetScrollDelta(scroll_delta);
   scroll_layer->SetScrollCompensationAdjustment(main_scroll_fractional_part);
 
   scroller->AddChild(std::move(fixed));
   container->AddChild(std::move(scroller));
   root->AddChild(std::move(container));
 
   LayerImplList render_surface_layer_list;
+  root->layer_tree_impl()->IncrementRenderSurfaceListIdForTesting();
   LayerTreeHostCommon::CalcDrawPropsImplInputsForTesting inputs(
-      root.get(), root->bounds(), &render_surface_layer_list);
+      root.get(), root->bounds(), &render_surface_layer_list,
+      root->layer_tree_impl()->current_render_surface_list_id());
   LayerTreeHostCommon::CalculateDrawProperties(&inputs);
 
   EXPECT_TRANSFORMATION_MATRIX_EQ(
       container_layer->draw_properties().screen_space_transform,
       fixed_layer->draw_properties().screen_space_transform);
   EXPECT_VECTOR_EQ(
       fixed_layer->draw_properties().screen_space_transform.To2dTranslation(),
       container_offset);
 
   gfx::ScrollOffset effective_scroll_offset =
@@ skipping 52 matching lines @@
   AddAnimatedTransformToLayer(animated_layer, 1.0, start_operations,
                               end_operations);
 
   gfx::Vector2dF scroll_delta(5.f, 9.f);
   scroller->SetScrollDelta(scroll_delta);
 
   ExecuteCalculateDrawProperties(root);
 
   gfx::Vector2dF expected_draw_transform_translation(-7.5f, -13.5f);
   EXPECT_VECTOR2DF_EQ(expected_draw_transform_translation,
-                      scroller->draw_transform().To2dTranslation());
+                      scroller->DrawTransform().To2dTranslation());
 }
 
 class AnimationScaleFactorTrackingLayerImpl : public LayerImpl {
  public:
   static scoped_ptr<AnimationScaleFactorTrackingLayerImpl> Create(
       LayerTreeImpl* tree_impl,
       int id) {
     return make_scoped_ptr(
         new AnimationScaleFactorTrackingLayerImpl(tree_impl, id));
   }
@@ skipping 666 matching lines @@
 
   // Changing page-scale would affect ideal_contents_scale and
   // maximum_animation_contents_scale.
 
   float page_scale_factor = 3.f;
   float device_scale_factor = 1.0f;
   std::vector<LayerImpl*> render_surface_layer_list;
   gfx::Size device_viewport_size =
       gfx::Size(root_layer->bounds().width() * device_scale_factor,
                 root_layer->bounds().height() * device_scale_factor);
+  root_layer->layer_tree_impl()->IncrementRenderSurfaceListIdForTesting();
   LayerTreeHostCommon::CalcDrawPropsImplInputsForTesting inputs(
-      root_layer, device_viewport_size, &render_surface_layer_list);
+      root_layer, device_viewport_size, &render_surface_layer_list,
+      root_layer->layer_tree_impl()->current_render_surface_list_id());
 
   inputs.page_scale_factor = page_scale_factor;
   inputs.can_adjust_raster_scales = true;
   inputs.page_scale_layer = root_layer;
   LayerTreeHostCommon::CalculateDrawProperties(&inputs);
 
   EXPECT_FLOAT_EQ(3.f, root_layer->GetIdealContentsScale());
   EXPECT_FLOAT_EQ(9.f, child1_layer->GetIdealContentsScale());
   EXPECT_FLOAT_EQ(9.f, child1_layer->mask_layer()->GetIdealContentsScale());
   EXPECT_FLOAT_EQ(
@@ skipping 148 matching lines @@
                                identity_matrix,
                                gfx::Point3F(),
                                gfx::PointF(),
                                sublayer_size,
                                false,
                                false,
                                false);
   sublayer->SetDrawsContent(true);
 
   LayerImplList layer_impl_list;
+  root->layer_tree_impl()->IncrementRenderSurfaceListIdForTesting();
   LayerTreeHostCommon::CalcDrawPropsImplInputsForTesting inputs(
-      root, device_viewport_size, &layer_impl_list);
+      root, device_viewport_size, &layer_impl_list,
+      root->layer_tree_impl()->current_render_surface_list_id());
 
   LayerTreeHostCommon::CalculateDrawProperties(&inputs);
   EXPECT_EQ(gfx::Rect(root_size), sublayer->visible_layer_rect());
 
   root->SetBoundsDelta(gfx::Vector2dF(0.0, 50.0));
   LayerTreeHostCommon::CalculateDrawProperties(&inputs);
 
   gfx::Rect affected_by_delta(0, 0, root_size.width(),
                               root_size.height() + 50);
   EXPECT_EQ(affected_by_delta, sublayer->visible_layer_rect());
@@ skipping 1525 matching lines @@
   bool root_in_rsll =
       std::find(rsll->begin(), rsll->end(), root) != rsll->end();
   EXPECT_TRUE(root_in_rsll);
   bool render_surface2_in_rsll =
       std::find(rsll->begin(), rsll->end(), render_surface2) != rsll->end();
   EXPECT_FALSE(render_surface2_in_rsll);
 }
 
 }  // namespace
 }  // namespace cc