Moving RenderSurface creation outside of CalcDrawProps

cc/trees/layer_tree_impl_unittest.cc

 // Copyright 2014 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "cc/trees/layer_tree_impl.h"
 
 #include "cc/layers/heads_up_display_layer_impl.h"
 #include "cc/layers/layer.h"
 #include "cc/test/fake_impl_proxy.h"
 #include "cc/test/fake_layer_tree_host_impl.h"
@@ skipping 39 matching lines @@
   gfx::Transform identity_matrix;
   gfx::Point3F transform_origin;
   gfx::PointF position;
   gfx::Size bounds(100, 100);
   SetLayerPropertiesForTesting(root.get(),
                                identity_matrix,
                                transform_origin,
                                position,
                                bounds,
                                true,
-                               false);
+                               false,
+                               true);
   root->SetDrawsContent(true);
 
   host_impl().SetViewportSize(root->bounds());
   host_impl().active_tree()->SetRootLayer(root.Pass());
   host_impl().UpdateNumChildrenAndDrawPropertiesForActiveTree();
 
   // Sanity check the scenario we just created.
   ASSERT_EQ(1u, RenderSurfaceLayerList().size());
   ASSERT_EQ(1u, root_layer()->render_surface()->layer_list().size());
 
@@ skipping 31 matching lines @@
   gfx::Transform identity_matrix;
   gfx::Point3F transform_origin;
   gfx::PointF position;
   gfx::Size bounds(100, 100);
   SetLayerPropertiesForTesting(root.get(),
                                identity_matrix,
                                transform_origin,
                                position,
                                bounds,
                                true,
-                               false);
+                               false,
+                               true);
   root->SetDrawsContent(true);
 
   // Create hud and add it as a child of root.
   gfx::Size hud_bounds(200, 200);
   SetLayerPropertiesForTesting(hud.get(),
                                identity_matrix,
                                transform_origin,
                                position,
                                hud_bounds,
                                true,
@@ skipping 51 matching lines @@
   gfx::Transform identity_matrix;
   gfx::Point3F transform_origin;
   gfx::PointF position;
   gfx::Size bounds(100, 100);
   SetLayerPropertiesForTesting(root.get(),
                                uninvertible_transform,
                                transform_origin,
                                position,
                                bounds,
                                true,
-                               false);
+                               false,
+                               true);
   root->SetDrawsContent(true);
 
   host_impl().SetViewportSize(root->bounds());
   host_impl().active_tree()->SetRootLayer(root.Pass());
   host_impl().UpdateNumChildrenAndDrawPropertiesForActiveTree();
   // Sanity check the scenario we just created.
   ASSERT_EQ(1u, RenderSurfaceLayerList().size());
   ASSERT_EQ(1u, root_layer()->render_surface()->layer_list().size());
   ASSERT_FALSE(root_layer()->screen_space_transform().IsInvertible());
 
@@ skipping 45 matching lines @@
   // this layer is positioned, and hit testing should correctly know where the
   // layer is located.
   gfx::PointF position(50.f, 50.f);
   gfx::Size bounds(100, 100);
   SetLayerPropertiesForTesting(root.get(),
                                identity_matrix,
                                transform_origin,
                                position,
                                bounds,
                                true,
-                               false);
+                               false,
+                               true);
   root->SetDrawsContent(true);
 
   host_impl().SetViewportSize(root->bounds());
   host_impl().active_tree()->SetRootLayer(root.Pass());
   host_impl().UpdateNumChildrenAndDrawPropertiesForActiveTree();
 
   // Sanity check the scenario we just created.
   ASSERT_EQ(1u, RenderSurfaceLayerList().size());
   ASSERT_EQ(1u, root_layer()->render_surface()->layer_list().size());
 
