Create RenderSurface on Effect Tree

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 135 matching lines @@
 
 TEST_F(LayerTreeHostCommonTest, DoNotSkipLayersWithHandlers) {
   LayerImpl* parent = root_layer();
   LayerImpl* child = AddChild<LayerImpl>(parent);
   LayerImpl* grand_child = AddChild<LayerImpl>(child);
   child->SetDrawsContent(true);
   grand_child->SetDrawsContent(true);
 
   gfx::Transform identity_matrix;
   SetLayerPropertiesForTesting(parent, identity_matrix, gfx::Point3F(),
-                               gfx::PointF(), gfx::Size(100, 100), true, false,
-                               true);
+                               gfx::PointF(), gfx::Size(100, 100), true, false);
   SetLayerPropertiesForTesting(child, identity_matrix, gfx::Point3F(),
                                gfx::PointF(10, 10), gfx::Size(100, 100), true,
-                               false, false);
+                               false);
   // This would have previously caused us to skip our subtree, but this would be
   // wrong; we need up-to-date draw properties to do hit testing on the layers
   // with handlers.
   child->SetOpacity(0.f);
   SetLayerPropertiesForTesting(grand_child, identity_matrix, gfx::Point3F(),
                                gfx::PointF(10, 10), gfx::Size(100, 100), true,
-                               false, false);
+                               false);
   grand_child->SetTouchEventHandlerRegion(gfx::Rect(0, 0, 100, 100));
 
   ExecuteCalculateDrawProperties(parent);
 
+  EXPECT_TRUE(child->has_render_surface());
+  EXPECT_FALSE(grand_child->has_render_surface());
   // Check that we've computed draw properties for the subtree rooted at
   // |child|.
-  EXPECT_FALSE(child->draw_properties().target_space_transform.IsIdentity());
+  EXPECT_TRUE(child->draw_properties().target_space_transform.IsIdentity());
+  EXPECT_FALSE(child->render_surface()->draw_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(),
@@ skipping 1205 matching lines @@
   EXPECT_EQ(1.f, root->draw_opacity());
   EXPECT_EQ(1.f, parent->draw_opacity());
   EXPECT_EQ(0.5f, child1->draw_opacity());
   EXPECT_EQ(1.f, child2->draw_opacity());
   EXPECT_EQ(0.25f, grand_child->draw_opacity());
   EXPECT_EQ(0.125f, leaf_node1->draw_opacity());
   EXPECT_EQ(0.5f, leaf_node2->draw_opacity());
 }
 
 TEST_F(LayerTreeHostCommonTest, ForceRenderSurface) {
-  scoped_refptr<Layer> parent = Layer::Create(layer_settings());
-  scoped_refptr<Layer> render_surface1 = Layer::Create(layer_settings());
-  scoped_refptr<LayerWithForcedDrawsContent> child =
-      make_scoped_refptr(new LayerWithForcedDrawsContent(layer_settings()));
+  LayerImpl* parent = root_layer();
+  LayerImpl* render_surface1 = AddChildToRoot<LayerImpl>();
+  LayerImpl* child = AddChild<LayerImpl>(render_surface1);
+
+  const gfx::Transform identity_matrix;
+  SetLayerPropertiesForTesting(parent, identity_matrix, gfx::Point3F(),
+                               gfx::PointF(), gfx::Size(10, 10), true, false);
+  SetLayerPropertiesForTesting(render_surface1, identity_matrix, gfx::Point3F(),
+                               gfx::PointF(), gfx::Size(10, 10), true, false);
+  SetLayerPropertiesForTesting(child, identity_matrix, gfx::Point3F(),
+                               gfx::PointF(), gfx::Size(10, 10), true, false);
+
+  child->SetDrawsContent(true);
   render_surface1->SetForceRenderSurface(true);
 
-  host()->SetRootLayer(parent);
-
-  const gfx::Transform identity_matrix;
-  SetLayerPropertiesForTesting(parent.get(),
-                               identity_matrix,
-                               gfx::Point3F(),
-                               gfx::PointF(),
-                               gfx::Size(10, 10),
-                               true,
-                               false);
-  SetLayerPropertiesForTesting(render_surface1.get(),
-                               identity_matrix,
-                               gfx::Point3F(),
-                               gfx::PointF(),
-                               gfx::Size(10, 10),
-                               true,
-                               false);
-  SetLayerPropertiesForTesting(child.get(),
-                               identity_matrix,
-                               gfx::Point3F(),
-                               gfx::PointF(),
-                               gfx::Size(10, 10),
-                               true,
-                               false);
-
-  parent->AddChild(render_surface1);
-  render_surface1->AddChild(child);
-
-  // Sanity check before the actual test
-  EXPECT_FALSE(parent->has_render_surface());
-  EXPECT_FALSE(render_surface1->has_render_surface());
-
   {
-    LayerTreeHostCommon::CalcDrawPropsMainInputs inputs(parent.get(),
-                                                        parent->bounds());
-    LayerTreeHostCommon::CalculateDrawProperties(&inputs);
+    ExecuteCalculateDrawPropertiesWithPropertyTrees(parent);
 
     // The root layer always creates a render surface
     EXPECT_TRUE(parent->has_render_surface());
     EXPECT_TRUE(render_surface1->has_render_surface());
   }
 
   {
     render_surface1->SetForceRenderSurface(false);
-    LayerTreeHostCommon::CalcDrawPropsMainInputs inputs(parent.get(),
-                                                        parent->bounds());
-    LayerTreeHostCommon::CalculateDrawProperties(&inputs);
+    render_surface1->layer_tree_impl()->property_trees()->needs_rebuild = true;
+    ExecuteCalculateDrawPropertiesWithPropertyTrees(parent);
     EXPECT_TRUE(parent->has_render_surface());
     EXPECT_FALSE(render_surface1->has_render_surface());
   }
 }
 
 TEST_F(LayerTreeHostCommonTest, RenderSurfacesFlattenScreenSpaceTransform) {
   // Render surfaces act as a flattening point for their subtree, so should
   // always flatten the target-to-screen space transform seen by descendants.
 
   LayerImpl* root = root_layer();
@@ skipping 325 matching lines @@
                                true);
   SetLayerPropertiesForTesting(leaf_node1, identity_matrix, gfx::Point3F(),
                                gfx::PointF(), gfx::Size(100, 100), true, false,
                                false);
   SetLayerPropertiesForTesting(leaf_node2, identity_matrix, gfx::Point3F(),
                                gfx::PointF(), gfx::Size(100, 100), true, false,
                                false);
 
   // Case 1: Nothing is clipped. In this case, is_clipped is always false, with
   // or without surfaces.
