cc: Remove direct calls to LayerImpl::SetHasRenderSurface from tests

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 <stddef.h>
 
 #include <algorithm>
 #include <memory>
@@ skipping 545 matching lines @@
   clip_layer->test_properties()->AddChild(std::move(scroll_layer_scoped_ptr));
   scroll_layer_raw_ptr->layer_tree_impl()
       ->property_trees()
       ->scroll_tree.UpdateScrollOffsetBaseForTesting(scroll_layer_raw_ptr->id(),
                                                      kScrollOffset);
 
   std::unique_ptr<LayerImpl> root(
       LayerImpl::Create(host_impl.active_tree(), 3));
   root->SetBounds(gfx::Size(3, 4));
   root->test_properties()->AddChild(std::move(clip_layer_scoped_ptr));
-  root->SetHasRenderSurface(true);
   LayerImpl* root_layer = root.get();
   host_impl.active_tree()->SetRootLayerForTesting(std::move(root));
 
   ExecuteCalculateDrawProperties(root_layer, kDeviceScale, page_scale,
                                  scroll_layer->test_properties()->parent,
                                  nullptr, nullptr);
   gfx::Transform expected_transform;
   gfx::PointF sub_layer_screen_position = kScrollLayerPosition - kScrollDelta;
   expected_transform.Translate(MathUtil::Round(sub_layer_screen_position.x() *
                                                page_scale * kDeviceScale),
@@ skipping 2800 matching lines @@
   child2->SetDrawsContent(true);
   grand_child1->SetDrawsContent(true);
   grand_child2->SetDrawsContent(true);
   leaf_node1->SetDrawsContent(true);
   leaf_node2->SetDrawsContent(true);
 
   // Case 1: No layers clip. Visible rects are clipped by the viewport.
   // 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);
+  child1->test_properties()->force_render_surface = true;
+  child2->test_properties()->force_render_surface = 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(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 1643 matching lines @@
   root->SetDrawsContent(true);
 
   std::unique_ptr<LayerImpl> child =
       LayerImpl::Create(host_impl.pending_tree(), 2);
   child->SetBounds(gfx::Size(50, 50));
   child->SetDrawsContent(true);
   child->test_properties()->opacity = 0.0f;
 
   const int child_id = child->id();
   root->test_properties()->AddChild(std::move(child));
-  root->SetHasRenderSurface(true);
   LayerImpl* root_layer = root.get();
   host_impl.pending_tree()->SetRootLayerForTesting(std::move(root));
   host_impl.pending_tree()->BuildLayerListAndPropertyTreesForTesting();
 
   // Add opacity animation.
   scoped_refptr<AnimationTimeline> timeline =
       AnimationTimeline::Create(AnimationIdProvider::NextTimelineId());
   host_impl.animation_host()->AddAnimationTimeline(timeline);
   host_impl.pending_tree()->SetElementIdsForTesting();
 
@@ skipping 304 matching lines @@
   child->SetDrawsContent(true);
 
   std::unique_ptr<LayerImpl> grand_child =
       LayerImpl::Create(host_impl.pending_tree(), 3);
   grand_child->SetBounds(gfx::Size(30, 30));
   grand_child->SetDrawsContent(true);
   grand_child->test_properties()->hide_layer_and_subtree = true;
 
   child->test_properties()->AddChild(std::move(grand_child));
   root->test_properties()->AddChild(std::move(child));
-  root->SetHasRenderSurface(true);
   host_impl.pending_tree()->SetRootLayerForTesting(std::move(root));
 
   LayerImplList render_surface_layer_list;
   LayerTreeHostCommon::CalcDrawPropsImplInputsForTesting inputs(
       root_layer, root_layer->bounds(), &render_surface_layer_list);
   inputs.can_adjust_raster_scales = true;
   LayerTreeHostCommon::CalculateDrawPropertiesForTesting(&inputs);
 
   // We should have one render surface and two layers. The grand child has
   // hidden itself.
@@ skipping 2937 matching lines @@
   EXPECT_FALSE(grand_child1_raw->is_drawn_render_surface_layer_list_member());
   EXPECT_FALSE(grand_child2_raw->is_drawn_render_surface_layer_list_member());
 
   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->SetHasRenderSurface(true);
+  grand_child1_raw->test_properties()->force_render_surface = true;
   grand_child1_raw->layer_tree_impl()->property_trees()->needs_rebuild = true;
 
   ExecuteCalculateDrawProperties(grand_parent_raw);
 
   EXPECT_FALSE(grand_parent_raw->is_drawn_render_surface_layer_list_member());
   EXPECT_FALSE(parent_raw->is_drawn_render_surface_layer_list_member());
   EXPECT_FALSE(child_raw->is_drawn_render_surface_layer_list_member());
   EXPECT_FALSE(grand_child1_raw->is_drawn_render_surface_layer_list_member());
   EXPECT_FALSE(grand_child2_raw->is_drawn_render_surface_layer_list_member());
 
@@ skipping 17 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->SetHasRenderSurface(false);
+  grand_child1_raw->test_properties()->force_render_surface = false;
   grand_child1_raw->layer_tree_impl()->property_trees()->needs_rebuild = true;
-  child_raw->SetHasRenderSurface(true);
+  child_raw->test_properties()->force_render_surface = true;
   grand_child2_raw->SetDrawsContent(true);
 
   ExecuteCalculateDrawProperties(grand_parent_raw);
 
   EXPECT_FALSE(grand_parent_raw->is_drawn_render_surface_layer_list_member());
   EXPECT_FALSE(parent_raw->is_drawn_render_surface_layer_list_member());
   EXPECT_FALSE(child_raw->is_drawn_render_surface_layer_list_member());
   EXPECT_FALSE(grand_child1_raw->is_drawn_render_surface_layer_list_member());
   EXPECT_TRUE(grand_child2_raw->is_drawn_render_surface_layer_list_member());
 
@@ skipping 1117 matching lines @@
       CopyOutputRequest::CreateEmptyRequest());
   root_ptr->layer_tree_impl()->property_trees()->needs_rebuild = true;
   ExecuteCalculateDrawPropertiesAndSaveUpdateLayerList(root_ptr);
   EXPECT_EQ(gfx::Rect(10, 10), grandchild_ptr->visible_layer_rect());
 
   host_impl.active_tree()->property_trees()->effect_tree.ClearCopyRequests();
   child_ptr->test_properties()->opacity = 1.f;
 
   // A double sided render surface with backface visible should not be skipped
   grandchild_ptr->set_visible_layer_rect(gfx::Rect());
-  child_ptr->SetHasRenderSurface(true);
+  child_ptr->test_properties()->force_render_surface = true;
   child_ptr->test_properties()->double_sided = true;
   child_ptr->test_properties()->transform = rotate_back_and_translate;
   root_ptr->layer_tree_impl()->property_trees()->needs_rebuild = true;
   ExecuteCalculateDrawPropertiesAndSaveUpdateLayerList(root_ptr);
   EXPECT_EQ(gfx::Rect(10, 10), grandchild_ptr->visible_layer_rect());
   child_ptr->test_properties()->transform = gfx::Transform();
 
   std::unique_ptr<KeyframedTransformAnimationCurve> curve(
       KeyframedTransformAnimationCurve::Create());
   TransformOperations start;
@@ skipping 1233 matching lines @@
   EXPECT_EQ(scroll_child6.id, grand_child10->scroll_tree_index());
   EXPECT_EQ(scroll_root1.id, parent3->scroll_tree_index());
   EXPECT_EQ(scroll_child7.id, child8->scroll_tree_index());
   EXPECT_EQ(scroll_root1.id, parent4->scroll_tree_index());
   EXPECT_EQ(scroll_root1.id, child9->scroll_tree_index());
   EXPECT_EQ(scroll_root1.id, grand_child12->scroll_tree_index());
 }
 
 }  // namespace
 }  // namespace cc