Moving RenderSurface creation outside of CalcDrawProps

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 <set>
 
 #include "cc/animation/layer_animation_controller.h"
 #include "cc/animation/transform_operations.h"
@@ skipping 328 matching lines @@
 
   scoped_ptr<LayerImpl> root(LayerImpl::Create(host_impl.active_tree(), 3));
   SetLayerPropertiesForTesting(root.get(),
                                identity_matrix,
                                gfx::Point3F(),
                                gfx::PointF(),
                                gfx::Size(3, 4),
                                true,
                                false);
   root->AddChild(clip_layer_scoped_ptr.Pass());
+  root->CreateRenderSurface();
 
   ExecuteCalculateDrawProperties(
       root.get(), kDeviceScale, kPageScale, scroll_layer->parent());
   gfx::Transform expected_transform = identity_matrix;
   gfx::PointF sub_layer_screen_position = kScrollLayerPosition - kScrollDelta;
   sub_layer_screen_position.Scale(kPageScale * kDeviceScale);
   expected_transform.Translate(MathUtil::Round(sub_layer_screen_position.x()),
                                MathUtil::Round(sub_layer_screen_position.y()));
   EXPECT_TRANSFORMATION_MATRIX_EQ(expected_transform,
                                   sublayer->draw_transform());
@@ skipping 5289 matching lines @@
                                true,
                                false);
   child->SetDrawsContent(true);
   child->SetOpacity(0.0f);
 
   // Add opacity animation.
   AddOpacityTransitionToController(
       child->layer_animation_controller(), 10.0, 0.0f, 1.0f, false);
 
   root->AddChild(child.Pass());
+  root->CreateRenderSurface();
 
   LayerImplList render_surface_layer_list;
   LayerTreeHostCommon::CalcDrawPropsImplInputsForTesting inputs(
       root.get(), root->bounds(), &render_surface_layer_list);
   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());
@@ skipping 246 matching lines @@
                                gfx::Point3F(),
                                gfx::PointF(),
                                gfx::Size(30, 30),
                                true,
                                false);
   grand_child->SetDrawsContent(true);
   grand_child->SetHideLayerAndSubtree(true);
 
   child->AddChild(grand_child.Pass());
   root->AddChild(child.Pass());
+  root->CreateRenderSurface();
 
   LayerImplList render_surface_layer_list;
   LayerTreeHostCommon::CalcDrawPropsImplInputsForTesting inputs(
       root.get(), root->bounds(), &render_surface_layer_list);
   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());
@@ skipping 93 matching lines @@
                                identity_matrix,
                                gfx::Point3F(),
                                gfx::PointF(),
                                gfx::Size(30, 30),
                                true,
                                false);
   grand_child->SetDrawsContent(true);
 
   child->AddChild(grand_child.Pass());
   root->AddChild(child.Pass());
+  root->CreateRenderSurface();
 
   LayerImplList render_surface_layer_list;
   LayerTreeHostCommon::CalcDrawPropsImplInputsForTesting inputs(
       root.get(), root->bounds(), &render_surface_layer_list);
   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());
@@ skipping 832 matching lines @@
             render_surface2->render_surface()->content_rect().ToString());
 
   // Sanity check our num_unclipped_descendants values.
   EXPECT_EQ(1, render_surface1->num_unclipped_descendants());
   EXPECT_EQ(0, render_surface2->num_unclipped_descendants());
 }
 
 TEST_F(LayerTreeHostCommonTest, CanRenderToSeparateSurface) {
   FakeImplProxy proxy;
   TestSharedBitmapManager shared_bitmap_manager;
-  FakeLayerTreeHostImpl host_impl(&proxy, &shared_bitmap_manager);
-  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);
+  scoped_ptr<LayerTreeHost> host =
+      FakeLayerTreeHost::Create().PassAs<LayerTreeHost>();
+  scoped_refptr<Layer> root = Layer::Create();
+  root->SetLayerTreeHost(host.get());
+  scoped_refptr<Layer> child1 = Layer::Create();
+  scoped_refptr<Layer> child2 = Layer::Create();
+  scoped_refptr<Layer> child3 = Layer::Create();
 
   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);
-  root->SetDrawsContent(true);
+  root->SetIsDrawable(true);
 
   // This layer structure normally forces render surface due to preserves3d
   // behavior.
   SetLayerPropertiesForTesting(child1.get(),
                                identity_matrix,
                                transform_origin,
                                position,
                                bounds,
                                false,
                                true);
-  child1->SetDrawsContent(true);
+  child1->SetIsDrawable(true);
   SetLayerPropertiesForTesting(child2.get(),
                                identity_matrix,
                                transform_origin,
                                position,
                                bounds,
                                true,
                                false);
-  child2->SetDrawsContent(true);
+  child2->SetIsDrawable(true);
   SetLayerPropertiesForTesting(child3.get(),
                                identity_matrix,
                                transform_origin,
                                position,
                                bounds,
                                true,
                                false);