+  root->SetHasRenderSurface(true);
+  child1->SetHasRenderSurface(true);
+  grand_child->SetHasRenderSurface(true);
   ExecuteCalculateDrawProperties(root);
   EXPECT_FALSE(root->is_clipped());
   EXPECT_FALSE(parent->is_clipped());
   EXPECT_FALSE(child1->is_clipped());
   EXPECT_FALSE(child2->is_clipped());
   EXPECT_FALSE(grand_child->is_clipped());
   EXPECT_FALSE(leaf_node1->is_clipped());
   EXPECT_FALSE(leaf_node2->is_clipped());
 
   ExecuteCalculateDrawPropertiesWithoutSeparateSurfaces(root);
   EXPECT_FALSE(root->is_clipped());
   EXPECT_FALSE(parent->is_clipped());
   EXPECT_FALSE(child1->is_clipped());
   EXPECT_FALSE(child2->is_clipped());
   EXPECT_FALSE(grand_child->is_clipped());
   EXPECT_FALSE(leaf_node1->is_clipped());
   EXPECT_FALSE(leaf_node2->is_clipped());
 
   // Case 2: The root is clipped. With surfaces, this only persists until the
   // next render surface. Without surfaces, the entire tree is clipped.
   root->SetMasksToBounds(true);
   host_impl()->active_tree()->property_trees()->needs_rebuild = true;
+  root->SetHasRenderSurface(true);
+  child1->SetHasRenderSurface(true);
+  grand_child->SetHasRenderSurface(true);
   ExecuteCalculateDrawProperties(root);
   EXPECT_TRUE(root->is_clipped());
   EXPECT_TRUE(parent->is_clipped());
   EXPECT_FALSE(child1->is_clipped());
   EXPECT_TRUE(child2->is_clipped());
   EXPECT_FALSE(grand_child->is_clipped());
   EXPECT_FALSE(leaf_node1->is_clipped());
   EXPECT_TRUE(leaf_node2->is_clipped());
 
   ExecuteCalculateDrawPropertiesWithoutSeparateSurfaces(root);
   EXPECT_TRUE(root->is_clipped());
   EXPECT_TRUE(parent->is_clipped());
   EXPECT_TRUE(child1->is_clipped());
   EXPECT_TRUE(child2->is_clipped());
   EXPECT_TRUE(grand_child->is_clipped());
   EXPECT_TRUE(leaf_node1->is_clipped());
   EXPECT_TRUE(leaf_node2->is_clipped());
 
   root->SetMasksToBounds(false);
 
   // Case 3: The parent is clipped. Again, with surfaces, this only persists
   // until the next render surface. Without surfaces, parent's entire subtree is
   // clipped.
   parent->SetMasksToBounds(true);
   host_impl()->active_tree()->property_trees()->needs_rebuild = true;
+  root->SetHasRenderSurface(true);
+  child1->SetHasRenderSurface(true);
+  grand_child->SetHasRenderSurface(true);
   ExecuteCalculateDrawProperties(root);
   EXPECT_FALSE(root->is_clipped());
   EXPECT_TRUE(parent->is_clipped());
   EXPECT_FALSE(child1->is_clipped());
   EXPECT_TRUE(child2->is_clipped());
   EXPECT_FALSE(grand_child->is_clipped());
   EXPECT_FALSE(leaf_node1->is_clipped());
   EXPECT_TRUE(leaf_node2->is_clipped());
 
   ExecuteCalculateDrawPropertiesWithoutSeparateSurfaces(root);
   EXPECT_FALSE(root->is_clipped());
   EXPECT_TRUE(parent->is_clipped());
   EXPECT_TRUE(child1->is_clipped());
   EXPECT_TRUE(child2->is_clipped());
   EXPECT_TRUE(grand_child->is_clipped());
   EXPECT_TRUE(leaf_node1->is_clipped());
   EXPECT_TRUE(leaf_node2->is_clipped());
 
   parent->SetMasksToBounds(false);
 
   // Case 4: child1 is clipped. With surfaces, only child1 is_clipped, since it
   // has no non-surface children. Without surfaces, child1's entire subtree is
   // clipped.
   child1->SetMasksToBounds(true);
   host_impl()->active_tree()->property_trees()->needs_rebuild = true;
+  root->SetHasRenderSurface(true);
+  child1->SetHasRenderSurface(true);
+  grand_child->SetHasRenderSurface(true);
   ExecuteCalculateDrawProperties(root);
   EXPECT_FALSE(root->is_clipped());
   EXPECT_FALSE(parent->is_clipped());
   EXPECT_TRUE(child1->is_clipped());
   EXPECT_FALSE(child2->is_clipped());
   EXPECT_FALSE(grand_child->is_clipped());
   EXPECT_FALSE(leaf_node1->is_clipped());
   EXPECT_FALSE(leaf_node2->is_clipped());
 
   ExecuteCalculateDrawPropertiesWithoutSeparateSurfaces(root);
   EXPECT_FALSE(root->is_clipped());
   EXPECT_FALSE(parent->is_clipped());
   EXPECT_TRUE(child1->is_clipped());
   EXPECT_FALSE(child2->is_clipped());
   EXPECT_TRUE(grand_child->is_clipped());
   EXPECT_TRUE(leaf_node1->is_clipped());
   EXPECT_FALSE(leaf_node2->is_clipped());
 
   child1->SetMasksToBounds(false);
 
   // Case 5: Only the leaf nodes are clipped. The behavior with and without
   // surfaces is the same.
   leaf_node1->SetMasksToBounds(true);
   leaf_node2->SetMasksToBounds(true);
   host_impl()->active_tree()->property_trees()->needs_rebuild = true;
+  root->SetHasRenderSurface(true);
+  child1->SetHasRenderSurface(true);
+  grand_child->SetHasRenderSurface(true);
   ExecuteCalculateDrawProperties(root);
   EXPECT_FALSE(root->is_clipped());
   EXPECT_FALSE(parent->is_clipped());
   EXPECT_FALSE(child1->is_clipped());
   EXPECT_FALSE(child2->is_clipped());
   EXPECT_FALSE(grand_child->is_clipped());
   EXPECT_TRUE(leaf_node1->is_clipped());
   EXPECT_TRUE(leaf_node2->is_clipped());
 
   ExecuteCalculateDrawPropertiesWithoutSeparateSurfaces(root);
