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

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 <set>
 
 #include "cc/animation/layer_animation_controller.h"
 #include "cc/animation/transform_operations.h"
 #include "cc/base/math_util.h"
 #include "cc/layers/content_layer.h"
 #include "cc/layers/content_layer_client.h"
 #include "cc/layers/heads_up_display_layer_impl.h"
 #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"
 #include "cc/output/copy_output_result.h"
 #include "cc/test/animation_test_common.h"
 #include "cc/test/fake_impl_proxy.h"
 #include "cc/test/fake_layer_tree_host.h"
 #include "cc/test/fake_layer_tree_host_impl.h"
 #include "cc/test/geometry_test_utils.h"
 #include "cc/trees/layer_tree_impl.h"
 #include "cc/trees/proxy.h"
 #include "cc/trees/single_thread_proxy.h"
 #include "testing/gmock/include/gmock/gmock.h"
 #include "testing/gtest/include/gtest/gtest.h"
 #include "ui/gfx/quad_f.h"
 #include "ui/gfx/size_conversions.h"
 #include "ui/gfx/transform.h"
 
 namespace cc {
 namespace {
 
 class LayerTreeHostCommonTestBase {
  protected:
+  LayerTreeHostCommonTestBase() : calculate_draw_properties_count_(0) {}
+
   template <typename LayerType>
   void SetLayerPropertiesForTestingInternal(
       LayerType* layer,
       const gfx::Transform& transform,
       const gfx::PointF& anchor,
       const gfx::PointF& position,
       const gfx::Size& bounds,
       bool flatten_transform,
       bool is_3d_sorted) {
     layer->SetTransform(transform);
@@ skipping 62 matching lines @@
     inputs.can_adjust_raster_scales = true;
     LayerTreeHostCommon::CalculateDrawProperties(&inputs);
   }
 
   void ExecuteCalculateDrawProperties(LayerImpl* root_layer,
                                       float device_scale_factor,
                                       float page_scale_factor,
                                       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);
   }
 
   template <class LayerType>
   void ExecuteCalculateDrawProperties(LayerType* root_layer) {
     LayerType* page_scale_application_layer = NULL;
     ExecuteCalculateDrawProperties(
         root_layer, 1.f, 1.f, page_scale_application_layer, false);
   }
 
@@ skipping 17 matching lines @@
                                    device_scale_factor,
                                    page_scale_factor,
                                    page_scale_application_layer,
                                    false);
   }
 
   RenderSurfaceLayerList* render_surface_layer_list() const {
     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,
                                 public testing::Test {
 };
 
 class LayerWithForcedDrawsContent : public Layer {
  public:
   LayerWithForcedDrawsContent() : Layer(), last_device_scale_factor_(0.f) {}
 
@@ skipping 9928 matching lines @@
 
   ExecuteCalculateDrawProperties(grand_parent.get());
 
   // |grand_parent| has a transform that's neither a translation nor a scale.
   EXPECT_EQ(0.f, grand_parent->last_maximum_animation_contents_scale());
   EXPECT_EQ(0.f, parent_raw->last_maximum_animation_contents_scale());
   EXPECT_EQ(0.f, child_raw->last_maximum_animation_contents_scale());
   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