-  child3->SetDrawsContent(true);
+  child3->SetIsDrawable(true);
 
   child2->Set3dSortingContextId(1);
   child3->Set3dSortingContextId(1);
 
-  child2->AddChild(child3.Pass());
-  child1->AddChild(child2.Pass());
-  root->AddChild(child1.Pass());
+  child2->AddChild(child3.get());
+  child1->AddChild(child2.get());
+  root->AddChild(child1.get());
 
   {
-    LayerImplList render_surface_layer_list;
-    FakeLayerTreeHostImpl::RecursiveUpdateNumChildren(root.get());
-    LayerTreeHostCommon::CalcDrawPropsImplInputsForTesting inputs(
+    RenderSurfaceLayerList render_surface_layer_list;
+    LayerTreeHostCommon::CalcDrawPropsMainInputsForTesting inputs(
         root.get(), root->bounds(), &render_surface_layer_list);
     inputs.can_render_to_separate_surface = true;
     LayerTreeHostCommon::CalculateDrawProperties(&inputs);
 
     EXPECT_EQ(2u, render_surface_layer_list.size());
   }
 
   {
-    LayerImplList render_surface_layer_list;
-    LayerTreeHostCommon::CalcDrawPropsImplInputsForTesting inputs(
+    RenderSurfaceLayerList render_surface_layer_list;
+    LayerTreeHostCommon::CalcDrawPropsMainInputsForTesting inputs(
         root.get(), root->bounds(), &render_surface_layer_list);
     inputs.can_render_to_separate_surface = false;
     LayerTreeHostCommon::CalculateDrawProperties(&inputs);
 
     EXPECT_EQ(1u, render_surface_layer_list.size());
   }
+  root->SetLayerTreeHost(NULL);
 }
 
 TEST_F(LayerTreeHostCommonTest, DoNotIncludeBackfaceInvisibleSurfaces) {
   scoped_refptr<Layer> root = Layer::Create();
   scoped_refptr<Layer> render_surface = Layer::Create();
   scoped_refptr<LayerWithForcedDrawsContent> child =
       make_scoped_refptr(new LayerWithForcedDrawsContent);
 
   root->AddChild(render_surface);
   render_surface->AddChild(child);
@@ skipping 598 matching lines @@
   top_transform.Translate3d(0.0, 0.0, 5.0);
   gfx::Transform bottom_transform;
   bottom_transform.Translate3d(0.0, 0.0, 3.0);
 
   SetLayerPropertiesForTesting(root.get(),
                                identity_transform,
                                gfx::Point3F(),
                                gfx::PointF(),
                                gfx::Size(50, 50),
                                true,
-                               false);
+                               false,
+                               true);
   SetLayerPropertiesForTesting(scroll_parent_border.get(),
                                identity_transform,
                                gfx::Point3F(),
                                gfx::PointF(),
                                gfx::Size(40, 40),
                                true,
+                               false,
                                false);
   SetLayerPropertiesForTesting(scroll_parent_clip.get(),
                                identity_transform,
                                gfx::Point3F(),
                                gfx::PointF(),
                                gfx::Size(30, 30),
                                true,
                                false);
   SetLayerPropertiesForTesting(scroll_parent.get(),
                                identity_transform,
                                gfx::Point3F(),
                                gfx::PointF(),
                                gfx::Size(50, 50),
                                true,
-                               false);
+                               true);
   SetLayerPropertiesForTesting(scroll_child.get(),
                                identity_transform,
                                gfx::Point3F(),
                                gfx::PointF(),
                                gfx::Size(50, 50),
                                true,
                                false);
   SetLayerPropertiesForTesting(top_content.get(),
                                top_transform,
                                gfx::Point3F(),
                                gfx::PointF(),
                                gfx::Size(50, 50),
                                false,
+                               true,
                                true);
   SetLayerPropertiesForTesting(bottom_content.get(),
                                bottom_transform,
                                gfx::Point3F(),
                                gfx::PointF(),
                                gfx::Size(50, 50),
                                false,
+                               true,
                                true);
 
   scroll_child->SetShouldFlattenTransform(false);
   scroll_child->Set3dSortingContextId(1);
 
   scroll_child->AddChild(top_content.Pass());
   scroll_child->AddChild(bottom_content.Pass());
   root->AddChild(scroll_child.Pass());
 
   scroll_parent_clip->AddChild(scroll_parent.Pass());
