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..7da9222d44334ab867e6c7be3b1493f822d60963 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() : calculate_draw_properties_count_(0) {}
+
   template <typename LayerType>
   void SetLayerPropertiesForTestingInternal(
       LayerType* layer,
@@ -120,21 +123,33 @@ 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;
+
+    if (calculate_draw_properties_count_ == std::numeric_limits<int>::max())
+      calculate_draw_properties_count_ = 1;
+    else
+      ++calculate_draw_properties_count_;
+
+    inputs.current_calculate_draw_properties_id =
+        calculate_draw_properties_count_;
+
     LayerTreeHostCommon::CalculateDrawProperties(&inputs);
   }
 
@@ -172,8 +187,19 @@ class LayerTreeHostCommonTestBase {
     return render_surface_layer_list_.get();
   }
 
+  LayerImplList* render_surface_layer_list_impl() const {
+    return render_surface_layer_list_impl_.get();
+  }
+
+  int calculate_draw_properties_count() const {
+    return calculate_draw_properties_count_;
+  }
+
  private:
   scoped_ptr<RenderSurfaceLayerList> render_surface_layer_list_;
+  scoped_ptr<LayerImplList> render_surface_layer_list_impl_;
+
+  int calculate_draw_properties_count_;
 };
 
 class LayerTreeHostCommonTest : public LayerTreeHostCommonTestBase,
@@ -10122,5 +10148,200 @@ 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_valid_render_surface_list_id;
+}
+
+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(), 2);
+  scoped_ptr<LayerImpl> child = LayerImpl::Create(host_impl.active_tree(), 3);
+  scoped_ptr<LayerImpl> grand_child1 =
+      LayerImpl::Create(host_impl.active_tree(), 4);
+  scoped_ptr<LayerImpl> grand_child2 =
+      LayerImpl::Create(host_impl.active_tree(), 5);
+
+  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);
+
+  ExecuteCalculateDrawProperties(grand_parent_raw);
+  int member_id = calculate_draw_properties_count();
+
+  EXPECT_EQ(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));
+
+  typedef LayerIterator<LayerImpl> LayerIteratorType;
+  LayerIteratorType end =
+      LayerIteratorType::End(render_surface_layer_list_impl());
+  LayerIteratorType it =
+      LayerIteratorType::Begin(render_surface_layer_list_impl());
+  EXPECT_NE(end, it);
+  EXPECT_EQ(grand_parent_raw, *it);
+  ++it;
+  EXPECT_EQ(end, it);
+
+  // 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 = calculate_draw_properties_count();
+
+  EXPECT_EQ(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));
+
+  end = LayerIteratorType::End(render_surface_layer_list_impl());
+  it = LayerIteratorType::Begin(render_surface_layer_list_impl());
+  EXPECT_NE(end, it);
+  EXPECT_EQ(grand_parent_raw, *it);
+  ++it;
+  EXPECT_EQ(end, it);
+
+  // 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 = calculate_draw_properties_count();
+
+  EXPECT_EQ(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));
+
+  std::set<LayerImpl*> expected;

[danakj, 2014/05/06 19:21:31]

If it's easier you could just compare the pointers in the rsll to the layer
pointers (they have a deterministic order)

[vmpstr, 2014/05/06 20:52:14]

I'd rather leave it like this, tbh. This test isn't really testing the order of
elements, so if those happen to change for whatever reason, this test should
still pass.

+  expected.insert(grand_parent_raw);
+  expected.insert(grand_child1_raw);
+
+  std::set<LayerImpl*> actual;
+  for (it = LayerIteratorType::Begin(render_surface_layer_list_impl()),
+      end = LayerIteratorType::End(render_surface_layer_list_impl());
+       it != end;
+       ++it) {
+    actual.insert(*it);
+  }
+
+  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 = calculate_draw_properties_count();
+
+  EXPECT_EQ(member_id, membership_id(grand_parent_raw));
+  EXPECT_NE(member_id, membership_id(parent_raw));
+  EXPECT_EQ(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_parent_raw);
+  expected.insert(child_raw);
+  expected.insert(grand_child2_raw);
+
+  actual.clear();
+  for (it = LayerIteratorType::Begin(render_surface_layer_list_impl()),
+      end = LayerIteratorType::End(render_surface_layer_list_impl());
+       it != end;
+       ++it) {
+    actual.insert(*it);
+  }
+
+  EXPECT_EQ(expected, actual);
+
+  // 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 = calculate_draw_properties_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();
+  for (it = LayerIteratorType::Begin(render_surface_layer_list_impl()),
+      end = LayerIteratorType::End(render_surface_layer_list_impl());
+       it != end;
+       ++it) {
+    actual.insert(*it);
+  }
+
+  EXPECT_EQ(expected, actual);
+}

[danakj, 2014/05/06 19:21:31]

Cool! I think that this test covers us calling RemoveSurfaceForEarlyExit(), can
you confirm?

[vmpstr, 2014/05/06 20:52:14]

Yes, there's a case where that's called (I know because I had a bug where I
didn't mark the layer itself as not a member, instead of just marking the render
surface's layer list)

 }  // namespace
 }  // namespace cc