cc: Rename LayerImpl::is_drawn_render_surface_layer_list_member

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 5385 matching lines @@
   RenderSurfaceList render_surface_list;
   LayerTreeHostCommon::CalcDrawPropsImplInputsForTesting inputs(
       root_layer, root_layer->bounds(), &render_surface_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.
   ASSERT_EQ(1u, render_surface_list.size());
   ASSERT_EQ(2, root_layer->GetRenderSurface()->num_contributors());
-  EXPECT_TRUE(root_layer->is_drawn_render_surface_layer_list_member());
-  EXPECT_TRUE(child_layer->is_drawn_render_surface_layer_list_member());
-  EXPECT_FALSE(grand_child_layer->is_drawn_render_surface_layer_list_member());
+  EXPECT_TRUE(root_layer->contributes_to_drawn_render_surface());
+  EXPECT_TRUE(child_layer->contributes_to_drawn_render_surface());
+  EXPECT_FALSE(grand_child_layer->contributes_to_drawn_render_surface());
 }
 
 TEST_F(LayerTreeHostCommonTest, SubtreeHidden_TwoLayersImpl) {
   FakeImplTaskRunnerProvider task_runner_provider;
   TestTaskGraphRunner task_graph_runner;
   FakeLayerTreeHostImpl host_impl(&task_runner_provider, &task_graph_runner);
   host_impl.CreatePendingTree();
 
   std::unique_ptr<LayerImpl> root =
       LayerImpl::Create(host_impl.pending_tree(), 1);
@@ skipping 21 matching lines @@
   RenderSurfaceList render_surface_list;
   LayerTreeHostCommon::CalcDrawPropsImplInputsForTesting inputs(
       root_layer, root_layer->bounds(), &render_surface_list);
   inputs.can_adjust_raster_scales = true;
   LayerTreeHostCommon::CalculateDrawPropertiesForTesting(&inputs);
 
   // We should have one render surface and one layer. The child has
   // hidden itself and the grand child.
   ASSERT_EQ(1u, render_surface_list.size());
   ASSERT_EQ(1, root_layer->GetRenderSurface()->num_contributors());
-  EXPECT_TRUE(root_layer->is_drawn_render_surface_layer_list_member());
-  EXPECT_FALSE(child_layer->is_drawn_render_surface_layer_list_member());
-  EXPECT_FALSE(grand_child_layer->is_drawn_render_surface_layer_list_member());
+  EXPECT_TRUE(root_layer->contributes_to_drawn_render_surface());
+  EXPECT_FALSE(child_layer->contributes_to_drawn_render_surface());
+  EXPECT_FALSE(grand_child_layer->contributes_to_drawn_render_surface());
 }
 
 void EmptyCopyOutputCallback(std::unique_ptr<CopyOutputResult> result) {}
 
 TEST_F(LayerTreeHostCommonTest, SubtreeHiddenWithCopyRequest) {
   FakeImplTaskRunnerProvider task_runner_provider;
   TestTaskGraphRunner task_graph_runner;
   FakeLayerTreeHostImpl host_impl(&task_runner_provider, &task_graph_runner);
   host_impl.CreatePendingTree();
 
@@ skipping 87 matching lines @@
   // parent since it has opacity and two drawing descendants, one for the parent
   // since it owns a surface, and one for the copy_layer.
   ASSERT_EQ(4u, render_surface_list.size());
   EXPECT_EQ(root_layer->id(), render_surface_list.at(0)->id());
   EXPECT_EQ(copy_grand_parent_layer->id(), render_surface_list.at(1)->id());
   EXPECT_EQ(copy_parent_layer->id(), render_surface_list.at(2)->id());
   EXPECT_EQ(copy_layer->id(), render_surface_list.at(3)->id());
 
   // The root render surface should have 2 contributing layers.
   EXPECT_EQ(2, root_layer->GetRenderSurface()->num_contributors());
-  EXPECT_TRUE(root_layer->is_drawn_render_surface_layer_list_member());
-  EXPECT_FALSE(
-      copy_grand_parent_layer->is_drawn_render_surface_layer_list_member());
+  EXPECT_TRUE(root_layer->contributes_to_drawn_render_surface());
+  EXPECT_FALSE(copy_grand_parent_layer->contributes_to_drawn_render_surface());
   EXPECT_FALSE(copy_grand_parent_sibling_before_layer
-                   ->is_drawn_render_surface_layer_list_member());
+                   ->contributes_to_drawn_render_surface());
   EXPECT_FALSE(copy_grand_parent_sibling_after_layer
-                   ->is_drawn_render_surface_layer_list_member());
+                   ->contributes_to_drawn_render_surface());
 
   // Nothing actually draws into the copy parent, so only the copy_layer will
   // appear in its list, since it needs to be drawn for the copy request.
   ASSERT_EQ(1, copy_parent_layer->GetRenderSurface()->num_contributors());
