cc: Replace LayerIterator with iterator that walks layer list and effect tree

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>
 #include <set>
 #include <vector>
 
 #include "base/memory/ptr_util.h"
 #include "cc/animation/animation_host.h"
 #include "cc/animation/animation_id_provider.h"
 #include "cc/animation/animation_player.h"
 #include "cc/animation/keyframed_animation_curve.h"
 #include "cc/animation/transform_operations.h"
 #include "cc/base/math_util.h"
 #include "cc/input/main_thread_scrolling_reason.h"
 #include "cc/layers/content_layer_client.h"
+#include "cc/layers/effect_tree_layer_list_iterator.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_impl.h"
 #include "cc/layers/texture_layer_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_compositor_frame_sink.h"
 #include "cc/test/fake_content_layer_client.h"
 #include "cc/test/fake_impl_task_runner_provider.h"
 #include "cc/test/fake_layer_tree_host.h"
 #include "cc/test/fake_layer_tree_host_impl.h"
@@ skipping 6096 matching lines @@
     LayerTreeHostCommon::CalcDrawPropsImplInputsForTesting inputs(
         root_layer, root_layer->bounds(), &render_surface_layer_list);
     inputs.can_render_to_separate_surface = true;
     LayerTreeHostCommon::CalculateDrawPropertiesForTesting(&inputs);
 
     EXPECT_EQ(2u, render_surface_layer_list.size());
 
     int count_represents_target_render_surface = 0;
     int count_represents_contributing_render_surface = 0;
     int count_represents_itself = 0;
-    LayerIterator end = LayerIterator::End(&render_surface_layer_list);
-    for (LayerIterator it = LayerIterator::Begin(&render_surface_layer_list);
-         it != end; ++it) {
-      if (it.represents_target_render_surface())
+    for (EffectTreeLayerListIterator it(host_impl.active_tree());
+         it.state() != EffectTreeLayerListIterator::State::END; ++it) {
+      if (it.state() == EffectTreeLayerListIterator::State::TARGET_SURFACE) {
         count_represents_target_render_surface++;
-      if (it.represents_contributing_render_surface())
+      } else if (it.state() ==
+                 EffectTreeLayerListIterator::State::CONTRIBUTING_SURFACE) {
         count_represents_contributing_render_surface++;
-      if (it.represents_itself())
+      } else {
         count_represents_itself++;
+      }
     }
 
     // Two render surfaces.
     EXPECT_EQ(2, count_represents_target_render_surface);
     // Second render surface contributes to root render surface.
     EXPECT_EQ(1, count_represents_contributing_render_surface);
     // All 4 layers represent itself.
     EXPECT_EQ(4, count_represents_itself);
   }
 
   {
     LayerImplList render_surface_layer_list;
     LayerTreeHostCommon::CalcDrawPropsImplInputsForTesting inputs(
         root_layer, root_layer->bounds(), &render_surface_layer_list);
     inputs.can_render_to_separate_surface = false;
     LayerTreeHostCommon::CalculateDrawPropertiesForTesting(&inputs);
 
     EXPECT_EQ(1u, render_surface_layer_list.size());
 
     int count_represents_target_render_surface = 0;
     int count_represents_contributing_render_surface = 0;
     int count_represents_itself = 0;
-    LayerIterator end = LayerIterator::End(&render_surface_layer_list);
-    for (LayerIterator it = LayerIterator::Begin(&render_surface_layer_list);
-         it != end; ++it) {
-      if (it.represents_target_render_surface())
+    for (EffectTreeLayerListIterator it(host_impl.active_tree());
+         it.state() != EffectTreeLayerListIterator::State::END; ++it) {
+      if (it.state() == EffectTreeLayerListIterator::State::TARGET_SURFACE) {
         count_represents_target_render_surface++;
-      if (it.represents_contributing_render_surface())
+      } else if (it.state() ==
+                 EffectTreeLayerListIterator::State::CONTRIBUTING_SURFACE) {
         count_represents_contributing_render_surface++;
-      if (it.represents_itself())
+      } else {
         count_represents_itself++;
+      }
     }
 
     // Only root layer has a render surface.
     EXPECT_EQ(1, count_represents_target_render_surface);
     // No layer contributes a render surface to root render surface.
     EXPECT_EQ(0, count_represents_contributing_render_surface);
     // All 4 layers represent itself.
     EXPECT_EQ(4, count_represents_itself);
   }
 }
