cc: Make DamageTracker use the effect tree and layer list

cc/trees/damage_tracker_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/damage_tracker.h"
 
 #include <stddef.h>
 
 #include "cc/base/filter_operation.h"
 #include "cc/base/filter_operations.h"
@@ skipping 39 matching lines @@
   // This emulates only steps that are relevant to testing the damage tracker:
   //   1. computing the render passes and layerlists
   //   2. updating all damage trackers in the correct order
   //   3. resetting all update_rects and property_changed flags for all layers
   //      and surfaces.
 
   LayerImplList render_surface_layer_list;
   ExecuteCalculateDrawProperties(root, device_scale_factor,
                                  &render_surface_layer_list);
 
-  // Iterate back-to-front, so that damage correctly propagates from descendant
-  // surfaces to ancestors.
-  size_t render_surface_layer_list_size = render_surface_layer_list.size();
-  for (size_t i = 0; i < render_surface_layer_list_size; ++i) {
-    size_t index = render_surface_layer_list_size - 1 - i;
-    RenderSurfaceImpl* target_surface =
-        render_surface_layer_list[index]->GetRenderSurface();
-    target_surface->damage_tracker()->UpdateDamageTrackingState(
-        target_surface->layer_list(), target_surface,
-        target_surface->SurfacePropertyChangedOnlyFromDescendant(),
-        target_surface->content_rect(), target_surface->MaskLayer(),
-        target_surface->Filters());
-  }
+  DamageTracker::UpdateDamageTracking(root->layer_tree_impl(),
+                                      render_surface_layer_list);
 
   root->layer_tree_impl()->ResetAllChangeTracking();
 }
 
 class DamageTrackerTest : public testing::Test {
  public:
   DamageTrackerTest()
       : host_impl_(&task_runner_provider_, &task_graph_runner_) {}
 
   LayerImpl* CreateTestTreeWithOneSurface(int number_of_children) {
@@ skipping 1254 matching lines @@
   ClearDamageForAllSurfaces(root);
   root->GetRenderSurface()->damage_tracker()->AddDamageNextUpdate(
       gfx::Rect(30, 31, 14, 15));
   root->layer_tree_impl()->property_trees()->needs_rebuild = true;
   EmulateDrawingOneFrame(root);
   EXPECT_TRUE(root->GetRenderSurface()->damage_tracker()->GetDamageRectIfValid(
       &root_damage_rect));
   EXPECT_EQ(gfx::Rect(30, 31, 14, 15).ToString(), root_damage_rect.ToString());
 }
 
-TEST_F(DamageTrackerTest, VerifyDamageForEmptyLayerList) {
-  // Though it should never happen, its a good idea to verify that the damage
-  // tracker does not crash when it receives an empty layer_list.
-
+TEST_F(DamageTrackerTest, VerifyDamageWithNoContributingLayers) {
   std::unique_ptr<LayerImpl> root =
       LayerImpl::Create(host_impl_.active_tree(), 1);
   root->test_properties()->force_render_surface = true;
   host_impl_.active_tree()->SetRootLayerForTesting(std::move(root));
   LayerImpl* root_ptr = host_impl_.active_tree()->root_layer_for_testing();
   root_ptr->layer_tree_impl()->property_trees()->needs_rebuild = true;
   EmulateDrawingOneFrame(root_ptr);
 
   DCHECK_EQ(root_ptr->GetRenderSurface(), root_ptr->render_target());
   RenderSurfaceImpl* target_surface = root_ptr->GetRenderSurface();
-
-  LayerImplList empty_list;
-  target_surface->damage_tracker()->UpdateDamageTrackingState(
-      empty_list, target_surface, false, gfx::Rect(), NULL, FilterOperations());
-
   gfx::Rect damage_rect;
   EXPECT_TRUE(
       target_surface->damage_tracker()->GetDamageRectIfValid(&damage_rect));
   EXPECT_TRUE(damage_rect.IsEmpty());
 }
 
 TEST_F(DamageTrackerTest, VerifyDamageAccumulatesUntilReset) {
   // If damage is not cleared, it should accumulate.
 
   LayerImpl* root = CreateAndSetUpTestTreeWithOneSurface();
@@ skipping 147 matching lines @@
   grandchild2->SetPosition(
       gfx::PointF(std::numeric_limits<int>::max() - 500, 0));
   grandchild2->SetBounds(gfx::Size(1, 1));
   grandchild2->SetDrawsContent(true);
 
   root->layer_tree_impl()->property_trees()->needs_rebuild = true;
   float device_scale_factor = 1.f;
   LayerImplList render_surface_layer_list;
   ExecuteCalculateDrawProperties(root, device_scale_factor,
                                  &render_surface_layer_list);
-
-  auto* surface = child1->GetRenderSurface();
-  surface->damage_tracker()->UpdateDamageTrackingState(
-      surface->layer_list(), surface, false, surface->content_rect(),
-      surface->MaskLayer(), surface->Filters());
-  surface = root->GetRenderSurface();
-  surface->damage_tracker()->UpdateDamageTrackingState(
-      surface->layer_list(), surface, false, surface->content_rect(),
-      surface->MaskLayer(), surface->Filters());
+  // Avoid the descendant-only property change path that skips unioning damage
+  // from descendant layers.
+  child1->GetRenderSurface()->NoteAncestorPropertyChanged();
+  DamageTracker::UpdateDamageTracking(host_impl_.active_tree(),
+                                      render_surface_layer_list);
 
   // The expected damage would be too large to store in a gfx::Rect, so we
   // should damage everything on child1.
   gfx::Rect damage_rect;
   EXPECT_FALSE(
       child1->GetRenderSurface()->damage_tracker()->GetDamageRectIfValid(
           &damage_rect));
   EXPECT_EQ(child1->GetRenderSurface()->content_rect(),
             child1->GetRenderSurface()->GetDamageRect());
 
   // However, the root should just use the child1 render surface's content rect
   // as damage.
   ASSERT_TRUE(root->GetRenderSurface()->damage_tracker()->GetDamageRectIfValid(
       &damage_rect));
   EXPECT_TRUE(damage_rect.Contains(root->GetRenderSurface()->content_rect()));
   EXPECT_TRUE(damage_rect.Contains(
       gfx::ToEnclosingRect(child1->GetRenderSurface()->DrawableContentRect())));
   EXPECT_EQ(damage_rect, root->GetRenderSurface()->GetDamageRect());
 
   // Add new damage, without changing properties, which goes down a different
   // path in the damage tracker.
   root->layer_tree_impl()->ResetAllChangeTracking();
   grandchild1->AddDamageRect(gfx::Rect(grandchild1->bounds()));
   grandchild2->AddDamageRect(gfx::Rect(grandchild1->bounds()));
 
   // Recompute all damage / properties.
   render_surface_layer_list.clear();
   ExecuteCalculateDrawProperties(root, device_scale_factor,
                                  &render_surface_layer_list);
-  surface = child1->GetRenderSurface();
-  surface->damage_tracker()->UpdateDamageTrackingState(
-      surface->layer_list(), surface, false, surface->content_rect(),
-      surface->MaskLayer(), surface->Filters());
-  surface = root->GetRenderSurface();
-  surface->damage_tracker()->UpdateDamageTrackingState(
-      surface->layer_list(), surface, false, surface->content_rect(),
-      surface->MaskLayer(), surface->Filters());
+  DamageTracker::UpdateDamageTracking(host_impl_.active_tree(),
+                                      render_surface_layer_list);
 
   // Child1 should still not have a valid rect, since the union of the damage of
   // its children is not representable by a single rect.
   EXPECT_FALSE(
       child1->GetRenderSurface()->damage_tracker()->GetDamageRectIfValid(
           &damage_rect));
   EXPECT_EQ(child1->GetRenderSurface()->content_rect(),
             child1->GetRenderSurface()->GetDamageRect());
 
   // Root should have valid damage and contain both its content rect and the
@@ skipping 28 matching lines @@
   grandchild2->SetPosition(
       gfx::PointF(std::numeric_limits<int>::max() - 500, 0));
   grandchild2->SetBounds(gfx::Size(1, 1));
   grandchild2->SetDrawsContent(true);
 
   root->layer_tree_impl()->property_trees()->needs_rebuild = true;
   float device_scale_factor = 1.f;
   LayerImplList render_surface_layer_list;
   ExecuteCalculateDrawProperties(root, device_scale_factor,
                                  &render_surface_layer_list);
-
-  auto* surface = child1->GetRenderSurface();
-  surface->damage_tracker()->UpdateDamageTrackingState(
-      surface->layer_list(), surface, false, surface->content_rect(),
-      surface->MaskLayer(), surface->Filters());
-  surface = root->GetRenderSurface();
-  surface->damage_tracker()->UpdateDamageTrackingState(
-      surface->layer_list(), surface, false, surface->content_rect(),
-      surface->MaskLayer(), surface->Filters());
+  // Avoid the descendant-only property change path that skips unioning damage
+  // from descendant layers.
+  child1->GetRenderSurface()->NoteAncestorPropertyChanged();
+  DamageTracker::UpdateDamageTracking(host_impl_.active_tree(),
+                                      render_surface_layer_list);
 
   // The expected damage would be too large to store in a gfx::Rect, so we
   // should damage everything on child1.
   gfx::Rect damage_rect;
   EXPECT_FALSE(
       child1->GetRenderSurface()->damage_tracker()->GetDamageRectIfValid(
           &damage_rect));
   EXPECT_EQ(child1->GetRenderSurface()->content_rect(),
             child1->GetRenderSurface()->GetDamageRect());
 
   // However, the root should just use the child1 render surface's content rect
   // as damage.
   ASSERT_TRUE(root->GetRenderSurface()->damage_tracker()->GetDamageRectIfValid(
       &damage_rect));
   EXPECT_TRUE(damage_rect.Contains(root->GetRenderSurface()->content_rect()));
   EXPECT_TRUE(damage_rect.Contains(
       gfx::ToEnclosingRect(child1->GetRenderSurface()->DrawableContentRect())));
   EXPECT_EQ(damage_rect, root->GetRenderSurface()->GetDamageRect());
 
   // Add new damage, without changing properties, which goes down a different
   // path in the damage tracker.
   root->layer_tree_impl()->ResetAllChangeTracking();
   grandchild1->AddDamageRect(gfx::Rect(grandchild1->bounds()));
   grandchild2->AddDamageRect(gfx::Rect(grandchild1->bounds()));
 
   // Recompute all damage / properties.
   render_surface_layer_list.clear();
   ExecuteCalculateDrawProperties(root, device_scale_factor,
                                  &render_surface_layer_list);
-  surface = child1->GetRenderSurface();
-  surface->damage_tracker()->UpdateDamageTrackingState(
-      surface->layer_list(), surface, false, surface->content_rect(),
-      surface->MaskLayer(), surface->Filters());
-  surface = root->GetRenderSurface();
-  surface->damage_tracker()->UpdateDamageTrackingState(
-      surface->layer_list(), surface, false, surface->content_rect(),
-      surface->MaskLayer(), surface->Filters());
+  DamageTracker::UpdateDamageTracking(host_impl_.active_tree(),
+                                      render_surface_layer_list);
 
   // Child1 should still not have a valid rect, since the union of the damage of
   // its children is not representable by a single rect.
   EXPECT_FALSE(
       child1->GetRenderSurface()->damage_tracker()->GetDamageRectIfValid(
           &damage_rect));
   EXPECT_EQ(child1->GetRenderSurface()->content_rect(),
             child1->GetRenderSurface()->GetDamageRect());
 
   // Root should have valid damage and contain both its content rect and the
   // drawable content rect of child1.
   ASSERT_TRUE(root->GetRenderSurface()->damage_tracker()->GetDamageRectIfValid(
       &damage_rect));
   EXPECT_TRUE(damage_rect.Contains(root->GetRenderSurface()->content_rect()));
   EXPECT_TRUE(damage_rect.Contains(
       gfx::ToEnclosingRect(child1->GetRenderSurface()->DrawableContentRect())));
   EXPECT_EQ(damage_rect, root->GetRenderSurface()->GetDamageRect());
 }
 
 }  // namespace
 }  // namespace cc