@@ skipping 168 matching lines @@
   child1->SetDrawsContent(true);
   child2->SetDrawsContent(true);
   grand_child->SetDrawsContent(true);
   leaf_node1->SetDrawsContent(true);
   leaf_node2->SetDrawsContent(true);
 
   const gfx::Transform identity_matrix;
 
   // child1 and grand_child get render surfaces when surfaces are enabled.
   SetLayerPropertiesForTesting(root, identity_matrix, gfx::Point3F(),
-                               gfx::PointF(), gfx::Size(100, 100), true, false,
-                               true);
+                               gfx::PointF(), gfx::Size(100, 100), true, false);
   SetLayerPropertiesForTesting(parent, identity_matrix, gfx::Point3F(),
                                gfx::PointF(2.f, 2.f), gfx::Size(400, 400), true,
-                               false, false);
+                               false);
   SetLayerPropertiesForTesting(child1, identity_matrix, gfx::Point3F(),
                                gfx::PointF(4.f, 4.f), gfx::Size(800, 800), true,
-                               false, true);
+                               false);
   SetLayerPropertiesForTesting(child2, identity_matrix, gfx::Point3F(),
                                gfx::PointF(3.f, 3.f), gfx::Size(800, 800), true,
-                               false, false);
+                               false);
   SetLayerPropertiesForTesting(grand_child, identity_matrix, gfx::Point3F(),
                                gfx::PointF(8.f, 8.f), gfx::Size(1500, 1500),
-                               true, false, true);
+                               true, false);
   SetLayerPropertiesForTesting(leaf_node1, identity_matrix, gfx::Point3F(),
                                gfx::PointF(16.f, 16.f), gfx::Size(2000, 2000),
-                               true, false, false);
+                               true, false);
   SetLayerPropertiesForTesting(leaf_node2, identity_matrix, gfx::Point3F(),
                                gfx::PointF(9.f, 9.f), gfx::Size(2000, 2000),
-                               true, false, false);
+                               true, false);
 
   // Case 1: Nothing is clipped. In this case, each layer's clip rect is its
   // bounds in target space. The only thing that changes when surfaces are
   // disabled is that target space is always screen space.
+  root->SetForceRenderSurface(true);
+  child1->SetForceRenderSurface(true);
+  grand_child->SetForceRenderSurface(true);
   ExecuteCalculateDrawProperties(root);
+  EXPECT_TRUE(root->has_render_surface());
+  EXPECT_FALSE(parent->has_render_surface());
+  EXPECT_TRUE(child1->has_render_surface());
+  EXPECT_FALSE(child2->has_render_surface());
+  EXPECT_TRUE(grand_child->has_render_surface());
+  EXPECT_FALSE(leaf_node1->has_render_surface());
+  EXPECT_FALSE(leaf_node2->has_render_surface());
   EXPECT_EQ(gfx::Rect(100, 100), root->clip_rect());
   EXPECT_EQ(gfx::Rect(2, 2, 400, 400), parent->clip_rect());
   EXPECT_EQ(gfx::Rect(800, 800), child1->clip_rect());
   EXPECT_EQ(gfx::Rect(5, 5, 800, 800), child2->clip_rect());
   EXPECT_EQ(gfx::Rect(1500, 1500), grand_child->clip_rect());
   EXPECT_EQ(gfx::Rect(16, 16, 2000, 2000), leaf_node1->clip_rect());
   EXPECT_EQ(gfx::Rect(14, 14, 2000, 2000), leaf_node2->clip_rect());
 
   ExecuteCalculateDrawPropertiesWithoutSeparateSurfaces(root);
   EXPECT_EQ(gfx::Rect(100, 100), root->clip_rect());
   EXPECT_EQ(gfx::Rect(2, 2, 400, 400), parent->clip_rect());
   EXPECT_EQ(gfx::Rect(6, 6, 800, 800), child1->clip_rect());
   EXPECT_EQ(gfx::Rect(5, 5, 800, 800), child2->clip_rect());
   EXPECT_EQ(gfx::Rect(14, 14, 1500, 1500), grand_child->clip_rect());
   EXPECT_EQ(gfx::Rect(30, 30, 2000, 2000), leaf_node1->clip_rect());
   EXPECT_EQ(gfx::Rect(14, 14, 2000, 2000), leaf_node2->clip_rect());
 
   // Case 2: The root is clipped. In this case, layers that draw into the root
   // render surface are clipped by the root's bounds.
   root->SetMasksToBounds(true);
   host_impl()->active_tree()->property_trees()->needs_rebuild = true;
+  root->SetForceRenderSurface(true);
+  child1->SetForceRenderSurface(true);
+  grand_child->SetForceRenderSurface(true);
   ExecuteCalculateDrawProperties(root);
+  EXPECT_TRUE(root->has_render_surface());
+  EXPECT_FALSE(parent->has_render_surface());
+  EXPECT_TRUE(child1->has_render_surface());
+  EXPECT_FALSE(child2->has_render_surface());
+  EXPECT_TRUE(grand_child->has_render_surface());
+  EXPECT_FALSE(leaf_node1->has_render_surface());
+  EXPECT_FALSE(leaf_node2->has_render_surface());
   EXPECT_EQ(gfx::Rect(100, 100), root->clip_rect());
   EXPECT_EQ(gfx::Rect(100, 100), parent->clip_rect());
   EXPECT_EQ(gfx::Rect(800, 800), child1->clip_rect());
   EXPECT_EQ(gfx::Rect(100, 100), child2->clip_rect());
   EXPECT_EQ(gfx::Rect(1500, 1500), grand_child->clip_rect());
   EXPECT_EQ(gfx::Rect(16, 16, 2000, 2000), leaf_node1->clip_rect());
   EXPECT_EQ(gfx::Rect(100, 100), leaf_node2->clip_rect());
 
   ExecuteCalculateDrawPropertiesWithoutSeparateSurfaces(root);
   EXPECT_EQ(gfx::Rect(100, 100), root->clip_rect());
   EXPECT_EQ(gfx::Rect(100, 100), parent->clip_rect());
   EXPECT_EQ(gfx::Rect(100, 100), child1->clip_rect());
   EXPECT_EQ(gfx::Rect(100, 100), child2->clip_rect());
   EXPECT_EQ(gfx::Rect(100, 100), grand_child->clip_rect());
   EXPECT_EQ(gfx::Rect(100, 100), leaf_node1->clip_rect());
   EXPECT_EQ(gfx::Rect(100, 100), leaf_node2->clip_rect());
 
   root->SetMasksToBounds(false);
 
   // Case 3: The parent and child1 are clipped. When surfaces are enabled, the
   // parent clip rect only contributes to the subtree rooted at child2, since
   // the subtree rooted at child1 renders into a separate surface. Similarly,
   // child1's clip rect doesn't contribute to its descendants, since its only
   // child is a render surface. However, without surfaces, these clip rects
   // contribute to all descendants.
   parent->SetMasksToBounds(true);
   child1->SetMasksToBounds(true);
   host_impl()->active_tree()->property_trees()->needs_rebuild = true;
