cc: Add a flag to layers that returns true if the layer is in RSLL.

cc/trees/layer_tree_host_common_unittest.cc

Index: cc/trees/layer_tree_host_common_unittest.cc
diff --git a/cc/trees/layer_tree_host_common_unittest.cc b/cc/trees/layer_tree_host_common_unittest.cc
index ad4f60bb5a62c9b88922d7fc2870856d80b6d0aa..393ec2862396b2e3c9f61fbecabed70f0ba9bbbf 100644
--- a/cc/trees/layer_tree_host_common_unittest.cc
+++ b/cc/trees/layer_tree_host_common_unittest.cc
@@ -15,6 +15,7 @@
 #include "cc/layers/layer.h"
 #include "cc/layers/layer_client.h"
 #include "cc/layers/layer_impl.h"
+#include "cc/layers/layer_iterator.h"
 #include "cc/layers/render_surface.h"
 #include "cc/layers/render_surface_impl.h"
 #include "cc/output/copy_output_request.h"
@@ -38,6 +39,8 @@ namespace {
 
 class LayerTreeHostCommonTestBase {
  protected:
+  LayerTreeHostCommonTestBase() : render_surface_layer_list_count_(0) {}
+
   template <typename LayerType>
   void SetLayerPropertiesForTestingInternal(
       LayerType* layer,
@@ -120,21 +123,29 @@ class LayerTreeHostCommonTestBase {
                                       LayerImpl* page_scale_application_layer,
                                       bool can_use_lcd_text) {
     gfx::Transform identity_matrix;
-    LayerImplList dummy_render_surface_layer_list;
     gfx::Size device_viewport_size =
         gfx::Size(root_layer->bounds().width() * device_scale_factor,
                   root_layer->bounds().height() * device_scale_factor);
 
+    render_surface_layer_list_impl_.reset(new LayerImplList);
+
     // We are probably not testing what is intended if the root_layer bounds are
     // empty.
     DCHECK(!root_layer->bounds().IsEmpty());
     LayerTreeHostCommon::CalcDrawPropsImplInputsForTesting inputs(
-        root_layer, device_viewport_size, &dummy_render_surface_layer_list);
+        root_layer,
+        device_viewport_size,
+        render_surface_layer_list_impl_.get());
     inputs.device_scale_factor = device_scale_factor;
     inputs.page_scale_factor = page_scale_factor;
     inputs.page_scale_application_layer = page_scale_application_layer;
     inputs.can_use_lcd_text = can_use_lcd_text;
     inputs.can_adjust_raster_scales = true;
+
+    ++render_surface_layer_list_count_;
+    inputs.current_render_surface_layer_list_id =
+        render_surface_layer_list_count_;
+
     LayerTreeHostCommon::CalculateDrawProperties(&inputs);
   }
 
@@ -172,8 +183,19 @@ class LayerTreeHostCommonTestBase {
     return render_surface_layer_list_.get();
   }
 
+  LayerImplList* render_surface_layer_list_impl() const {
+    return render_surface_layer_list_impl_.get();
+  }
+
+  int render_surface_layer_list_count() const {
+    return render_surface_layer_list_count_;
+  }
+
  private:
   scoped_ptr<RenderSurfaceLayerList> render_surface_layer_list_;
+  scoped_ptr<LayerImplList> render_surface_layer_list_impl_;
+
+  int render_surface_layer_list_count_;
 };
 
 class LayerTreeHostCommonTest : public LayerTreeHostCommonTestBase,
@@ -10122,5 +10144,217 @@ TEST_F(LayerTreeHostCommonTest, MaximumAnimationScaleFactor) {
   EXPECT_EQ(0.f, grand_child_raw->last_maximum_animation_contents_scale());
 }
 
+static int membership_id(LayerImpl* layer) {
+  return layer->draw_properties().last_drawn_render_surface_layer_list_id;
+}
+
+static void gather_drawn_layers(LayerImplList* rsll,
+                                std::set<LayerImpl*>* drawn_layers) {
+  for (LayerIterator<LayerImpl> it = LayerIterator<LayerImpl>::Begin(rsll),
+                                end = LayerIterator<LayerImpl>::End(rsll);
+       it != end;
+       ++it) {
+    LayerImpl* layer = *it;
+    if (it.represents_itself())
+      drawn_layers->insert(layer);
+
+    if (!it.represents_contributing_render_surface())
+      continue;
+
+    if (layer->mask_layer())
+      drawn_layers->insert(layer->mask_layer());
+    if (layer->replica_layer() && layer->replica_layer()->mask_layer())
+      drawn_layers->insert(layer->replica_layer()->mask_layer());
+  }
+}
+
+TEST_F(LayerTreeHostCommonTest, RenderSurfaceLayerListMembership) {
+  FakeImplProxy proxy;
+  TestSharedBitmapManager shared_bitmap_manager;
+  FakeLayerTreeHostImpl host_impl(&proxy, &shared_bitmap_manager);
+  gfx::Transform identity_matrix;
+
+  scoped_ptr<LayerImpl> grand_parent =
+      LayerImpl::Create(host_impl.active_tree(), 1);
+  scoped_ptr<LayerImpl> parent = LayerImpl::Create(host_impl.active_tree(), 3);
+  scoped_ptr<LayerImpl> child = LayerImpl::Create(host_impl.active_tree(), 5);
+  scoped_ptr<LayerImpl> grand_child1 =
+      LayerImpl::Create(host_impl.active_tree(), 7);
+  scoped_ptr<LayerImpl> grand_child2 =
+      LayerImpl::Create(host_impl.active_tree(), 9);
+
+  LayerImpl* grand_parent_raw = grand_parent.get();
+  LayerImpl* parent_raw = parent.get();
+  LayerImpl* child_raw = child.get();
+  LayerImpl* grand_child1_raw = grand_child1.get();
+  LayerImpl* grand_child2_raw = grand_child2.get();
+
+  child->AddChild(grand_child1.Pass());
+  child->AddChild(grand_child2.Pass());
+  parent->AddChild(child.Pass());
+  grand_parent->AddChild(parent.Pass());
+
+  SetLayerPropertiesForTesting(grand_parent_raw,
+                               identity_matrix,
+                               gfx::PointF(),
+                               gfx::PointF(),
+                               gfx::Size(1, 2),
+                               true,
+                               false);
+  SetLayerPropertiesForTesting(parent_raw,
+                               identity_matrix,
+                               gfx::PointF(),
+                               gfx::PointF(),
+                               gfx::Size(1, 2),
+                               true,
+                               false);
+  SetLayerPropertiesForTesting(child_raw,
+                               identity_matrix,
+                               gfx::PointF(),
+                               gfx::PointF(),
+                               gfx::Size(1, 2),
+                               true,
+                               false);
+  SetLayerPropertiesForTesting(grand_child1_raw,
+                               identity_matrix,
+                               gfx::PointF(),
+                               gfx::PointF(),
+                               gfx::Size(1, 2),
+                               true,
+                               false);
+  SetLayerPropertiesForTesting(grand_child2_raw,
+                               identity_matrix,
+                               gfx::PointF(),
+                               gfx::PointF(),
+                               gfx::Size(1, 2),
+                               true,
+                               false);
+
+  // Start with nothing being drawn.
+  ExecuteCalculateDrawProperties(grand_parent_raw);
+  int 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));
+
+  std::set<LayerImpl*> expected;
+  std::set<LayerImpl*> actual;
+  gather_drawn_layers(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);
+
+  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));
+
+  expected.clear();
+  actual.clear();
+  gather_drawn_layers(render_surface_layer_list_impl(), &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);
+  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_EQ(member_id, membership_id(grand_child1_raw));
+  EXPECT_NE(member_id, membership_id(grand_child2_raw));
+
+  expected.clear();
+  expected.insert(grand_child1_raw);
+
+  actual.clear();
+  gather_drawn_layers(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_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));
+
+  expected.clear();
+  expected.insert(grand_child2_raw);
+
+  actual.clear();
+  gather_drawn_layers(render_surface_layer_list_impl(), &actual);
+  EXPECT_EQ(expected, actual);
+
+  // Add a mask layer to child.
+  child_raw->SetMaskLayer(LayerImpl::Create(host_impl.active_tree(), 6).Pass());
+
+  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_EQ(member_id, membership_id(child_raw->mask_layer()));
+  EXPECT_NE(member_id, membership_id(grand_child1_raw));
+  EXPECT_EQ(member_id, membership_id(grand_child2_raw));
+
+  expected.clear();
+  expected.insert(grand_child2_raw);
+  expected.insert(child_raw->mask_layer());
+
+  actual.clear();
+  gather_drawn_layers(render_surface_layer_list_impl(), &actual);
+  EXPECT_EQ(expected, actual);
+
+  child_raw->TakeMaskLayer();
+
+  // 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);
+  member_id = render_surface_layer_list_count();
+
+  EXPECT_EQ(member_id, membership_id(grand_parent_raw));
+  EXPECT_EQ(member_id, membership_id(parent_raw));
+  EXPECT_EQ(member_id, membership_id(child_raw));
+  EXPECT_EQ(member_id, membership_id(grand_child1_raw));
+  EXPECT_EQ(member_id, membership_id(grand_child2_raw));
+
+  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();
+  gather_drawn_layers(render_surface_layer_list_impl(), &actual);
+  EXPECT_EQ(expected, actual);
+}
 }  // namespace
 }  // namespace cc