@@ skipping 56 matching lines @@
   gfx::Transform container_transform;
   container_transform.Translate3d(10.0, 20.0, 0.0);
   gfx::Vector2dF container_offset = container_transform.To2dTranslation();
 
   SetLayerPropertiesForTesting(root.get(),
                                identity_transform,
                                gfx::Point3F(),
                                gfx::PointF(),
                                gfx::Size(50, 50),
                                true,
-                               false);
+                               false,
+                               true);
   SetLayerPropertiesForTesting(container.get(),
                                container_transform,
                                gfx::Point3F(),
                                gfx::PointF(),
                                gfx::Size(40, 40),
                                true,
                                false);
   SetLayerPropertiesForTesting(scroller.get(),
                                identity_transform,
                                gfx::Point3F(),
@@ skipping 143 matching lines @@
   child->AddChild(grand_child.PassAs<LayerImpl>());
   parent->AddChild(child.PassAs<LayerImpl>());
   grand_parent->AddChild(parent.PassAs<LayerImpl>());
 
   SetLayerPropertiesForTesting(grand_parent.get(),
                                identity_matrix,
                                gfx::Point3F(),
                                gfx::PointF(),
                                gfx::Size(1, 2),
                                true,
-                               false);
+                               false,
+                               true);
   SetLayerPropertiesForTesting(parent_raw,
                                identity_matrix,
                                gfx::Point3F(),
                                gfx::PointF(),
                                gfx::Size(1, 2),
                                true,
                                false);
   SetLayerPropertiesForTesting(child_raw,
                                identity_matrix,
                                gfx::Point3F(),
@@ skipping 215 matching lines @@
   child->AddChild(grand_child2.Pass());
   parent->AddChild(child.Pass());
   grand_parent->AddChild(parent.Pass());
 
   SetLayerPropertiesForTesting(grand_parent_raw,
                                identity_matrix,
                                gfx::Point3F(),
                                gfx::PointF(),
                                gfx::Size(1, 2),
                                true,
-                               false);
+                               false,
+                               true);
   SetLayerPropertiesForTesting(parent_raw,
                                identity_matrix,
                                gfx::Point3F(),
                                gfx::PointF(),
                                gfx::Size(1, 2),
                                true,
                                false);
   SetLayerPropertiesForTesting(child_raw,
                                identity_matrix,
                                gfx::Point3F(),
@@ skipping 26 matching lines @@
   EXPECT_NE(member_id, membership_id(grand_child1_raw));
   EXPECT_NE(member_id, membership_id(grand_child2_raw));
 
   std::set<LayerImpl*> expected;
   std::set<LayerImpl*> actual;
   GatherDrawnLayers(render_surface_layer_list_impl(), &actual);
   EXPECT_EQ(expected, actual);
 
   // If we force render surface, but none of the layers are in the layer list,
   // then this layer should not appear in RSLL.
-  grand_child1_raw->SetForceRenderSurface(true);
+  grand_child1_raw->CreateRenderSurface();
 
   ExecuteCalculateDrawProperties(grand_parent_raw);
   member_id = render_surface_layer_list_count();
 
   EXPECT_NE(member_id, membership_id(grand_parent_raw));
   EXPECT_NE(member_id, membership_id(parent_raw));
   EXPECT_NE(member_id, membership_id(child_raw));
   EXPECT_NE(member_id, membership_id(grand_child1_raw));
   EXPECT_NE(member_id, membership_id(grand_child2_raw));
 
@@ skipping 18 matching lines @@
   expected.clear();
   expected.insert(grand_child1_raw);
 
   actual.clear();
   GatherDrawnLayers(render_surface_layer_list_impl(), &actual);
   EXPECT_EQ(expected, actual);
 
   // Now child is forced to have a render surface, and one if its children draws
   // content.
   grand_child1_raw->SetDrawsContent(false);
-  grand_child1_raw->SetForceRenderSurface(false);
-  child_raw->SetForceRenderSurface(true);
+  grand_child1_raw->ClearRenderSurface();
+  child_raw->CreateRenderSurface();
   grand_child2_raw->SetDrawsContent(true);
 
   ExecuteCalculateDrawProperties(grand_parent_raw);
   member_id = render_surface_layer_list_count();
 
   EXPECT_NE(member_id, membership_id(grand_parent_raw));
   EXPECT_NE(member_id, membership_id(parent_raw));
   EXPECT_NE(member_id, membership_id(child_raw));
   EXPECT_NE(member_id, membership_id(grand_child1_raw));
   EXPECT_EQ(member_id, membership_id(grand_child2_raw));
@@ skipping 146 matching lines @@
       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);
+                               false,
+                               true);
   SetLayerPropertiesForTesting(child1_layer,
                                scale_transform_child1,
                                gfx::Point3F(),
                                gfx::PointF(),
                                gfx::Size(),
                                true,
                                false);
 
   child1_layer->SetMaskLayer(
       LayerImpl::Create(host_impl.active_tree(), 4).Pass());
@@ skipping 187 matching lines @@
   EXPECT_FLOAT_EQ(4.f,
                   child1_layer->replica_layer()
                       ->mask_layer()
                       ->draw_properties()
                       .device_scale_factor);
   EXPECT_FLOAT_EQ(4.f, child2_layer->draw_properties().device_scale_factor);
 }
 
 }  // namespace
 }  // namespace cc