+  root->SetForceRenderSurface(true);
+  child1->SetForceRenderSurface(true);
+  grand_child->SetForceRenderSurface(true);
   ExecuteCalculateDrawProperties(root);
+  EXPECT_TRUE(root->has_render_surface());
+  EXPECT_FALSE(parent->has_render_surface());
+  EXPECT_TRUE(child1->has_render_surface());
+  EXPECT_FALSE(child2->has_render_surface());
+  EXPECT_TRUE(grand_child->has_render_surface());
+  EXPECT_FALSE(leaf_node1->has_render_surface());
+  EXPECT_FALSE(leaf_node2->has_render_surface());
   EXPECT_EQ(gfx::Rect(100, 100), root->clip_rect());
   EXPECT_EQ(gfx::Rect(2, 2, 400, 400), parent->clip_rect());
   EXPECT_EQ(gfx::Rect(800, 800), child1->clip_rect());
   EXPECT_EQ(gfx::Rect(2, 2, 400, 400), child2->clip_rect());
   EXPECT_EQ(gfx::Rect(1500, 1500), grand_child->clip_rect());
   EXPECT_EQ(gfx::Rect(16, 16, 2000, 2000), leaf_node1->clip_rect());
   EXPECT_EQ(gfx::Rect(2, 2, 400, 400), leaf_node2->clip_rect());
 
   ExecuteCalculateDrawPropertiesWithoutSeparateSurfaces(root);
   EXPECT_EQ(gfx::Rect(100, 100), root->clip_rect());
@@ skipping 35 matching lines @@
   SetLayerPropertiesForTesting(grand_child, identity_matrix, gfx::Point3F(),
                                gfx::PointF(8.f, 8.f), gfx::Size(1500, 1500),
                                true, false, true);
   SetLayerPropertiesForTesting(leaf_node, identity_matrix, gfx::Point3F(),
                                gfx::PointF(16.f, 16.f), gfx::Size(2000, 2000),
                                true, false, false);
 
   parent->SetMasksToBounds(true);
   child->SetMasksToBounds(true);
 
+  root->SetHasRenderSurface(true);
+  child->SetHasRenderSurface(true);
+  grand_child->SetHasRenderSurface(true);
+
   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->DrawTransform());
 
+  root->SetHasRenderSurface(true);
+  child->SetHasRenderSurface(true);
+  grand_child->SetHasRenderSurface(true);
+
   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->DrawTransform());
 
+  root->SetHasRenderSurface(true);
+  child->SetHasRenderSurface(true);
+  grand_child->SetHasRenderSurface(true);
+
   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->DrawTransform());
 }
 
 TEST_F(LayerTreeHostCommonTest, AnimationsForRenderSurfaceHierarchy) {
   LayerImpl* parent = root_layer();
   LayerImpl* render_surface1 = AddChildToRoot<LayerImpl>();
@@ skipping 728 matching lines @@
                                true, false, false);
   SetLayerPropertiesForTesting(leaf_node2, identity_matrix, gfx::Point3F(),
                                gfx::PointF(9.f, 9.f), gfx::Size(2000, 2000),
                                true, false, false);
 
   // Case 1: No layers clip. Visible rects are clipped by the viewport, but the
   // viewport clip doesn't apply to layers that draw into unclipped surfaces.
   // Each layer's drawable content rect is its bounds in target space; the only
   // thing that changes with surfaces disabled is that target space is always
   // screen space.
+  root->SetHasRenderSurface(true);
+  child1->SetHasRenderSurface(true);
+  child2->SetHasRenderSurface(true);
   ExecuteCalculateDrawProperties(root);
   EXPECT_EQ(gfx::Rect(100, 100), root->visible_layer_rect());
   EXPECT_EQ(gfx::Rect(0, 0, 98, 98), parent->visible_layer_rect());
   EXPECT_EQ(gfx::Rect(800, 800), child1->visible_layer_rect());
   EXPECT_EQ(gfx::Rect(800, 800), child2->visible_layer_rect());
   EXPECT_EQ(gfx::Rect(1500, 1500), grand_child1->visible_layer_rect());
   EXPECT_EQ(gfx::Rect(1500, 1500), grand_child2->visible_layer_rect());
   EXPECT_EQ(gfx::Rect(2000, 2000), leaf_node1->visible_layer_rect());
   EXPECT_EQ(gfx::Rect(2000, 2000), leaf_node2->visible_layer_rect());
 
@@ skipping 28 matching lines @@
   EXPECT_EQ(gfx::Rect(21, 21, 2000, 2000), leaf_node2->drawable_content_rect());
 
   // Case 2: The parent clips. In this case, neither surface is unclipped, so
   // all visible layer rects are clipped by the intersection of all ancestor
   // clips, whether or not surfaces are disabled. However, drawable content
   // rects are clipped only until the next render surface is reached, so
   // descendants of parent have their drawable content rects clipped only when
   // surfaces are disabled.
   parent->SetMasksToBounds(true);
   host_impl()->active_tree()->property_trees()->needs_rebuild = true;