@@ skipping 35 matching lines @@
   rotation45_degrees_about_center.Translate(-50.0, -50.0);
   gfx::Point3F transform_origin;
   gfx::PointF position;
   gfx::Size bounds(100, 100);
   SetLayerPropertiesForTesting(root.get(),
                                rotation45_degrees_about_center,
                                transform_origin,
                                position,
                                bounds,
                                true,
-                               false);
+                               false,
+                               true);
   root->SetDrawsContent(true);
 
   host_impl().SetViewportSize(root->bounds());
   host_impl().active_tree()->SetRootLayer(root.Pass());
   host_impl().UpdateNumChildrenAndDrawPropertiesForActiveTree();
 
   // Sanity check the scenario we just created.
   ASSERT_EQ(1u, RenderSurfaceLayerList().size());
   ASSERT_EQ(1u, root_layer()->render_surface()->layer_list().size());
 
@@ skipping 48 matching lines @@
   gfx::Point3F transform_origin;
   gfx::PointF position;
   gfx::Size bounds(100, 100);
   SetLayerPropertiesForTesting(
       root.get(),
       perspective_projection_about_center * translation_by_z,
       transform_origin,
       position,
       bounds,
       true,
-      false);
+      false,
+      true);
   root->SetDrawsContent(true);
 
   host_impl().SetViewportSize(root->bounds());
   host_impl().active_tree()->SetRootLayer(root.Pass());
   host_impl().UpdateNumChildrenAndDrawPropertiesForActiveTree();
 
   // Sanity check the scenario we just created.
   ASSERT_EQ(1u, RenderSurfaceLayerList().size());
   ASSERT_EQ(1u, root_layer()->render_surface()->layer_list().size());
 