-  EXPECT_FALSE(copy_parent_layer->is_drawn_render_surface_layer_list_member());
+  EXPECT_FALSE(copy_parent_layer->contributes_to_drawn_render_surface());
 
   // The copy layer's render surface should have 2 contributing layers.
   ASSERT_EQ(2, copy_layer->GetRenderSurface()->num_contributors());
-  EXPECT_TRUE(copy_layer->is_drawn_render_surface_layer_list_member());
-  EXPECT_TRUE(copy_child_layer->is_drawn_render_surface_layer_list_member());
-  EXPECT_FALSE(
-      copy_grand_child_layer->is_drawn_render_surface_layer_list_member());
+  EXPECT_TRUE(copy_layer->contributes_to_drawn_render_surface());
+  EXPECT_TRUE(copy_child_layer->contributes_to_drawn_render_surface());
+  EXPECT_FALSE(copy_grand_child_layer->contributes_to_drawn_render_surface());
 
   // copy_grand_parent, copy_parent shouldn't be drawn because they are hidden,
   // but the copy_layer and copy_child should be drawn for the copy request.
   // copy grand child should not be drawn as its hidden even in the copy
   // request.
   EffectTree& tree =
       root_layer->layer_tree_impl()->property_trees()->effect_tree;
   EffectNode* node = tree.Node(copy_grand_parent_layer->effect_tree_index());
   EXPECT_FALSE(node->is_drawn);
   node = tree.Node(copy_parent_layer->effect_tree_index());
@@ skipping 52 matching lines @@
   inputs.can_adjust_raster_scales = true;
   LayerTreeHostCommon::CalculateDrawPropertiesForTesting(&inputs);
 
   // We should have two render surface, as the others are clipped out.
   ASSERT_EQ(2u, render_surface_list.size());
   EXPECT_EQ(root_layer->id(), render_surface_list.at(0)->id());
 
   // The root render surface should have only 2 contributing layer, since the
   // other layers are clipped away.
   ASSERT_EQ(2, root_layer->GetRenderSurface()->num_contributors());
-  EXPECT_TRUE(root_layer->is_drawn_render_surface_layer_list_member());
+  EXPECT_TRUE(root_layer->contributes_to_drawn_render_surface());
 }
 
 TEST_F(LayerTreeHostCommonTest, VisibleRectInNonRootCopyRequest) {
   LayerImpl* root = root_layer_for_testing();
   root->SetBounds(gfx::Size(50, 50));
   root->SetDrawsContent(true);
   root->SetMasksToBounds(true);
 
   LayerImpl* copy_layer = AddChild<LayerImpl>(root);
   copy_layer->SetBounds(gfx::Size(100, 100));
@@ skipping 614 matching lines @@
   child->SetBounds(gfx::Size(30, 30));
   child->test_properties()->double_sided = false;
   child->test_properties()->should_flatten_transform = false;
   grand_child->SetBounds(gfx::Size(20, 20));
   grand_child->SetDrawsContent(true);
   grand_child->SetUseParentBackfaceVisibility(true);
   grand_child->test_properties()->should_flatten_transform = false;
   ExecuteCalculateDrawProperties(root);
 
   EXPECT_EQ(1u, render_surface_list_impl()->size());
-  EXPECT_TRUE(grand_child->is_drawn_render_surface_layer_list_member());
+  EXPECT_TRUE(grand_child->contributes_to_drawn_render_surface());
 
   // As all layers have identity transform, we shouldn't check for backface
   // visibility.
   EXPECT_FALSE(root->should_check_backface_visibility());
   EXPECT_FALSE(child->should_check_backface_visibility());
   EXPECT_FALSE(grand_child->should_check_backface_visibility());
   // As there are no 3d rendering contexts, all layers should use their local
   // transform for backface visibility.
   EXPECT_TRUE(root->use_local_transform_for_backface_visibility());
   EXPECT_TRUE(child->use_local_transform_for_backface_visibility());
@@ skipping 319 matching lines @@
   ExecuteCalculateDrawProperties(root);
 
   EXPECT_TRUE(root->GetRenderSurface());
 
   EXPECT_EQ(gfx::Rect(0, 0, 20, 20), scroll_child->clip_rect());
   EXPECT_TRUE(scroll_child->is_clipped());
 
   // Despite the fact that we visited the above layers out of order to get the
   // correct clip, the layer lists should be unaffected.
   EXPECT_EQ(3, root->GetRenderSurface()->num_contributors());
-  EXPECT_TRUE(scroll_child->is_drawn_render_surface_layer_list_member());
-  EXPECT_TRUE(scroll_parent->is_drawn_render_surface_layer_list_member());
-  EXPECT_TRUE(scroll_grandparent->is_drawn_render_surface_layer_list_member());
+  EXPECT_TRUE(scroll_child->contributes_to_drawn_render_surface());
+  EXPECT_TRUE(scroll_parent->contributes_to_drawn_render_surface());
+  EXPECT_TRUE(scroll_grandparent->contributes_to_drawn_render_surface());
 }
 
 TEST_F(LayerTreeHostCommonTest, OutOfOrderClippingRequiresRSLLSorting) {
   // Ensures that even if we visit layers out of order, we still produce a
   // correctly ordered render surface layer list.
   // + root
   //   + scroll_child
   //   + scroll_parent_border
   //     + scroll_parent_clip
   //       + scroll_parent
@@ skipping 1728 matching lines @@
 
   child->test_properties()->AddChild(std::move(grand_child1));
   child->test_properties()->AddChild(std::move(grand_child2));
   parent->test_properties()->AddChild(std::move(child));
   grand_parent->test_properties()->AddChild(std::move(parent));
   host_impl.active_tree()->SetRootLayerForTesting(std::move(grand_parent));
 
   // Start with nothing being drawn.
   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());