+  root->SetHasRenderSurface(true);
+  child1->SetHasRenderSurface(true);
+  child2->SetHasRenderSurface(true);
   ExecuteCalculateDrawProperties(root);
   EXPECT_EQ(gfx::Rect(100, 100), root->visible_layer_rect());
   EXPECT_EQ(gfx::Rect(98, 98), parent->visible_layer_rect());
   EXPECT_EQ(gfx::Rect(94, 94), child1->visible_layer_rect());
   EXPECT_EQ(gfx::Rect(95, 95), child2->visible_layer_rect());
   EXPECT_EQ(gfx::Rect(86, 86), grand_child1->visible_layer_rect());
   EXPECT_EQ(gfx::Rect(88, 88), grand_child2->visible_layer_rect());
   EXPECT_EQ(gfx::Rect(70, 70), leaf_node1->visible_layer_rect());
   EXPECT_EQ(gfx::Rect(79, 79), leaf_node2->visible_layer_rect());
 
@@ skipping 27 matching lines @@
 
   parent->SetMasksToBounds(false);
 
   // Case 3: child1 and grand_child2 clip. In this case, descendants of these
   // layers have their visible rects clipped by them; without surfaces, these
   // rects are also clipped by the viewport. Similarly, descendants of these
   // layers have their drawable content rects clipped by them.
   child1->SetMasksToBounds(true);
   grand_child2->SetMasksToBounds(true);
   host_impl()->active_tree()->property_trees()->needs_rebuild = true;
+  root->SetHasRenderSurface(true);
+  child1->SetHasRenderSurface(true);
+  child2->SetHasRenderSurface(true);
   ExecuteCalculateDrawProperties(root);
   EXPECT_EQ(gfx::Rect(100, 100), root->visible_layer_rect());
   EXPECT_EQ(gfx::Rect(98, 98), parent->visible_layer_rect());
   EXPECT_EQ(gfx::Rect(800, 800), child1->visible_layer_rect());
   EXPECT_EQ(gfx::Rect(800, 800), child2->visible_layer_rect());
   EXPECT_EQ(gfx::Rect(792, 792), grand_child1->visible_layer_rect());
   EXPECT_EQ(gfx::Rect(1500, 1500), grand_child2->visible_layer_rect());
   EXPECT_EQ(gfx::Rect(776, 776), leaf_node1->visible_layer_rect());
   EXPECT_EQ(gfx::Rect(1491, 1491), leaf_node2->visible_layer_rect());
 