@@ skipping 40 matching lines @@
 
   gfx::Transform identity_matrix;
   gfx::Point3F transform_origin;
 
   SetLayerPropertiesForTesting(root.get(),
                                identity_matrix,
                                transform_origin,
                                gfx::PointF(),
                                gfx::Size(100, 100),
                                true,
-                               false);
+                               false,
+                               true);
   {
     gfx::PointF position(25.f, 25.f);
     gfx::Size bounds(50, 50);
     scoped_ptr<LayerImpl> test_layer =
         LayerImpl::Create(host_impl().active_tree(), 12345);
     SetLayerPropertiesForTesting(test_layer.get(),
                                  identity_matrix,
                                  transform_origin,
                                  position,
                                  bounds,
@@ skipping 59 matching lines @@
   gfx::Transform identity_matrix;
   gfx::Point3F transform_origin;
 
   scoped_ptr<LayerImpl> root = LayerImpl::Create(host_impl().active_tree(), 1);
   SetLayerPropertiesForTesting(root.get(),
                                identity_matrix,
                                transform_origin,
                                gfx::PointF(),
                                gfx::Size(100, 100),
                                true,
-                               false);
+                               false,
+                               true);
   {
     scoped_ptr<LayerImpl> clipping_layer =
         LayerImpl::Create(host_impl().active_tree(), 123);
     // this layer is positioned, and hit testing should correctly know where the
     // layer is located.
     gfx::PointF position(25.f, 25.f);
     gfx::Size bounds(50, 50);
     SetLayerPropertiesForTesting(clipping_layer.get(),
                                  identity_matrix,
                                  transform_origin,
@@ skipping 74 matching lines @@
   gfx::Transform identity_matrix;
   gfx::Point3F transform_origin;
   gfx::PointF position;
   gfx::Size bounds(100, 100);
   SetLayerPropertiesForTesting(root.get(),
                                identity_matrix,
                                transform_origin,
                                position,
                                bounds,
                                true,
-                               false);
+                               false,
+                               true);
   root->SetMasksToBounds(true);
   {
     scoped_ptr<LayerImpl> child =
         LayerImpl::Create(host_impl().active_tree(), 456);
     scoped_ptr<LayerImpl> grand_child =
         LayerImpl::Create(host_impl().active_tree(), 789);
     scoped_ptr<LayerImpl> rotated_leaf =
         LayerImpl::Create(host_impl().active_tree(), 2468);
 
     position = gfx::PointF(10.f, 10.f);
@@ skipping 45 matching lines @@
     rotated_leaf->SetDrawsContent(true);
 
     grand_child->AddChild(rotated_leaf.Pass());
     child->AddChild(grand_child.Pass());
     root->AddChild(child.Pass());
   }
 
   host_impl().SetViewportSize(root->bounds());
   host_impl().active_tree()->SetRootLayer(root.Pass());
   host_impl().UpdateNumChildrenAndDrawPropertiesForActiveTree();
 

[awoloszyn, 2014/08/25 21:03:44]

This will move to the RenderSurface creation tests in the next CL.

-  // Sanity check the scenario we just created.
-  // The grand_child is expected to create a render surface because it
-  // MasksToBounds and is not axis aligned.
-  ASSERT_EQ(2u, RenderSurfaceLayerList().size());
-  ASSERT_EQ(
-      1u,
-      RenderSurfaceLayerList().at(0)->render_surface()->layer_list().size());
-  ASSERT_EQ(789,
-            RenderSurfaceLayerList()
-                .at(0)
-                ->render_surface()
-                ->layer_list()
-                .at(0)
-                ->id());  // grand_child's surface.
-  ASSERT_EQ(
-      1u,
-      RenderSurfaceLayerList().at(1)->render_surface()->layer_list().size());
-  ASSERT_EQ(
-      2468,
-      RenderSurfaceLayerList()[1]->render_surface()->layer_list().at(0)->id());
-
   // (11, 89) is close to the the bottom left corner within the clip, but it is
   // not inside the layer.
   gfx::Point test_point(11, 89);
   LayerImpl* result_layer =
       host_impl().active_tree()->FindLayerThatIsHitByPoint(test_point);
   EXPECT_FALSE(result_layer);
 
   // Closer inwards from the bottom left will overlap the layer.
   test_point = gfx::Point(25, 75);
   result_layer =
@@ skipping 40 matching lines @@
   gfx::Transform identity_matrix;
   gfx::Point3F transform_origin;
 
   scoped_ptr<LayerImpl> root = LayerImpl::Create(host_impl().active_tree(), 1);
   SetLayerPropertiesForTesting(root.get(),
                                identity_matrix,
                                transform_origin,
                                gfx::PointF(),
                                gfx::Size(100, 100),
                                true,
-                               false);
+                               false,
+                               true);
   {
     scoped_ptr<LayerImpl> intermediate_layer =
         LayerImpl::Create(host_impl().active_tree(), 123);
     // this layer is positioned, and hit testing should correctly know where the
     // layer is located.
     gfx::PointF position(10.f, 10.f);
     gfx::Size bounds(50, 50);
     SetLayerPropertiesForTesting(intermediate_layer.get(),
                                  identity_matrix,
                                  transform_origin,
@@ skipping 64 matching lines @@
   gfx::Transform identity_matrix;
   gfx::Point3F transform_origin;
   gfx::PointF position;
   gfx::Size bounds(100, 100);
   SetLayerPropertiesForTesting(root.get(),
                                identity_matrix,
                                transform_origin,
                                position,
                                bounds,
                                true,
-                               false);
+                               false,
+                               true);
   root->SetDrawsContent(true);
   {
     // child 1 and child2 are initialized to overlap between x=50 and x=60.
     // grand_child is set to overlap both child1 and child2 between y=50 and
     // y=60.  The expected stacking order is: (front) child2, (second)
     // grand_child, (third) child1, and (back) the root layer behind all other
     // layers.
 
     scoped_ptr<LayerImpl> child1 =
         LayerImpl::Create(host_impl().active_tree(), 2);
@@ skipping 118 matching lines @@
   gfx::Transform identity_matrix;
   gfx::Point3F transform_origin;
   gfx::PointF position;
   gfx::Size bounds(100, 100);
   SetLayerPropertiesForTesting(root.get(),
                                identity_matrix,
                                transform_origin,
                                position,
                                bounds,
                                true,
-                               false);
+                               false,
+                               true);
   root->SetDrawsContent(true);
   root->SetShouldFlattenTransform(false);
   root->Set3dSortingContextId(1);
   {
     // child 1 and child2 are initialized to overlap between x=50 and x=60.
     // grand_child is set to overlap both child1 and child2 between y=50 and
     // y=60.  The expected stacking order is: (front) child2, (second)
     // grand_child, (third) child1, and (back) the root layer behind all other
     // layers.
 
@@ skipping 128 matching lines @@
   gfx::Transform identity_matrix;
   gfx::Point3F transform_origin;
   gfx::PointF position;
   gfx::Size bounds(100, 100);
   SetLayerPropertiesForTesting(root.get(),
                                identity_matrix,
                                transform_origin,
                                position,
                                bounds,
                                true,
-                               false);
+                               false,
+                               true);
   root->SetDrawsContent(true);
   {
     scoped_ptr<LayerImpl> child =
         LayerImpl::Create(host_impl().active_tree(), 2);
     scoped_ptr<LayerImpl> grand_child =
         LayerImpl::Create(host_impl().active_tree(), 4);
 
     position = gfx::PointF(10.f, 10.f);
     bounds = gfx::Size(1, 1);
     SetLayerPropertiesForTesting(child.get(),
                                  identity_matrix,
                                  transform_origin,
                                  position,
                                  bounds,
                                  true,
                                  false);
     child->SetDrawsContent(true);
     child->SetMasksToBounds(true);
 
     position = gfx::PointF(0.f, 40.f);
     bounds = gfx::Size(100, 50);
     SetLayerPropertiesForTesting(grand_child.get(),
                                  identity_matrix,
                                  transform_origin,
                                  position,
                                  bounds,
                                  true,
                                  false);
     grand_child->SetDrawsContent(true);
-    grand_child->SetForceRenderSurface(true);
+    grand_child->CreateRenderSurface();
 
     // This should let |grand_child| "escape" |child|'s clip.
     grand_child->SetClipParent(root.get());
 
     child->AddChild(grand_child.Pass());
     root->AddChild(child.Pass());
   }
 
   host_impl().SetViewportSize(root->bounds());
   host_impl().active_tree()->SetRootLayer(root.Pass());
@@ skipping 11 matching lines @@
   gfx::Transform identity_matrix;
   gfx::Point3F transform_origin;
   gfx::PointF position;
   gfx::Size bounds(100, 100);
   SetLayerPropertiesForTesting(root.get(),
                                identity_matrix,
                                transform_origin,
                                position,
                                bounds,
                                true,
-                               false);
+                               false,
+                               true);
   root->SetDrawsContent(true);
   {
     scoped_ptr<LayerImpl> child =
         LayerImpl::Create(host_impl().active_tree(), 2);
     scoped_ptr<LayerImpl> scroll_child =
         LayerImpl::Create(host_impl().active_tree(), 3);
     scoped_ptr<LayerImpl> grand_child =
         LayerImpl::Create(host_impl().active_tree(), 4);
 
     position = gfx::PointF(10.f, 10.f);
@@ skipping 24 matching lines @@
     scroll_child->SetScrollParent(child.get());
 
     SetLayerPropertiesForTesting(grand_child.get(),
                                  identity_matrix,
                                  transform_origin,
                                  position,
                                  bounds,
                                  true,
                                  false);
     grand_child->SetDrawsContent(true);
-    grand_child->SetForceRenderSurface(true);
+    grand_child->CreateRenderSurface();
 
     scroll_child->AddChild(grand_child.Pass());
     root->AddChild(scroll_child.Pass());
     root->AddChild(child.Pass());
   }
 
   host_impl().SetViewportSize(root->bounds());
   host_impl().active_tree()->SetRootLayer(root.Pass());
   host_impl().UpdateNumChildrenAndDrawPropertiesForActiveTree();
 
@@ skipping 15 matching lines @@
   gfx::Transform identity_matrix;
   gfx::Point3F transform_origin;
   gfx::PointF position;
   gfx::Size bounds(100, 100);
   SetLayerPropertiesForTesting(root.get(),
                                identity_matrix,
                                transform_origin,
                                position,
                                bounds,
                                true,
-                               false);
+                               false,
+                               true);
   root->SetDrawsContent(true);
   {
     // child 1 and child2 are initialized to overlap between x=50 and x=60.
     // grand_child is set to overlap both child1 and child2 between y=50 and
     // y=60.  The expected stacking order is: (front) child2, (second)
     // grand_child, (third) child1, and (back) the root layer behind all other
     // layers.
 
     scoped_ptr<LayerImpl> child1 =
         LayerImpl::Create(host_impl().active_tree(), 2);
     scoped_ptr<LayerImpl> child2 =
         LayerImpl::Create(host_impl().active_tree(), 3);
     scoped_ptr<LayerImpl> grand_child1 =
         LayerImpl::Create(host_impl().active_tree(), 4);
 
     position = gfx::PointF(10.f, 10.f);
     bounds = gfx::Size(50, 50);
     SetLayerPropertiesForTesting(child1.get(),
                                  identity_matrix,
                                  transform_origin,
                                  position,
                                  bounds,
                                  true,
                                  false);
     child1->SetDrawsContent(true);
-    child1->SetForceRenderSurface(true);
+    child1->CreateRenderSurface();
 
     position = gfx::PointF(50.f, 10.f);
     bounds = gfx::Size(50, 50);
     SetLayerPropertiesForTesting(child2.get(),
                                  identity_matrix,
                                  transform_origin,
                                  position,
                                  bounds,
                                  true,
                                  false);
     child2->SetDrawsContent(true);
-    child2->SetForceRenderSurface(true);
+    child2->CreateRenderSurface();
 
     // Remember that grand_child is positioned with respect to its parent (i.e.
     // child1).  In screen space, the intended position is (10, 50), with size
     // 100 x 50.
     position = gfx::PointF(0.f, 40.f);
     bounds = gfx::Size(100, 50);
     SetLayerPropertiesForTesting(grand_child1.get(),
                                  identity_matrix,
                                  transform_origin,
                                  position,
                                  bounds,
                                  true,
                                  false);
     grand_child1->SetDrawsContent(true);
-    grand_child1->SetForceRenderSurface(true);
+    grand_child1->CreateRenderSurface();
 
     child1->AddChild(grand_child1.Pass());
     root->AddChild(child1.Pass());
     root->AddChild(child2.Pass());
   }
 
   LayerImpl* child1 = root->children()[0];
   LayerImpl* child2 = root->children()[1];
   LayerImpl* grand_child1 = child1->children()[0];
 
