cc : Compute subtree has copy requests before property tree building

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 5520 matching lines @@
 
   copy_layer->test_properties()->copy_requests.push_back(
       CopyOutputRequest::CreateRequest(base::Bind(&EmptyCopyOutputCallback)));
 
   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);
 
-  EXPECT_GT(root_layer->num_copy_requests_in_target_subtree(), 0);
-  EXPECT_GT(copy_grand_parent_layer->num_copy_requests_in_target_subtree(), 0);
-  EXPECT_GT(copy_parent_layer->num_copy_requests_in_target_subtree(), 0);
-  EXPECT_GT(copy_layer->num_copy_requests_in_target_subtree(), 0);
+  EXPECT_TRUE(root_layer->has_copy_requests_in_target_subtree());
+  EXPECT_TRUE(copy_grand_parent_layer->has_copy_requests_in_target_subtree());
+  EXPECT_TRUE(copy_parent_layer->has_copy_requests_in_target_subtree());
+  EXPECT_TRUE(copy_layer->has_copy_requests_in_target_subtree());
 
   // We should have four render surfaces, one for the root, one for the grand
   // 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_layer_list.size());
   EXPECT_EQ(root_layer->id(), render_surface_layer_list.at(0)->id());
   EXPECT_EQ(copy_grand_parent_layer->id(),
             render_surface_layer_list.at(1)->id());
   EXPECT_EQ(copy_parent_layer->id(), render_surface_layer_list.at(2)->id());
   EXPECT_EQ(copy_layer->id(), render_surface_layer_list.at(3)->id());
@@ skipping 3782 matching lines @@
 
   scroll_child->SetPosition(gfx::PointF(0, -10.f));
   scroll_parent->SetCurrentScrollOffset(gfx::ScrollOffset(0.f, 10.f));
   root->layer_tree_impl()->property_trees()->needs_rebuild = true;
   ExecuteCalculateDrawProperties(root);
   EXPECT_EQ(gfx::Rect(0, 5, 25, 25), scroll_child->visible_layer_rect());
 }
 
 static void CopyOutputCallback(std::unique_ptr<CopyOutputResult> result) {}
 
-TEST_F(LayerTreeHostCommonTest, NumCopyRequestsInTargetSubtree) {
-  // If the layer has a node in effect_tree, the return value of
-  // num_copy_requests_in_target_subtree()  must be equal to the actual number
-  // of copy requests in the sub-layer_tree; Otherwise, the number is expected
-  // to be the value of its nearest ancestor that owns an effect node and
-  // greater than or equal to the actual number of copy requests in the
-  // sub-layer_tree.
-
+TEST_F(LayerTreeHostCommonTest, HasCopyRequestsInTargetSubtree) {
   scoped_refptr<Layer> root = Layer::Create();
   scoped_refptr<Layer> child1 = Layer::Create();
   scoped_refptr<Layer> child2 = Layer::Create();
   scoped_refptr<Layer> grandchild = Layer::Create();
   scoped_refptr<Layer> greatgrandchild = Layer::Create();
 
   root->AddChild(child1);
   root->AddChild(child2);
   child1->AddChild(grandchild);
   grandchild->AddChild(greatgrandchild);
   host()->SetRootLayer(root);
 
   child1->RequestCopyOfOutput(
       CopyOutputRequest::CreateBitmapRequest(base::Bind(&CopyOutputCallback)));
   greatgrandchild->RequestCopyOfOutput(
       CopyOutputRequest::CreateBitmapRequest(base::Bind(&CopyOutputCallback)));
   child2->SetOpacity(0.f);
   ExecuteCalculateDrawPropertiesAndSaveUpdateLayerList(root.get());
 
-  EXPECT_EQ(root->num_copy_requests_in_target_subtree(), 2);
-  EXPECT_EQ(child1->num_copy_requests_in_target_subtree(), 2);
-  EXPECT_EQ(child2->num_copy_requests_in_target_subtree(), 0);
-  EXPECT_EQ(grandchild->num_copy_requests_in_target_subtree(), 2);
-  EXPECT_EQ(greatgrandchild->num_copy_requests_in_target_subtree(), 1);
+  EXPECT_TRUE(root->has_copy_requests_in_target_subtree());
+  EXPECT_TRUE(child1->has_copy_requests_in_target_subtree());
+  EXPECT_FALSE(child2->has_copy_requests_in_target_subtree());
+  EXPECT_TRUE(grandchild->has_copy_requests_in_target_subtree());
+  EXPECT_TRUE(greatgrandchild->has_copy_requests_in_target_subtree());
 }
 
 TEST_F(LayerTreeHostCommonTest, SkippingSubtreeMain) {
   scoped_refptr<Layer> root = Layer::Create();
   FakeContentLayerClient client;
   client.set_bounds(root->bounds());
   scoped_refptr<LayerWithForcedDrawsContent> child =
       make_scoped_refptr(new LayerWithForcedDrawsContent());
   scoped_refptr<LayerWithForcedDrawsContent> grandchild =
       make_scoped_refptr(new LayerWithForcedDrawsContent());
@@ skipping 385 matching lines @@
   child->SetClipParent(root.get());
 
   root->AddChild(parent);
   parent->AddChild(child);
   host()->SetRootLayer(root);
 
   child->RequestCopyOfOutput(
       CopyOutputRequest::CreateRequest(base::Bind(&EmptyCopyOutputCallback)));
 
   ExecuteCalculateDrawPropertiesAndSaveUpdateLayerList(root.get());
-  EXPECT_GT(root->num_copy_requests_in_target_subtree(), 0);
+  EXPECT_TRUE(root->has_copy_requests_in_target_subtree());
 
   ExecuteCalculateDrawPropertiesAndSaveUpdateLayerList(root.get());
-  EXPECT_GT(root->num_copy_requests_in_target_subtree(), 0);
+  EXPECT_TRUE(root->has_copy_requests_in_target_subtree());
 }
 
 TEST_F(LayerTreeHostCommonTest, ResetPropertyTreeIndices) {
   scoped_refptr<Layer> root = Layer::Create();
   root->SetBounds(gfx::Size(800, 800));
 
   gfx::Transform translate_z;
   translate_z.Translate3d(0, 0, 10);
 
   scoped_refptr<Layer> child = Layer::Create();
@@ skipping 1069 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