@@ skipping 996 matching lines @@
       front_facing_child_of_front_facing_surface->id()));
   EXPECT_TRUE(
       UpdateLayerListContains(front_facing_child_of_back_facing_surface->id()));
 }
 
 TEST_F(LayerTreeHostCommonTest, BackFaceCullingWithPreserves3d) {
   // Verify the behavior of back-face culling when preserves-3d transform style
   // is used.
 
   const gfx::Transform identity_matrix;
-  scoped_refptr<Layer> parent = Layer::Create(layer_settings());
-  scoped_refptr<LayerWithForcedDrawsContent> front_facing_child =
-      make_scoped_refptr(new LayerWithForcedDrawsContent(layer_settings()));
-  scoped_refptr<LayerWithForcedDrawsContent> back_facing_child =
-      make_scoped_refptr(new LayerWithForcedDrawsContent(layer_settings()));
-  scoped_refptr<LayerWithForcedDrawsContent> front_facing_surface =
-      make_scoped_refptr(new LayerWithForcedDrawsContent(layer_settings()));
-  scoped_refptr<LayerWithForcedDrawsContent> back_facing_surface =
-      make_scoped_refptr(new LayerWithForcedDrawsContent(layer_settings()));
-  scoped_refptr<LayerWithForcedDrawsContent>
-      front_facing_child_of_front_facing_surface =
-          make_scoped_refptr(new LayerWithForcedDrawsContent(layer_settings()));
-  scoped_refptr<LayerWithForcedDrawsContent>
-      back_facing_child_of_front_facing_surface =
-          make_scoped_refptr(new LayerWithForcedDrawsContent(layer_settings()));
-  scoped_refptr<LayerWithForcedDrawsContent>
-      front_facing_child_of_back_facing_surface =
-          make_scoped_refptr(new LayerWithForcedDrawsContent(layer_settings()));
-  scoped_refptr<LayerWithForcedDrawsContent>
-      back_facing_child_of_back_facing_surface =
-          make_scoped_refptr(new LayerWithForcedDrawsContent(layer_settings()));
-  scoped_refptr<LayerWithForcedDrawsContent> dummy_replica_layer1 =
-      make_scoped_refptr(new LayerWithForcedDrawsContent(layer_settings()));
-  scoped_refptr<LayerWithForcedDrawsContent> dummy_replica_layer2 =
-      make_scoped_refptr(new LayerWithForcedDrawsContent(layer_settings()));
-
-  parent->AddChild(front_facing_child);
-  parent->AddChild(back_facing_child);
-  parent->AddChild(front_facing_surface);
-  parent->AddChild(back_facing_surface);
-  front_facing_surface->AddChild(front_facing_child_of_front_facing_surface);
-  front_facing_surface->AddChild(back_facing_child_of_front_facing_surface);
-  back_facing_surface->AddChild(front_facing_child_of_back_facing_surface);
-  back_facing_surface->AddChild(back_facing_child_of_back_facing_surface);
-
-  host()->SetRootLayer(parent);
+  LayerImpl* parent = root_layer();
+  LayerImpl* front_facing_child = AddChildToRoot<LayerImpl>();
+  LayerImpl* back_facing_child = AddChildToRoot<LayerImpl>();
+  LayerImpl* front_facing_surface = AddChildToRoot<LayerImpl>();
+  LayerImpl* back_facing_surface = AddChildToRoot<LayerImpl>();
+  LayerImpl* front_facing_child_of_front_facing_surface =
+      AddChild<LayerImpl>(front_facing_surface);
+  LayerImpl* back_facing_child_of_front_facing_surface =
+      AddChild<LayerImpl>(front_facing_surface);
+  LayerImpl* front_facing_child_of_back_facing_surface =
+      AddChild<LayerImpl>(back_facing_surface);
+  LayerImpl* back_facing_child_of_back_facing_surface =
+      AddChild<LayerImpl>(back_facing_surface);
+  // Opacity will not force creation of render surfaces in this case because of
+  // the preserve-3d transform style. Instead, an example of when a surface
+  // would be created with preserve-3d is when there is a replica layer.
+  LayerImpl* dummy_replica_layer1 =
+      AddReplicaLayer<LayerImpl>(front_facing_surface);
+  LayerImpl* dummy_replica_layer2 =
+      AddReplicaLayer<LayerImpl>(back_facing_surface);
 
   // Nothing is double-sided
   front_facing_child->SetDoubleSided(false);
   back_facing_child->SetDoubleSided(false);
   front_facing_surface->SetDoubleSided(false);
   back_facing_surface->SetDoubleSided(false);
   front_facing_child_of_front_facing_surface->SetDoubleSided(false);
   back_facing_child_of_front_facing_surface->SetDoubleSided(false);
   front_facing_child_of_back_facing_surface->SetDoubleSided(false);
   back_facing_child_of_back_facing_surface->SetDoubleSided(false);
 
+  // Everything draws content.
+  front_facing_child->SetDrawsContent(true);
+  back_facing_child->SetDrawsContent(true);
+  front_facing_surface->SetDrawsContent(true);
+  back_facing_surface->SetDrawsContent(true);
+  front_facing_child_of_front_facing_surface->SetDrawsContent(true);
+  back_facing_child_of_front_facing_surface->SetDrawsContent(true);
+  front_facing_child_of_back_facing_surface->SetDrawsContent(true);
+  back_facing_child_of_back_facing_surface->SetDrawsContent(true);
+  dummy_replica_layer1->SetDrawsContent(true);
+  dummy_replica_layer2->SetDrawsContent(true);
+
   gfx::Transform backface_matrix;
   backface_matrix.Translate(50.0, 50.0);
   backface_matrix.RotateAboutYAxis(180.0);
   backface_matrix.Translate(-50.0, -50.0);
 
-  // Opacity will not force creation of render surfaces in this case because of
-  // the preserve-3d transform style. Instead, an example of when a surface
-  // would be created with preserve-3d is when there is a replica layer.
-  front_facing_surface->SetReplicaLayer(dummy_replica_layer1.get());
-  back_facing_surface->SetReplicaLayer(dummy_replica_layer2.get());
-
   // Each surface creates its own new 3d rendering context (as defined by W3C
   // spec).  According to current W3C CSS gfx::Transforms spec, layers in a 3d
   // rendering context should use the transform with respect to that context.
   // This 3d rendering context occurs when (a) parent's transform style is flat
   // and (b) the layer's transform style is preserve-3d.
-  SetLayerPropertiesForTesting(parent.get(),
-                               identity_matrix,
-                               gfx::Point3F(),
-                               gfx::PointF(),
-                               gfx::Size(100, 100),
-                               true,
+  SetLayerPropertiesForTesting(parent, identity_matrix, gfx::Point3F(),
+                               gfx::PointF(), gfx::Size(100, 100), true,
                                false);  // parent transform style is flat.
-  SetLayerPropertiesForTesting(front_facing_child.get(),
-                               identity_matrix,
-                               gfx::Point3F(),
-                               gfx::PointF(),
-                               gfx::Size(100, 100),
-                               true,
-                               false);
-  SetLayerPropertiesForTesting(back_facing_child.get(),
-                               backface_matrix,
-                               gfx::Point3F(),
-                               gfx::PointF(),
-                               gfx::Size(100, 100),
-                               true,
-                               false);
+  SetLayerPropertiesForTesting(front_facing_child, identity_matrix,
+                               gfx::Point3F(), gfx::PointF(),
+                               gfx::Size(100, 100), true, false);
+  SetLayerPropertiesForTesting(back_facing_child, backface_matrix,
+                               gfx::Point3F(), gfx::PointF(),
+                               gfx::Size(100, 100), true, false);
   // surface transform style is preserve-3d.
-  SetLayerPropertiesForTesting(front_facing_surface.get(),
-                               identity_matrix,
-                               gfx::Point3F(),
-                               gfx::PointF(),
-                               gfx::Size(100, 100),
-                               false,
-                               true);
+  SetLayerPropertiesForTesting(front_facing_surface, identity_matrix,
+                               gfx::Point3F(), gfx::PointF(),
+                               gfx::Size(100, 100), false, true);
   // surface transform style is preserve-3d.
-  SetLayerPropertiesForTesting(back_facing_surface.get(),
-                               backface_matrix,
-                               gfx::Point3F(),
-                               gfx::PointF(),
-                               gfx::Size(100, 100),
-                               false,
-                               true);
-  SetLayerPropertiesForTesting(front_facing_child_of_front_facing_surface.get(),
-                               identity_matrix,
-                               gfx::Point3F(),
-                               gfx::PointF(),
-                               gfx::Size(100, 100),
-                               true,
-                               true);
-  SetLayerPropertiesForTesting(back_facing_child_of_front_facing_surface.get(),
-                               backface_matrix,
-                               gfx::Point3F(),
-                               gfx::PointF(),
-                               gfx::Size(100, 100),
-                               true,
-                               true);
-  SetLayerPropertiesForTesting(front_facing_child_of_back_facing_surface.get(),
-                               identity_matrix,
-                               gfx::Point3F(),
-                               gfx::PointF(),
-                               gfx::Size(100, 100),
-                               true,
-                               true);
-  SetLayerPropertiesForTesting(back_facing_child_of_back_facing_surface.get(),
-                               backface_matrix,
-                               gfx::Point3F(),
-                               gfx::PointF(),
-                               gfx::Size(100, 100),
-                               true,
-                               true);
+  SetLayerPropertiesForTesting(back_facing_surface, backface_matrix,
+                               gfx::Point3F(), gfx::PointF(),
+                               gfx::Size(100, 100), false, true);
+  SetLayerPropertiesForTesting(front_facing_child_of_front_facing_surface,
+                               identity_matrix, gfx::Point3F(), gfx::PointF(),
+                               gfx::Size(100, 100), true, true);
+  SetLayerPropertiesForTesting(back_facing_child_of_front_facing_surface,
+                               backface_matrix, gfx::Point3F(), gfx::PointF(),
+                               gfx::Size(100, 100), true, true);
+  SetLayerPropertiesForTesting(front_facing_child_of_back_facing_surface,
+                               identity_matrix, gfx::Point3F(), gfx::PointF(),
+                               gfx::Size(100, 100), true, true);
+  SetLayerPropertiesForTesting(back_facing_child_of_back_facing_surface,
+                               backface_matrix, gfx::Point3F(), gfx::PointF(),
+                               gfx::Size(100, 100), true, true);
 
-  ExecuteCalculateDrawPropertiesWithPropertyTrees(parent.get());
+  ExecuteCalculateDrawPropertiesWithPropertyTrees(parent);
 
   // Verify which render surfaces were created and used.
   EXPECT_FALSE(front_facing_child->has_render_surface());
   EXPECT_FALSE(back_facing_child->has_render_surface());
   EXPECT_TRUE(front_facing_surface->has_render_surface());
   // We expect that a has_render_surface was created but not used.
   EXPECT_TRUE(back_facing_surface->has_render_surface());
   EXPECT_FALSE(
       front_facing_child_of_front_facing_surface->has_render_surface());
   EXPECT_FALSE(back_facing_child_of_front_facing_surface->has_render_surface());
   EXPECT_FALSE(front_facing_child_of_back_facing_surface->has_render_surface());
   EXPECT_FALSE(back_facing_child_of_back_facing_surface->has_render_surface());
 
-  EXPECT_EQ(3u, update_layer_list().size());
+  EXPECT_EQ(3u, update_layer_list_impl()->size());
 
-  EXPECT_TRUE(UpdateLayerListContains(front_facing_child->id()));
-  EXPECT_TRUE(UpdateLayerListContains(front_facing_surface->id()));
-  EXPECT_TRUE(UpdateLayerListContains(
+  EXPECT_TRUE(UpdateLayerListImplContains(front_facing_child->id()));
+  EXPECT_TRUE(UpdateLayerListImplContains(front_facing_surface->id()));
+  EXPECT_TRUE(UpdateLayerListImplContains(
       front_facing_child_of_front_facing_surface->id()));
 }
 
 TEST_F(LayerTreeHostCommonTest, BackFaceCullingWithAnimatingTransforms) {
   // Verify that layers are appropriately culled when their back face is showing
   // and they are not double sided, while animations are going on.
   //
   // Layers that are animating do not get culled on the main thread, as their
   // transforms should be treated as "unknown" so we can not be sure that their
   // back face is really showing.
@@ skipping 1727 matching lines @@
 
   // Sanity check our num_unclipped_descendants values.
   EXPECT_EQ(1u, render_surface1->num_unclipped_descendants());
   EXPECT_EQ(0u, render_surface2->num_unclipped_descendants());
 }
 
 TEST_F(LayerTreeHostCommonTest,
        CreateRenderSurfaceWhenFlattenInsideRenderingContext) {
   // Verifies that Render Surfaces are created at the edge of rendering context.
 
-  scoped_refptr<LayerWithForcedDrawsContent> parent =
-      make_scoped_refptr(new LayerWithForcedDrawsContent(layer_settings()));
-  Layer* root = parent.get();
-  scoped_refptr<LayerWithForcedDrawsContent> child_1 =
-      make_scoped_refptr(new LayerWithForcedDrawsContent(layer_settings()));
-  Layer* child1 = child_1.get();
-  scoped_refptr<LayerWithForcedDrawsContent> child_2 =
-      make_scoped_refptr(new LayerWithForcedDrawsContent(layer_settings()));
-  Layer* child2 = child_2.get();
-  scoped_refptr<LayerWithForcedDrawsContent> child_3 =
-      make_scoped_refptr(new LayerWithForcedDrawsContent(layer_settings()));
-  Layer* child3 = child_3.get();
-
-  parent->AddChild(std::move(child_1));
-  child1->AddChild(std::move(child_2));
-  child2->AddChild(std::move(child_3));
-
-  host()->SetRootLayer(root);
+  LayerImpl* root = root_layer();
+  LayerImpl* child1 = AddChildToRoot<LayerImpl>();
+  LayerImpl* child2 = AddChild<LayerImpl>(child1);
+  LayerImpl* child3 = AddChild<LayerImpl>(child2);
+  root->SetDrawsContent(true);
 
   const gfx::Transform identity_matrix;
   gfx::Point3F transform_origin;
   gfx::PointF position;
   gfx::Size bounds(100, 100);
 
   SetLayerPropertiesForTesting(root, identity_matrix, transform_origin,
                                position, bounds, true, false);
   SetLayerPropertiesForTesting(child1, identity_matrix, transform_origin,
                                position, bounds, false, true);
+  child1->SetDrawsContent(true);
   SetLayerPropertiesForTesting(child2, identity_matrix, transform_origin,
                                position, bounds, true, false);
+  child2->SetDrawsContent(true);
   SetLayerPropertiesForTesting(child3, identity_matrix, transform_origin,
                                position, bounds, true, false);
+  child3->SetDrawsContent(true);
 
   child2->Set3dSortingContextId(1);
   child3->Set3dSortingContextId(1);
 
-  ExecuteCalculateDrawPropertiesWithPropertyTrees(parent.get());
+  ExecuteCalculateDrawPropertiesWithPropertyTrees(root);
 
   // Verify which render surfaces were created.
   EXPECT_TRUE(root->has_render_surface());
   EXPECT_FALSE(child1->has_render_surface());
   EXPECT_TRUE(child2->has_render_surface());
   EXPECT_FALSE(child3->has_render_surface());
 }
 
 TEST_F(LayerTreeHostCommonTest, CanRenderToSeparateSurface) {
   FakeImplTaskRunnerProvider task_runner_provider;
   TestSharedBitmapManager shared_bitmap_manager;
   TestTaskGraphRunner task_graph_runner;
   FakeLayerTreeHostImpl host_impl(&task_runner_provider, &shared_bitmap_manager,
                                   &task_graph_runner);
+
   scoped_ptr<LayerImpl> root =
       LayerImpl::Create(host_impl.active_tree(), 12345);
   scoped_ptr<LayerImpl> child1 =
       LayerImpl::Create(host_impl.active_tree(), 123456);
   scoped_ptr<LayerImpl> child2 =
       LayerImpl::Create(host_impl.active_tree(), 1234567);
   scoped_ptr<LayerImpl> child3 =
       LayerImpl::Create(host_impl.active_tree(), 12345678);
 
   gfx::Transform identity_matrix;
@@ skipping 1474 matching lines @@
 
   scoped_ptr<LayerImpl> root = LayerImpl::Create(host_impl.active_tree(), 1);
   LayerImpl* root_layer = root.get();
   scoped_ptr<LayerImpl> child1 = LayerImpl::Create(host_impl.active_tree(), 2);
   LayerImpl* child1_layer = child1.get();
   scoped_ptr<LayerImpl> child2 = LayerImpl::Create(host_impl.active_tree(), 3);
   LayerImpl* child2_layer = child2.get();
 
   root->AddChild(std::move(child1));
   root->AddChild(std::move(child2));
-  root->SetHasRenderSurface(true);
+  root->SetForceRenderSurface(true);
   root->SetDrawsContent(true);
 
   gfx::Transform identity_matrix, scale_transform_child1,
       scale_transform_child2;
   scale_transform_child1.Scale(2, 3);
   scale_transform_child2.Scale(4, 5);
 
   SetLayerPropertiesForTesting(root_layer, identity_matrix, gfx::Point3F(),
                                gfx::PointF(), gfx::Size(1, 1), true, false,
                                true);
   SetLayerPropertiesForTesting(child1_layer, scale_transform_child1,
                                gfx::Point3F(), gfx::PointF(), gfx::Size(1, 1),
                                true, false, false);
 
   child1_layer->SetMaskLayer(LayerImpl::Create(host_impl.active_tree(), 4));
   child1_layer->SetDrawsContent(true);
 
   scoped_ptr<LayerImpl> replica_layer =
       LayerImpl::Create(host_impl.active_tree(), 5);
-  replica_layer->SetHasRenderSurface(true);
   replica_layer->SetMaskLayer(LayerImpl::Create(host_impl.active_tree(), 6));
   child1_layer->SetReplicaLayer(std::move(replica_layer));
   child1_layer->SetHasRenderSurface(true);
 
   ExecuteCalculateDrawProperties(root_layer);
 
   TransformOperations scale;
   scale.AppendScale(5.f, 8.f, 3.f);
 
   AddAnimatedTransformToLayer(child2_layer, 1.0, TransformOperations(), scale);
@@ skipping 1194 matching lines @@
   transform1.RotateAboutXAxis(30);
   // This transform should be a 3d transform as we want the render surface
   // to flatten the transform
   gfx::Transform transform2;
   transform2.Translate3d(10, 10, 10);
 
   layer_clips_subtree->SetMasksToBounds(true);
   test_layer->SetDrawsContent(true);
 
   SetLayerPropertiesForTesting(root, identity_matrix, gfx::Point3F(),
-                               gfx::PointF(), gfx::Size(30, 30), true, false,
-                               true);
+                               gfx::PointF(), gfx::Size(30, 30), true, false);
   SetLayerPropertiesForTesting(significant_transform, transform1,
                                gfx::Point3F(), gfx::PointF(), gfx::Size(30, 30),
-                               true, false, false);
+                               true, false);
   SetLayerPropertiesForTesting(layer_clips_subtree, identity_matrix,
                                gfx::Point3F(), gfx::PointF(), gfx::Size(30, 30),
-                               true, false, false);
+                               true, false);
   SetLayerPropertiesForTesting(render_surface, transform2, gfx::Point3F(),
-                               gfx::PointF(), gfx::Size(30, 30), true, false,
-                               true);
+                               gfx::PointF(), gfx::Size(30, 30), true, false);
   SetLayerPropertiesForTesting(test_layer, identity_matrix, gfx::Point3F(),
-                               gfx::PointF(), gfx::Size(30, 30), true, false,
-                               false);
+                               gfx::PointF(), gfx::Size(30, 30), true, false);
 