+  EXPECT_FALSE(grand_parent_raw->contributes_to_drawn_render_surface());
+  EXPECT_FALSE(parent_raw->contributes_to_drawn_render_surface());
+  EXPECT_FALSE(child_raw->contributes_to_drawn_render_surface());
+  EXPECT_FALSE(grand_child1_raw->contributes_to_drawn_render_surface());
+  EXPECT_FALSE(grand_child2_raw->contributes_to_drawn_render_surface());
 
   std::set<LayerImpl*> expected;
   std::set<LayerImpl*> actual;
   GatherDrawnLayers(host_impl.active_tree(), &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->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());
+  EXPECT_FALSE(grand_parent_raw->contributes_to_drawn_render_surface());
+  EXPECT_FALSE(parent_raw->contributes_to_drawn_render_surface());
+  EXPECT_FALSE(child_raw->contributes_to_drawn_render_surface());
+  EXPECT_FALSE(grand_child1_raw->contributes_to_drawn_render_surface());
+  EXPECT_FALSE(grand_child2_raw->contributes_to_drawn_render_surface());
 
   expected.clear();
   actual.clear();
   GatherDrawnLayers(host_impl.active_tree(), &actual);
   EXPECT_EQ(expected, actual);
 
   // However, if we say that this layer also draws content, it will appear in
   // RSLL.
   grand_child1_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_TRUE(grand_child1_raw->is_drawn_render_surface_layer_list_member());
-  EXPECT_FALSE(grand_child2_raw->is_drawn_render_surface_layer_list_member());
+  EXPECT_FALSE(grand_parent_raw->contributes_to_drawn_render_surface());
+  EXPECT_FALSE(parent_raw->contributes_to_drawn_render_surface());
+  EXPECT_FALSE(child_raw->contributes_to_drawn_render_surface());
+  EXPECT_TRUE(grand_child1_raw->contributes_to_drawn_render_surface());
+  EXPECT_FALSE(grand_child2_raw->contributes_to_drawn_render_surface());
 
   expected.clear();
   expected.insert(grand_child1_raw);
 
   actual.clear();
   GatherDrawnLayers(host_impl.active_tree(), &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->test_properties()->force_render_surface = false;
   grand_child1_raw->layer_tree_impl()->property_trees()->needs_rebuild = 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());