@@ skipping 77 matching lines @@
   Region touch_handler_region(gfx::Rect(10, 10, 50, 50));
   gfx::Point3F transform_origin;
   gfx::PointF position;
   gfx::Size bounds(100, 100);
   SetLayerPropertiesForTesting(root.get(),
                                identity_matrix,
                                transform_origin,
                                position,
                                bounds,
                                true,
-                               false);
+                               false,
+                               true);
   root->SetDrawsContent(true);
 
   host_impl().SetViewportSize(root->bounds());
   host_impl().active_tree()->SetRootLayer(root.Pass());
   host_impl().UpdateNumChildrenAndDrawPropertiesForActiveTree();
 
   // Sanity check the scenario we just created.
   ASSERT_EQ(1u, RenderSurfaceLayerList().size());
   ASSERT_EQ(1u, root_layer()->render_surface()->layer_list().size());
 
@@ skipping 67 matching lines @@
   Region touch_handler_region(gfx::Rect(10, 10, 50, 50));
   gfx::Point3F transform_origin;
   gfx::PointF position;
   gfx::Size bounds(100, 100);
   SetLayerPropertiesForTesting(root.get(),
                                uninvertible_transform,
                                transform_origin,
                                position,
                                bounds,
                                true,
-                               false);
+                               false,
+                               true);
   root->SetDrawsContent(true);
   root->SetTouchEventHandlerRegion(touch_handler_region);
 
   host_impl().SetViewportSize(root->bounds());
   host_impl().active_tree()->SetRootLayer(root.Pass());
   host_impl().UpdateNumChildrenAndDrawPropertiesForActiveTree();
 
   // Sanity check the scenario we just created.
   ASSERT_EQ(1u, RenderSurfaceLayerList().size());
   ASSERT_EQ(1u, root_layer()->render_surface()->layer_list().size());