+  root->SetForceRenderSurface(true);
+  significant_transform->SetForceRenderSurface(false);
+  layer_clips_subtree->SetForceRenderSurface(true);
+  render_surface->SetForceRenderSurface(true);
+  test_layer->SetForceRenderSurface(false);
   ExecuteCalculateDrawProperties(root);
 
   TransformTree transform_tree =
       root->layer_tree_impl()->property_trees()->transform_tree;
   TransformNode* transform_node =
       transform_tree.Node(significant_transform->transform_tree_index());
   EXPECT_EQ(transform_node->owner_id, significant_transform->id());
 
+  EXPECT_TRUE(root->has_render_surface());
+  EXPECT_FALSE(significant_transform->has_render_surface());
+  EXPECT_TRUE(layer_clips_subtree->has_render_surface());
+  EXPECT_TRUE(render_surface->has_render_surface());
+  EXPECT_FALSE(test_layer->has_render_surface());
+
   ClipTree clip_tree = root->layer_tree_impl()->property_trees()->clip_tree;
   ClipNode* clip_node = clip_tree.Node(render_surface->clip_tree_index());
   EXPECT_FALSE(clip_node->data.applies_local_clip);
-  EXPECT_EQ(gfx::Rect(30, 21), test_layer->visible_rect_from_property_trees());
+  EXPECT_EQ(gfx::Rect(22, 21), test_layer->visible_rect_from_property_trees());

