cc: layer_or_descendant_has_copy_request is inherited by siblings.

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 "cc/animation/layer_animation_controller.h"
 #include "cc/base/math_util.h"
 #include "cc/layers/content_layer.h"
 #include "cc/layers/content_layer_client.h"
@@ skipping 8187 matching lines @@
   scoped_refptr<Layer> copy_child = Layer::Create();
   SetLayerPropertiesForTesting(copy_child.get(),
                                identity_matrix,
                                identity_matrix,
                                gfx::PointF(),
                                gfx::PointF(),
                                gfx::Size(20, 20),
                                false);
   copy_child->SetIsDrawable(true);
 
+  scoped_refptr<Layer> copy_grand_parent_sibling_before = Layer::Create();
+  SetLayerPropertiesForTesting(copy_grand_parent_sibling_before.get(),
+                               identity_matrix,
+                               identity_matrix,
+                               gfx::PointF(),
+                               gfx::PointF(),
+                               gfx::Size(40, 40),
+                               false);
+  copy_grand_parent_sibling_before->SetIsDrawable(true);
+
+  scoped_refptr<Layer> copy_grand_parent_sibling_after = Layer::Create();
+  SetLayerPropertiesForTesting(copy_grand_parent_sibling_after.get(),
+                               identity_matrix,
+                               identity_matrix,
+                               gfx::PointF(),
+                               gfx::PointF(),
+                               gfx::Size(40, 40),
+                               false);
+  copy_grand_parent_sibling_after->SetIsDrawable(true);
+
   copy_layer->AddChild(copy_child);
   copy_parent->AddChild(copy_layer);
   copy_grand_parent->AddChild(copy_parent);
+  root->AddChild(copy_grand_parent_sibling_before);
   root->AddChild(copy_grand_parent);
+  root->AddChild(copy_grand_parent_sibling_after);
 
   // Hide the copy_grand_parent and its subtree. But make a copy request in that
   // hidden subtree on copy_layer.
   copy_grand_parent->SetHideLayerAndSubtree(true);
+  copy_grand_parent_sibling_before->SetHideLayerAndSubtree(true);
+  copy_grand_parent_sibling_after->SetHideLayerAndSubtree(true);
   copy_layer->RequestCopyOfOutput(CopyOutputRequest::CreateRequest(
       base::Bind(&EmptyCopyOutputCallback)));
   EXPECT_TRUE(copy_layer->HasCopyRequest());
 
   LayerList render_surface_layer_list;
   int dummy_max_texture_size = 512;
   LayerTreeHostCommon::CalculateDrawProperties(root.get(),
                                                root->bounds(),
                                                gfx::Transform(),
                                                1.f,
                                                1.f,
                                                NULL,
                                                dummy_max_texture_size,
                                                false,
                                                true,  // can_adjust_raster_scale
                                                &render_surface_layer_list);
 
+  EXPECT_TRUE(root->draw_properties().layer_or_descendant_has_copy_request);
+  EXPECT_TRUE(copy_grand_parent->draw_properties().
+              layer_or_descendant_has_copy_request);
+  EXPECT_TRUE(copy_parent->draw_properties().
+              layer_or_descendant_has_copy_request);
+  EXPECT_TRUE(copy_layer->draw_properties().
+              layer_or_descendant_has_copy_request);
+  EXPECT_FALSE(copy_child->draw_properties().
+               layer_or_descendant_has_copy_request);
+  EXPECT_FALSE(copy_grand_parent_sibling_before->draw_properties().
+               layer_or_descendant_has_copy_request);
+  EXPECT_FALSE(copy_grand_parent_sibling_after->draw_properties().
+               layer_or_descendant_has_copy_request);
+
   // We should have three render surfaces, one for the root, one for the parent
   // since it owns a surface, and one for the copy_layer.
   ASSERT_EQ(3u, render_surface_layer_list.size());
   EXPECT_EQ(root->id(), render_surface_layer_list[0]->id());
   EXPECT_EQ(copy_parent->id(), render_surface_layer_list[1]->id());
   EXPECT_EQ(copy_layer->id(), render_surface_layer_list[2]->id());
 
   // The root render surface should have 2 contributing layers. The
-  // copy_grand_parent is hidden, but the copy_parent will appear since
-  // something in its subtree needs to be drawn for a copy request.
+  // copy_grand_parent is hidden along with its siblings, but the copy_parent
+  // will appear since something in its subtree needs to be drawn for a copy
+  // request.
   ASSERT_EQ(2u, root->render_surface()->layer_list().size());
   EXPECT_EQ(root->id(), root->render_surface()->layer_list()[0]->id());
   EXPECT_EQ(copy_parent->id(), root->render_surface()->layer_list()[1]->id());
 
   // Nothing actually drawns 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(1u, copy_parent->render_surface()->layer_list().size());
   EXPECT_EQ(copy_layer->id(),
             copy_parent->render_surface()->layer_list()[0]->id());
 
@@ skipping 78 matching lines @@
   EXPECT_EQ(root->id(), render_surface_layer_list[0]->id());
 
   // The root render surface should only have 1 contributing layer, since the
   // other layers are empty/clipped away.
   ASSERT_EQ(1u, root->render_surface()->layer_list().size());
   EXPECT_EQ(root->id(), root->render_surface()->layer_list()[0]->id());
 }
 
 }  // namespace
 }  // namespace cc