+  EXPECT_FALSE(grand_parent_raw->contributes_to_drawn_render_surface());
+  EXPECT_FALSE(parent_raw->contributes_to_drawn_render_surface());
+  EXPECT_FALSE(child_raw->contributes_to_drawn_render_surface());
+  EXPECT_FALSE(grand_child1_raw->contributes_to_drawn_render_surface());
+  EXPECT_TRUE(grand_child2_raw->contributes_to_drawn_render_surface());
 
   expected.clear();
   expected.insert(grand_child2_raw);
 
   actual.clear();
   GatherDrawnLayers(host_impl.active_tree(), &actual);
   EXPECT_EQ(expected, actual);
 
   // Add a mask layer to child.
   child_raw->test_properties()->SetMaskLayer(
       LayerImpl::Create(host_impl.active_tree(), 6));
   child_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_parent_raw->contributes_to_drawn_render_surface());
+  EXPECT_FALSE(parent_raw->contributes_to_drawn_render_surface());
+  EXPECT_FALSE(child_raw->contributes_to_drawn_render_surface());
   EXPECT_TRUE(child_raw->test_properties()
-                  ->mask_layer->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());
+                  ->mask_layer->contributes_to_drawn_render_surface());
+  EXPECT_FALSE(grand_child1_raw->contributes_to_drawn_render_surface());
+  EXPECT_TRUE(grand_child2_raw->contributes_to_drawn_render_surface());
 
   expected.clear();
   expected.insert(grand_child2_raw);
   expected.insert(child_raw->test_properties()->mask_layer);
 
   expected.clear();
   expected.insert(grand_child2_raw);
   expected.insert(child_raw->test_properties()->mask_layer);
 
   actual.clear();
   GatherDrawnLayers(host_impl.active_tree(), &actual);
   EXPECT_EQ(expected, actual);
 
   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_parent_raw->contributes_to_drawn_render_surface());
+  EXPECT_FALSE(parent_raw->contributes_to_drawn_render_surface());
+  EXPECT_FALSE(child_raw->contributes_to_drawn_render_surface());
   EXPECT_TRUE(child_raw->test_properties()
-                  ->mask_layer->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());
+                  ->mask_layer->contributes_to_drawn_render_surface());
+  EXPECT_FALSE(grand_child1_raw->contributes_to_drawn_render_surface());
+  EXPECT_TRUE(grand_child2_raw->contributes_to_drawn_render_surface());
 
   expected.clear();
   expected.insert(grand_child2_raw);
   expected.insert(child_raw->test_properties()->mask_layer);
 
   actual.clear();
   GatherDrawnLayers(host_impl.active_tree(), &actual);
   EXPECT_EQ(expected, actual);
 
   child_raw->layer_tree_impl()->property_trees()->needs_rebuild = true;
 
   // With nothing drawing, we should have no layers.
   grand_child2_raw->SetDrawsContent(false);
 
   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_parent_raw->contributes_to_drawn_render_surface());
+  EXPECT_FALSE(parent_raw->contributes_to_drawn_render_surface());
+  EXPECT_FALSE(child_raw->contributes_to_drawn_render_surface());
   EXPECT_FALSE(child_raw->test_properties()
-                   ->mask_layer->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());
+                   ->mask_layer->contributes_to_drawn_render_surface());
+  EXPECT_FALSE(grand_child1_raw->contributes_to_drawn_render_surface());
+  EXPECT_FALSE(grand_child2_raw->contributes_to_drawn_render_surface());
 
   expected.clear();
   actual.clear();
   GatherDrawnLayers(host_impl.active_tree(), &actual);
   EXPECT_EQ(expected, actual);
 
   // Child itself draws means that we should have the child and the mask in the
   // list.
   child_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_TRUE(child_raw->is_drawn_render_surface_layer_list_member());
+  EXPECT_FALSE(grand_parent_raw->contributes_to_drawn_render_surface());
+  EXPECT_FALSE(parent_raw->contributes_to_drawn_render_surface());
+  EXPECT_TRUE(child_raw->contributes_to_drawn_render_surface());
   EXPECT_TRUE(child_raw->test_properties()
-                  ->mask_layer->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());
+                  ->mask_layer->contributes_to_drawn_render_surface());
+  EXPECT_FALSE(grand_child1_raw->contributes_to_drawn_render_surface());
+  EXPECT_FALSE(grand_child2_raw->contributes_to_drawn_render_surface());
 
   expected.clear();
   expected.insert(child_raw);
   expected.insert(child_raw->test_properties()->mask_layer);
   actual.clear();
   GatherDrawnLayers(host_impl.active_tree(), &actual);
   EXPECT_EQ(expected, actual);
 
   child_raw->test_properties()->SetMaskLayer(nullptr);
   child_raw->layer_tree_impl()->property_trees()->needs_rebuild = true;
 
   // Now everyone's a member!
   grand_parent_raw->SetDrawsContent(true);
   parent_raw->SetDrawsContent(true);
   child_raw->SetDrawsContent(true);
   grand_child1_raw->SetDrawsContent(true);
   grand_child2_raw->SetDrawsContent(true);
 
   ExecuteCalculateDrawProperties(grand_parent_raw);
 