[ajuma, 2015/12/02 14:54:21]

Is this change because layer_clips_subtree has a surface now but didn't before?
(And do we need to change whether layer_clips_subtree has a surface?)

[weiliangc, 2015/12/02 18:16:38]

Mostly before ptree is built using LayerImpl's has_render_surface information as
is, now ExecuteCalcDrawProps determines whether layer has RS. Since
layer_clips_subtree's parent significant_transform is not axis-aligned, it now
has a RenderSurface. I can rm all the SetForceRenderSurface calls if that helps?

Since render_surface layer here still clips the test_layer I just changed the
test expectation to match.

Adding a special code path for LayerImpl unittests to build effect tree
differently (based on pre-set has_rs) seems like adding too much complexity and
not testing real behavior.

[ajuma, 2015/12/02 18:25:08]

Ah, that makes sense, thanks.
I think it's fine to leave them. If you decide to remove them, please add a
comment above (where you check that layer_clips_subtree has a surface) that the
layer has a surface because of non-axis-aligned clipping.
Agreed.

 }
 
 TEST_F(LayerTreeHostCommonTest, TransformOfParentClipNodeAncestorOfTarget) {
   // Ensure that when parent clip node's transform is an ancestor of current
   // clip node's target, clip is 'projected' from parent space to current
   // target space and visible rects are calculated correctly.
   LayerImpl* root = root_layer();
   LayerImpl* clip_layer = AddChild<LayerImpl>(root);
   LayerImpl* target_layer = AddChild<LayerImpl>(clip_layer);
   LayerImpl* test_layer = AddChild<LayerImpl>(target_layer);
@@ skipping 508 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