@@ skipping 2131 matching lines @@
   EXPECT_EQ(0.f, GetMaximumAnimationScale(parent_raw));
   EXPECT_EQ(0.f, GetMaximumAnimationScale(child_raw));
   EXPECT_EQ(0.f, GetMaximumAnimationScale(grand_child_raw));
 
   EXPECT_EQ(0.f, GetStartingAnimationScale(grand_parent_raw));
   EXPECT_EQ(0.f, GetStartingAnimationScale(parent_raw));
   EXPECT_EQ(0.f, GetStartingAnimationScale(child_raw));
   EXPECT_EQ(0.f, GetStartingAnimationScale(grand_child_raw));
 }
 
-static void GatherDrawnLayers(const LayerImplList* rsll,
+static void GatherDrawnLayers(LayerTreeImpl* tree_impl,
                               std::set<LayerImpl*>* drawn_layers) {
-  for (LayerIterator it = LayerIterator::Begin(rsll),
-                     end = LayerIterator::End(rsll);
-       it != end; ++it) {
-    LayerImpl* layer = *it;
-    if (it.represents_itself())
-      drawn_layers->insert(layer);
+  for (EffectTreeLayerListIterator it(tree_impl);
+       it.state() != EffectTreeLayerListIterator::State::END; ++it) {
+    if (it.state() == EffectTreeLayerListIterator::State::LAYER)
+      drawn_layers->insert(it.current_layer());
 
-    if (!it.represents_contributing_render_surface())
+    if (it.state() != EffectTreeLayerListIterator::State::CONTRIBUTING_SURFACE)
       continue;
 
-    if (layer->GetRenderSurface()->MaskLayer())
-      drawn_layers->insert(layer->GetRenderSurface()->MaskLayer());
+    if (it.current_render_surface()->MaskLayer())
+      drawn_layers->insert(it.current_render_surface()->MaskLayer());
   }
 }
 
 TEST_F(LayerTreeHostCommonTest, RenderSurfaceLayerListMembership) {
   FakeImplTaskRunnerProvider task_runner_provider;
   TestTaskGraphRunner task_graph_runner;
   FakeLayerTreeHostImpl host_impl(&task_runner_provider, &task_graph_runner);
 
   std::unique_ptr<LayerImpl> grand_parent =
       LayerImpl::Create(host_impl.active_tree(), 1);
@@ skipping 28 matching lines @@
   ExecuteCalculateDrawProperties(grand_parent_raw);
 
   EXPECT_FALSE(grand_parent_raw->is_drawn_render_surface_layer_list_member());
   EXPECT_FALSE(parent_raw->is_drawn_render_surface_layer_list_member());
   EXPECT_FALSE(child_raw->is_drawn_render_surface_layer_list_member());
   EXPECT_FALSE(grand_child1_raw->is_drawn_render_surface_layer_list_member());
   EXPECT_FALSE(grand_child2_raw->is_drawn_render_surface_layer_list_member());
 
   std::set<LayerImpl*> expected;
   std::set<LayerImpl*> actual;
-  GatherDrawnLayers(render_surface_layer_list_impl(), &actual);
+  GatherDrawnLayers(host_impl.active_tree(), &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->test_properties()->force_render_surface = true;
   grand_child1_raw->layer_tree_impl()->property_trees()->needs_rebuild = true;
 
   ExecuteCalculateDrawProperties(grand_parent_raw);
 
   EXPECT_FALSE(grand_parent_raw->is_drawn_render_surface_layer_list_member());
   EXPECT_FALSE(parent_raw->is_drawn_render_surface_layer_list_member());
   EXPECT_FALSE(child_raw->is_drawn_render_surface_layer_list_member());
   EXPECT_FALSE(grand_child1_raw->is_drawn_render_surface_layer_list_member());
   EXPECT_FALSE(grand_child2_raw->is_drawn_render_surface_layer_list_member());
 
   expected.clear();
   actual.clear();
-  GatherDrawnLayers(render_surface_layer_list_impl(), &actual);
+  GatherDrawnLayers(host_impl.active_tree(), &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);
 
   EXPECT_FALSE(grand_parent_raw->is_drawn_render_surface_layer_list_member());
   EXPECT_FALSE(parent_raw->is_drawn_render_surface_layer_list_member());
   EXPECT_FALSE(child_raw->is_drawn_render_surface_layer_list_member());
   EXPECT_TRUE(grand_child1_raw->is_drawn_render_surface_layer_list_member());
   EXPECT_FALSE(grand_child2_raw->is_drawn_render_surface_layer_list_member());
 
   expected.clear();
   expected.insert(grand_child1_raw);
 
   actual.clear();
-  GatherDrawnLayers(render_surface_layer_list_impl(), &actual);
+  GatherDrawnLayers(host_impl.active_tree(), &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->test_properties()->force_render_surface = false;
   grand_child1_raw->layer_tree_impl()->property_trees()->needs_rebuild = true;
   child_raw->test_properties()->force_render_surface = true;
   grand_child2_raw->SetDrawsContent(true);
 
   ExecuteCalculateDrawProperties(grand_parent_raw);
 
   EXPECT_FALSE(grand_parent_raw->is_drawn_render_surface_layer_list_member());
   EXPECT_FALSE(parent_raw->is_drawn_render_surface_layer_list_member());
   EXPECT_FALSE(child_raw->is_drawn_render_surface_layer_list_member());
   EXPECT_FALSE(grand_child1_raw->is_drawn_render_surface_layer_list_member());
   EXPECT_TRUE(grand_child2_raw->is_drawn_render_surface_layer_list_member());
 
   expected.clear();
   expected.insert(grand_child2_raw);
 
   actual.clear();
-  GatherDrawnLayers(render_surface_layer_list_impl(), &actual);
+  GatherDrawnLayers(host_impl.active_tree(), &actual);
   EXPECT_EQ(expected, actual);
 
   // Add a mask layer to child.
   child_raw->test_properties()->SetMaskLayer(
       LayerImpl::Create(host_impl.active_tree(), 6));
   child_raw->layer_tree_impl()->property_trees()->needs_rebuild = true;
 
   ExecuteCalculateDrawProperties(grand_parent_raw);
 
   EXPECT_FALSE(grand_parent_raw->is_drawn_render_surface_layer_list_member());
   EXPECT_FALSE(parent_raw->is_drawn_render_surface_layer_list_member());
   EXPECT_FALSE(child_raw->is_drawn_render_surface_layer_list_member());
   EXPECT_TRUE(child_raw->test_properties()
                   ->mask_layer->is_drawn_render_surface_layer_list_member());
   EXPECT_FALSE(grand_child1_raw->is_drawn_render_surface_layer_list_member());
   EXPECT_TRUE(grand_child2_raw->is_drawn_render_surface_layer_list_member());
 
   expected.clear();
   expected.insert(grand_child2_raw);
   expected.insert(child_raw->test_properties()->mask_layer);
 
   expected.clear();
   expected.insert(grand_child2_raw);
   expected.insert(child_raw->test_properties()->mask_layer);
 
   actual.clear();
-  GatherDrawnLayers(render_surface_layer_list_impl(), &actual);
+  GatherDrawnLayers(host_impl.active_tree(), &actual);
   EXPECT_EQ(expected, actual);
 
   ExecuteCalculateDrawProperties(grand_parent_raw);
 
   EXPECT_FALSE(grand_parent_raw->is_drawn_render_surface_layer_list_member());
   EXPECT_FALSE(parent_raw->is_drawn_render_surface_layer_list_member());
   EXPECT_FALSE(child_raw->is_drawn_render_surface_layer_list_member());
   EXPECT_TRUE(child_raw->test_properties()
                   ->mask_layer->is_drawn_render_surface_layer_list_member());
   EXPECT_FALSE(grand_child1_raw->is_drawn_render_surface_layer_list_member());
   EXPECT_TRUE(grand_child2_raw->is_drawn_render_surface_layer_list_member());
 
   expected.clear();
   expected.insert(grand_child2_raw);
   expected.insert(child_raw->test_properties()->mask_layer);
 
   actual.clear();
-  GatherDrawnLayers(render_surface_layer_list_impl(), &actual);
+  GatherDrawnLayers(host_impl.active_tree(), &actual);
   EXPECT_EQ(expected, actual);
 
   child_raw->layer_tree_impl()->property_trees()->needs_rebuild = true;
 
   // With nothing drawing, we should have no layers.
   grand_child2_raw->SetDrawsContent(false);
 
   ExecuteCalculateDrawProperties(grand_parent_raw);
 
   EXPECT_FALSE(grand_parent_raw->is_drawn_render_surface_layer_list_member());
   EXPECT_FALSE(parent_raw->is_drawn_render_surface_layer_list_member());
   EXPECT_FALSE(child_raw->is_drawn_render_surface_layer_list_member());
   EXPECT_FALSE(child_raw->test_properties()
                    ->mask_layer->is_drawn_render_surface_layer_list_member());
   EXPECT_FALSE(grand_child1_raw->is_drawn_render_surface_layer_list_member());
   EXPECT_FALSE(grand_child2_raw->is_drawn_render_surface_layer_list_member());
 
   expected.clear();
   actual.clear();
-  GatherDrawnLayers(render_surface_layer_list_impl(), &actual);
+  GatherDrawnLayers(host_impl.active_tree(), &actual);
   EXPECT_EQ(expected, actual);
 
   // Child itself draws means that we should have the child and the mask in the
   // list.
   child_raw->SetDrawsContent(true);
 
   ExecuteCalculateDrawProperties(grand_parent_raw);
 
   EXPECT_FALSE(grand_parent_raw->is_drawn_render_surface_layer_list_member());
   EXPECT_FALSE(parent_raw->is_drawn_render_surface_layer_list_member());
   EXPECT_TRUE(child_raw->is_drawn_render_surface_layer_list_member());
   EXPECT_TRUE(child_raw->test_properties()
                   ->mask_layer->is_drawn_render_surface_layer_list_member());
   EXPECT_FALSE(grand_child1_raw->is_drawn_render_surface_layer_list_member());
   EXPECT_FALSE(grand_child2_raw->is_drawn_render_surface_layer_list_member());
 
   expected.clear();
   expected.insert(child_raw);
   expected.insert(child_raw->test_properties()->mask_layer);
   actual.clear();
-  GatherDrawnLayers(render_surface_layer_list_impl(), &actual);
+  GatherDrawnLayers(host_impl.active_tree(), &actual);
   EXPECT_EQ(expected, actual);
 
   child_raw->test_properties()->SetMaskLayer(nullptr);
   child_raw->layer_tree_impl()->property_trees()->needs_rebuild = true;
 
   // 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);
 
   EXPECT_TRUE(grand_parent_raw->is_drawn_render_surface_layer_list_member());
   EXPECT_TRUE(parent_raw->is_drawn_render_surface_layer_list_member());
   EXPECT_TRUE(child_raw->is_drawn_render_surface_layer_list_member());
   EXPECT_TRUE(grand_child1_raw->is_drawn_render_surface_layer_list_member());
   EXPECT_TRUE(grand_child2_raw->is_drawn_render_surface_layer_list_member());
 
   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();
-  GatherDrawnLayers(render_surface_layer_list_impl(), &actual);
+  GatherDrawnLayers(host_impl.active_tree(), &actual);
   EXPECT_EQ(expected, actual);
 }
 
 TEST_F(LayerTreeHostCommonTest, DrawPropertyScales) {
   FakeImplTaskRunnerProvider task_runner_provider;
   TestTaskGraphRunner task_graph_runner;
   LayerTreeSettings settings = host()->GetSettings();
   settings.layer_transforms_should_scale_layer_contents = true;
   FakeLayerTreeHostImpl host_impl(settings, &task_runner_provider,
                                   &task_graph_runner);
@@ skipping 1666 matching lines @@
   LayerImpl* test = AddChild<LayerImpl>(hidden);
 
   root->SetBounds(gfx::Size(30, 30));
   hidden->SetBounds(gfx::Size(30, 30));
   hidden->test_properties()->force_render_surface = true;
   hidden->test_properties()->hide_layer_and_subtree = true;
   test->SetBounds(gfx::Size(30, 30));
   test->test_properties()->force_render_surface = true;
 
   ExecuteCalculateDrawProperties(root);
-  EXPECT_TRUE(test->IsHidden());
+  EXPECT_EQ(0.f,
+            test->GetRenderSurface()->OwningEffectNode()->screen_space_opacity);
 
   hidden->test_properties()->hide_layer_and_subtree = false;
   root->layer_tree_impl()->property_trees()->needs_rebuild = true;
   ExecuteCalculateDrawProperties(root);
-  EXPECT_FALSE(test->IsHidden());
+  EXPECT_EQ(1.f,
+            test->GetRenderSurface()->OwningEffectNode()->screen_space_opacity);
 }
 
 TEST_F(LayerTreeHostCommonTest, TwoUnclippedRenderSurfaces) {
   LayerImpl* root = root_layer_for_testing();
   LayerImpl* render_surface1 = AddChild<LayerImpl>(root);
   LayerImpl* render_surface2 = AddChild<LayerImpl>(render_surface1);
   LayerImpl* clip_child = AddChild<LayerImpl>(render_surface2);
 
   root->SetBounds(gfx::Size(30, 30));
   root->SetMasksToBounds(true);
@@ skipping 532 matching lines @@
   EXPECT_EQ(scroll_child6.id, grand_child10->scroll_tree_index());
   EXPECT_EQ(scroll_root1.id, parent3->scroll_tree_index());
   EXPECT_EQ(scroll_child7.id, child8->scroll_tree_index());
   EXPECT_EQ(scroll_root1.id, parent4->scroll_tree_index());
   EXPECT_EQ(scroll_root1.id, child9->scroll_tree_index());
   EXPECT_EQ(scroll_root1.id, grand_child12->scroll_tree_index());
 }
 
 }  // namespace
 }  // namespace cc