-  EXPECT_TRUE(grand_parent_raw->is_drawn_render_surface_layer_list_member());
-  EXPECT_TRUE(parent_raw->is_drawn_render_surface_layer_list_member());
-  EXPECT_TRUE(child_raw->is_drawn_render_surface_layer_list_member());
-  EXPECT_TRUE(grand_child1_raw->is_drawn_render_surface_layer_list_member());
-  EXPECT_TRUE(grand_child2_raw->is_drawn_render_surface_layer_list_member());
+  EXPECT_TRUE(grand_parent_raw->contributes_to_drawn_render_surface());
+  EXPECT_TRUE(parent_raw->contributes_to_drawn_render_surface());
+  EXPECT_TRUE(child_raw->contributes_to_drawn_render_surface());
+  EXPECT_TRUE(grand_child1_raw->contributes_to_drawn_render_surface());
+  EXPECT_TRUE(grand_child2_raw->contributes_to_drawn_render_surface());
 
   expected.clear();
   expected.insert(grand_parent_raw);
   expected.insert(parent_raw);
   expected.insert(child_raw);
   expected.insert(grand_child1_raw);
   expected.insert(grand_child2_raw);
 
   actual.clear();
   GatherDrawnLayers(host_impl.active_tree(), &actual);
@@ skipping 1739 matching lines @@
 
   root->SetBounds(gfx::Size(40, 40));
   root->SetDrawsContent(true);
   child->test_properties()->transform = transform;
   child->SetBounds(gfx::Size(30, 30));
   child->SetDrawsContent(false);
   mask->SetBounds(gfx::Size(20, 20));
   ExecuteCalculateDrawProperties(root);
 
   // The render surface created for the mask has no contributing content, so the
   // mask isn't a drawn RSLL member. This means it has an empty visible rect,

[jaydasika, 2017/05/01 16:49:22]

Can you also change the comment, since there is no RSLL ?

[ajuma, 2017/05/01 17:23:59]

Done.

   // but its screen space transform can still be computed correctly on-demand.
-  EXPECT_FALSE(mask->is_drawn_render_surface_layer_list_member());
+  EXPECT_FALSE(mask->contributes_to_drawn_render_surface());
   EXPECT_EQ(gfx::Rect(), mask->visible_layer_rect());
   EXPECT_TRANSFORMATION_MATRIX_EQ(transform, mask->ScreenSpaceTransform());
 
   // Make the child's render surface have contributing content.
   child->SetDrawsContent(true);
   root->layer_tree_impl()->property_trees()->needs_rebuild = true;
   ExecuteCalculateDrawProperties(root);
-  EXPECT_TRUE(mask->is_drawn_render_surface_layer_list_member());
+  EXPECT_TRUE(mask->contributes_to_drawn_render_surface());
   EXPECT_EQ(gfx::Rect(20, 20), mask->visible_layer_rect());
   EXPECT_TRANSFORMATION_MATRIX_EQ(transform, mask->ScreenSpaceTransform());
 
   transform.Translate(10, 10);
   child->test_properties()->transform = transform;
   root->layer_tree_impl()->property_trees()->needs_rebuild = true;
   ExecuteCalculateDrawProperties(root);
   EXPECT_TRANSFORMATION_MATRIX_EQ(transform, mask->ScreenSpaceTransform());
   EXPECT_EQ(gfx::Rect(20, 20), mask->visible_layer_rect());
 }
@@ skipping 506 matching lines @@
 
   // Check child layer draw properties.
   EXPECT_EQ(gfx::Rect(10, 10), child->visible_layer_rect());
   EXPECT_EQ(gfx::Transform(), child->DrawTransform());
   EXPECT_EQ(gfx::Rect(10, 10), child->clip_rect());
   EXPECT_EQ(gfx::Rect(10, 10), child->drawable_content_rect());
 }
 
 }  // namespace
 }  // namespace cc