@@ skipping 57 matching lines @@
   // this layer is positioned, and hit testing should correctly know where the
   // layer is located.
   gfx::PointF position(50.f, 50.f);
   gfx::Size bounds(100, 100);
   SetLayerPropertiesForTesting(root.get(),
                                identity_matrix,
                                transform_origin,
                                position,
                                bounds,
                                true,
-                               false);
+                               false,
+                               true);
   root->SetDrawsContent(true);
   root->SetTouchEventHandlerRegion(touch_handler_region);
 
   host_impl().SetViewportSize(root->bounds());
   host_impl().active_tree()->SetRootLayer(root.Pass());
   host_impl().UpdateNumChildrenAndDrawPropertiesForActiveTree();
 
   // Sanity check the scenario we just created.
   ASSERT_EQ(1u, RenderSurfaceLayerList().size());
   ASSERT_EQ(1u, root_layer()->render_surface()->layer_list().size());
@@ skipping 55 matching lines @@
 
   gfx::Transform identity_matrix;
   gfx::Point3F transform_origin;
 
   SetLayerPropertiesForTesting(root.get(),
                                identity_matrix,
                                transform_origin,
                                gfx::PointF(),
                                gfx::Size(100, 100),
                                true,
-                               false);
+                               false,
+                               true);
   {
     Region touch_handler_region(gfx::Rect(10, 10, 30, 30));
     gfx::PointF position(25.f, 25.f);
     gfx::Size bounds(50, 50);
     scoped_ptr<LayerImpl> test_layer =
         LayerImpl::Create(host_impl().active_tree(), 12345);
     SetLayerPropertiesForTesting(test_layer.get(),
                                  identity_matrix,
                                  transform_origin,
                                  position,
@@ skipping 83 matching lines @@
 
   gfx::Transform identity_matrix;
   gfx::Point3F transform_origin;
   // Set the bounds of the root layer big enough to fit the child when scaled.
   SetLayerPropertiesForTesting(root.get(),
                                identity_matrix,
                                transform_origin,
                                gfx::PointF(),
                                gfx::Size(100, 100),
                                true,
-                               false);
+                               false,
+                               true);
   {
     Region touch_handler_region(gfx::Rect(10, 10, 30, 30));
     gfx::PointF position(25.f, 25.f);
     gfx::Size bounds(50, 50);
     scoped_ptr<LayerImpl> test_layer =
         LayerImpl::Create(host_impl().active_tree(), 12345);
     SetLayerPropertiesForTesting(test_layer.get(),
                                  identity_matrix,
                                  transform_origin,
                                  position,
@@ skipping 103 matching lines @@
   gfx::Transform identity_matrix;
   gfx::Point3F transform_origin;
 
   scoped_ptr<LayerImpl> root = LayerImpl::Create(host_impl().active_tree(), 1);
   SetLayerPropertiesForTesting(root.get(),
                                identity_matrix,
                                transform_origin,
                                gfx::PointF(),
                                gfx::Size(100, 100),
                                true,
-                               false);
+                               false,
+                               true);
   {
     scoped_ptr<LayerImpl> clipping_layer =
         LayerImpl::Create(host_impl().active_tree(), 123);
     // this layer is positioned, and hit testing should correctly know where the
     // layer is located.
     gfx::PointF position(25.f, 25.f);
     gfx::Size bounds(50, 50);
     SetLayerPropertiesForTesting(clipping_layer.get(),
                                  identity_matrix,
                                  transform_origin,
@@ skipping 74 matching lines @@
   gfx::Transform identity_matrix;
   gfx::Point3F transform_origin;
 
   scoped_ptr<LayerImpl> root = LayerImpl::Create(host_impl().active_tree(), 1);
   SetLayerPropertiesForTesting(root.get(),
                                identity_matrix,
                                transform_origin,
                                gfx::PointF(),
                                gfx::Size(100, 100),
                                true,
-                               false);
+                               false,
+                               true);
   {
     scoped_ptr<LayerImpl> touch_layer =
         LayerImpl::Create(host_impl().active_tree(), 123);
     // this layer is positioned, and hit testing should correctly know where the
     // layer is located.
     gfx::PointF position;
     gfx::Size bounds(50, 50);
     SetLayerPropertiesForTesting(touch_layer.get(),
                                  identity_matrix,
                                  transform_origin,
@@ skipping 76 matching lines @@
   gfx::Transform identity_matrix;
   gfx::Point3F transform_origin;
   gfx::PointF position;
   gfx::Size bounds(100, 100);
   SetLayerPropertiesForTesting(root.get(),
                                identity_matrix,
                                transform_origin,
                                position,
                                bounds,
                                true,
-                               false);
+                               false,
+                               true);
   root->SetDrawsContent(true);
 
   host_impl().SetViewportSize(root->bounds());
   host_impl().active_tree()->SetRootLayer(root.Pass());
   host_impl().UpdateNumChildrenAndDrawPropertiesForActiveTree();
 
   // Sanity check the scenario we just created.
   ASSERT_EQ(1u, RenderSurfaceLayerList().size());
   ASSERT_EQ(1u, root_layer()->render_surface()->layer_list().size());
 
@@ skipping 55 matching lines @@
   gfx::Transform identity_matrix;
   gfx::Point3F transform_origin;
   gfx::PointF position;
   gfx::Size bounds(100, 100);
   SetLayerPropertiesForTesting(root.get(),
                                identity_matrix,
                                transform_origin,
                                position,
                                bounds,
                                true,
-                               false);
+                               false,
+                               true);
 
   gfx::Vector2dF clipping_offset(10, 10);
   {
     scoped_ptr<LayerImpl> clipping_layer =
         LayerImpl::Create(host_impl().active_tree(), clip_layer_id);
     // The clipping layer should occlude the right selection bound.
     gfx::PointF position = gfx::PointF() + clipping_offset;
     gfx::Size bounds(50, 50);
     SetLayerPropertiesForTesting(clipping_layer.get(),
                                  identity_matrix,
@@ skipping 91 matching lines @@
   gfx::Transform identity_matrix;
   gfx::Point3F transform_origin;
   gfx::PointF position;
   gfx::Size bounds(100, 100);
   SetLayerPropertiesForTesting(root.get(),
                                identity_matrix,
                                transform_origin,
                                position,
                                bounds,
                                true,
-                               false);
+                               false,
+                               true);
 
   gfx::Vector2dF sub_layer_offset(10, 0);
   {
     scoped_ptr<LayerImpl> sub_layer =
         LayerImpl::Create(host_impl().active_tree(), sub_layer_id);
     gfx::PointF position = gfx::PointF() + sub_layer_offset;
     gfx::Size bounds(50, 50);
     SetLayerPropertiesForTesting(sub_layer.get(),
                                  identity_matrix,
                                  transform_origin,
@@ skipping 70 matching lines @@
   EXPECT_EQ(0u, host_impl().active_tree()->NumLayers());
   scoped_ptr<LayerImpl> root = LayerImpl::Create(host_impl().active_tree(), 1);
   root->AddChild(LayerImpl::Create(host_impl().active_tree(), 2));
   root->AddChild(LayerImpl::Create(host_impl().active_tree(), 3));
   root->child_at(1)->AddChild(LayerImpl::Create(host_impl().active_tree(), 4));
   EXPECT_EQ(4u, host_impl().active_tree()->NumLayers());
 }
 
 }  // namespace
 }  // namespace cc