Rename |can_use_cached_backdrop_filtered_result_| to

|intersects_damage_under|.

The |can_use_cached_backdrop_filtered_result_| flag on a
|RenderSurfaceImpl| is set during damage tracking to mark if there's
any intersecting damage from layers or other render surfaces under this
|RenderSurfaceImpl| rendering to the same target.

Previously this flag was intended only for a render surface with a
backdrop filter to avoid recomputation of the backdrop filter, i.e. to
use cached result, if there was no intersecting damage from under it. As
this flag is already on |RenderSurfaceImpl|, we can use it for a more
general purpose optimization at a later stage (during surface
aggregation) in the pipeline if we set it appropriately for every render
surface, with or without a backdrop filter.

Bug: 1142892
Change-Id: Icc0e418bc4f7c09bb2825dc21fb1f8706ebcf64a
Reviewed-on: https://chromium-review.googlesource.com/c/chromium/src/+/2538957Reviewed-by: weiliangc <weiliangc@chromium.org>
Commit-Queue: Jun Liu <yjliu@chromium.org>
Cr-Commit-Position: refs/heads/master@{#827822}

cc/layers/render_surface_impl.cc

@@ -45,7 +45,7 @@ RenderSurfaceImpl::RenderSurfaceImpl(LayerTreeImpl* layer_tree_impl,
       ancestor_property_changed_(false),
       contributes_to_drawn_surface_(false),
       is_render_surface_list_member_(false),
-      can_use_cached_backdrop_filtered_result_(false),
+      intersects_damage_under_(false),
       nearest_occlusion_immune_ancestor_(nullptr) {
   damage_tracker_ = DamageTracker::Create();
 }
@@ -452,13 +452,12 @@ void RenderSurfaceImpl::AppendQuads(DrawMode draw_mode,
   gfx::RectF tex_coord_rect(gfx::Rect(content_rect().size()));
   auto* quad =
       render_pass->CreateAndAppendDrawQuad<viz::CompositorRenderPassDrawQuad>();
-  quad->SetAll(shared_quad_state, content_rect(), unoccluded_content_rect,
-               /*needs_blending=*/true, render_pass_id(), mask_resource_id,
-               mask_uv_rect, mask_texture_size, surface_contents_scale,
-               gfx::PointF(), tex_coord_rect,
+  quad->SetAll(
+      shared_quad_state, content_rect(), unoccluded_content_rect,
+      /*needs_blending=*/true, render_pass_id(), mask_resource_id, mask_uv_rect,
+      mask_texture_size, surface_contents_scale, gfx::PointF(), tex_coord_rect,
       !layer_tree_impl_->settings().enable_edge_anti_aliasing,
-               OwningEffectNode()->backdrop_filter_quality,
-               can_use_cached_backdrop_filtered_result_);
+      OwningEffectNode()->backdrop_filter_quality, intersects_damage_under_);
 }
 
 }  // namespace cc

cc/layers/render_surface_impl.h

@@ -122,14 +122,10 @@ class CC_EXPORT RenderSurfaceImpl {
     return is_render_surface_list_member_;
   }
 
-  void set_can_use_cached_backdrop_filtered_result(
-      bool can_use_cached_backdrop_filtered_result) {
-    can_use_cached_backdrop_filtered_result_ =
-        can_use_cached_backdrop_filtered_result;
-  }
-  bool can_use_cached_backdrop_filtered_result() const {
-    return can_use_cached_backdrop_filtered_result_;
+  void set_intersects_damage_under(bool intersects_damage_under) {
+    intersects_damage_under_ = intersects_damage_under;
   }
+  bool intersects_damage_under() const { return intersects_damage_under_; }
 
   void CalculateContentRectFromAccumulatedContentRect(int max_texture_size);
   void SetContentRectToViewport();
@@ -260,7 +256,7 @@ class CC_EXPORT RenderSurfaceImpl {
 
   bool contributes_to_drawn_surface_ : 1;
   bool is_render_surface_list_member_ : 1;
-  bool can_use_cached_backdrop_filtered_result_ : 1;
+  bool intersects_damage_under_ : 1;
 
   Occlusion occlusion_in_content_space_;
 

cc/trees/damage_tracker.cc

@@ -217,7 +217,7 @@ void DamageTracker::ComputeSurfaceDamage(
     while (it != surfaces_with_backdrop_blur_filter.end()) {
       RenderSurfaceImpl* surface = it->first;
       if (surface->render_target() == render_surface) {
-        surface->set_can_use_cached_backdrop_filtered_result(
+        surface->set_intersects_damage_under(
             !it->second.Intersects(leftover_damage_rect) && valid);
         it = surfaces_with_backdrop_blur_filter.erase(it);
       } else {
@@ -441,7 +441,7 @@ void DamageTracker::AccumulateDamageFromRenderSurface(
 
     // The surface's old region is now exposed on the target surface, too.
     damage_for_this_update_.Union(old_surface_rect);
-    render_surface->set_can_use_cached_backdrop_filtered_result(false);
+    render_surface->set_intersects_damage_under(false);
   } else {
     // Check if current accumulated damage intersects the render surface.
     gfx::Rect damage_on_target;
@@ -450,7 +450,7 @@ void DamageTracker::AccumulateDamageFromRenderSurface(
       surfaces_with_backdrop_blur_filter.emplace_back(
           std::make_pair(render_surface, surface_rect_in_target_space));
     } else {
-      render_surface->set_can_use_cached_backdrop_filtered_result(false);
+      render_surface->set_intersects_damage_under(false);
     }
     // Only the surface's damage_rect will damage the target surface.
     gfx::Rect damage_rect_in_local_space;

cc/trees/damage_tracker_unittest.cc

@@ -2054,27 +2054,23 @@ TEST_F(DamageTrackerTest, CanUseCachedBackdropFilterResultTest) {
   filters.Append(FilterOperation::CreateBlurFilter(2.f));
   SetBackdropFilter(child1_, filters);
   child1_->NoteLayerPropertyChanged();
-  // can_use_cached_backdrop_filtered_result_ is false by default.
-  EXPECT_FALSE(
-      GetRenderSurface(child1_)->can_use_cached_backdrop_filtered_result());
+  // intersects_damage_under_ is false by default.
+  EXPECT_FALSE(GetRenderSurface(child1_)->intersects_damage_under());
 
   EmulateDrawingOneFrame(root);
   // child1_'s render target has changed its surface property.
-  EXPECT_FALSE(
-      GetRenderSurface(child1_)->can_use_cached_backdrop_filtered_result());
+  EXPECT_FALSE(GetRenderSurface(child1_)->intersects_damage_under());
 
   // Let run for one update and there should be no damage left.
   EmulateDrawingOneFrame(root);
-  EXPECT_TRUE(
-      GetRenderSurface(child1_)->can_use_cached_backdrop_filtered_result());
+  EXPECT_TRUE(GetRenderSurface(child1_)->intersects_damage_under());
 
   // CASE 1.1: Setting a non-intersecting update rect on the root
   // doesn't invalidate child1_'s cached backdrop-filtered result.
   // Damage rect at 0,0 20x20 doesn't intersect 270,270 36x38.
   root->UnionUpdateRect(gfx::Rect(0, 0, 20, 20));
   EmulateDrawingOneFrame(root);
-  EXPECT_TRUE(
-      GetRenderSurface(child1_)->can_use_cached_backdrop_filtered_result());
+  EXPECT_TRUE(GetRenderSurface(child1_)->intersects_damage_under());
 
   // CASE 1.2: Setting an intersecting update rect on the root invalidates
   // child1_'s cached backdrop-filtered result.
@@ -2082,8 +2078,7 @@ TEST_F(DamageTrackerTest, CanUseCachedBackdropFilterResultTest) {
   ClearDamageForAllSurfaces(root);
   root->UnionUpdateRect(gfx::Rect(260, 260, 20, 20));
   EmulateDrawingOneFrame(root);
-  EXPECT_FALSE(
-      GetRenderSurface(child1_)->can_use_cached_backdrop_filtered_result());
+  EXPECT_FALSE(GetRenderSurface(child1_)->intersects_damage_under());
 
   // CASE 1.3: Damage on layers above the surface with the backdrop filter
   // doesn't invalidate cached backdrop-filtered result. Move child2_ to overlap
@@ -2091,8 +2086,7 @@ TEST_F(DamageTrackerTest, CanUseCachedBackdropFilterResultTest) {
   ClearDamageForAllSurfaces(root);
   child2_->SetOffsetToTransformParent(gfx::Vector2dF(180.f, 180.f));
   EmulateDrawingOneFrame(root);
-  EXPECT_TRUE(GetRenderSurface(grand_child1_)
-                  ->can_use_cached_backdrop_filtered_result());
+  EXPECT_TRUE(GetRenderSurface(grand_child1_)->intersects_damage_under());
 
   // CASE 2: Adding or removing a backdrop filter would invalidate cached
   // backdrop-filtered result of the corresponding render surfaces.
@@ -2104,15 +2098,12 @@ TEST_F(DamageTrackerTest, CanUseCachedBackdropFilterResultTest) {
   SetBackdropFilter(grand_child4_, filters);
   grand_child4_->NoteLayerPropertyChanged();
   EmulateDrawingOneFrame(root);
-  EXPECT_FALSE(GetRenderSurface(grand_child4_)
-                   ->can_use_cached_backdrop_filtered_result());
-  EXPECT_FALSE(GetRenderSurface(grand_child1_)
-                   ->can_use_cached_backdrop_filtered_result());
+  EXPECT_FALSE(GetRenderSurface(grand_child4_)->intersects_damage_under());
+  EXPECT_FALSE(GetRenderSurface(grand_child1_)->intersects_damage_under());
 
   // Let run for one update and there should be no damage left.
   EmulateDrawingOneFrame(root);
-  EXPECT_TRUE(GetRenderSurface(grand_child4_)
-                  ->can_use_cached_backdrop_filtered_result());
+  EXPECT_TRUE(GetRenderSurface(grand_child4_)->intersects_damage_under());
 
   // CASE 3.1: Adding a non-intersecting damage rect to a sibling layer under
   // the render surface with the backdrop filter doesn't invalidate cached
@@ -2121,8 +2112,7 @@ TEST_F(DamageTrackerTest, CanUseCachedBackdropFilterResultTest) {
   ClearDamageForAllSurfaces(root);
   grand_child1_->AddDamageRect(gfx::Rect(2, 2, 1.f, 1.f));
   EmulateDrawingOneFrame(root);
-  EXPECT_TRUE(GetRenderSurface(grand_child4_)
-                  ->can_use_cached_backdrop_filtered_result());
+  EXPECT_TRUE(GetRenderSurface(grand_child4_)->intersects_damage_under());
 
   // CASE 3.2: Adding an intersecting damage rect to a sibling layer under the
   // render surface with the backdrop filter invalidates cached
@@ -2131,8 +2121,7 @@ TEST_F(DamageTrackerTest, CanUseCachedBackdropFilterResultTest) {
   ClearDamageForAllSurfaces(root);
   grand_child2_->AddDamageRect(gfx::Rect(0, 0, 1.f, 1.f));
   EmulateDrawingOneFrame(root);
-  EXPECT_FALSE(GetRenderSurface(grand_child4_)
-                   ->can_use_cached_backdrop_filtered_result());
+  EXPECT_FALSE(GetRenderSurface(grand_child4_)->intersects_damage_under());
 
   // CASE 4.1: Non-intersecting damage rect on a sibling surface under the
   // render surface with the backdrop filter doesn't invalidate cached
@@ -2147,8 +2136,7 @@ TEST_F(DamageTrackerTest, CanUseCachedBackdropFilterResultTest) {
   EXPECT_EQ(gfx::Rect(170, 170, 1.f, 1.f), damage_rect);
   // Damage rect at 170,170 1x1 in render target local space doesn't intersect
   // 180,180 15x16.
-  EXPECT_TRUE(GetRenderSurface(grand_child4_)
-                  ->can_use_cached_backdrop_filtered_result());
+  EXPECT_TRUE(GetRenderSurface(grand_child4_)->intersects_damage_under());
 
   // CASE 4.2: Intersecting damage rect on a sibling surface under the render
   // surface with the backdrop filter invalidates cached backdrop-filtered
@@ -2162,8 +2150,7 @@ TEST_F(DamageTrackerTest, CanUseCachedBackdropFilterResultTest) {
   EXPECT_EQ(gfx::Rect(170, 170, 11.f, 11.f), damage_rect);
   // Damage rect at 170,170 11x11 in render target local space intersects
   // 180,180 15x16
-  EXPECT_FALSE(GetRenderSurface(grand_child4_)
-                   ->can_use_cached_backdrop_filtered_result());
+  EXPECT_FALSE(GetRenderSurface(grand_child4_)->intersects_damage_under());
 
   // CASE 5.1: Removing a non-intersecting sibling layer under the render
   // surface with the backdrop filter doesn't invalidate cached
@@ -2185,8 +2172,7 @@ TEST_F(DamageTrackerTest, CanUseCachedBackdropFilterResultTest) {
   host_impl()->active_tree()->AddLayer(std::move(layers[5]));
   host_impl()->active_tree()->AddLayer(std::move(layers[6]));
   EmulateDrawingOneFrame(root);
-  EXPECT_TRUE(GetRenderSurface(grand_child4_)
-                  ->can_use_cached_backdrop_filtered_result());
+  EXPECT_TRUE(GetRenderSurface(grand_child4_)->intersects_damage_under());
 
   // CASE 5.2: Removing an intersecting sibling layer under the render surface
   // with the backdrop filter invalidates cached backdrop-filtered result.
@@ -2205,14 +2191,12 @@ TEST_F(DamageTrackerTest, CanUseCachedBackdropFilterResultTest) {
   host_impl()->active_tree()->AddLayer(std::move(layers[5]));
 
   EmulateDrawingOneFrame(root);
-  EXPECT_FALSE(GetRenderSurface(grand_child4_)
-                   ->can_use_cached_backdrop_filtered_result());
+  EXPECT_FALSE(GetRenderSurface(grand_child4_)->intersects_damage_under());
 
   // Let run for one update and there should be no damage left.
   ClearDamageForAllSurfaces(root);
   EmulateDrawingOneFrame(root);
-  EXPECT_TRUE(GetRenderSurface(grand_child4_)
-                  ->can_use_cached_backdrop_filtered_result());
+  EXPECT_TRUE(GetRenderSurface(grand_child4_)->intersects_damage_under());
 
   // CASE 6: Removing a intersecting sibling surface under the render
   // surface with the backdrop filter invalidate cached backdrop-filtered
@@ -2221,8 +2205,7 @@ TEST_F(DamageTrackerTest, CanUseCachedBackdropFilterResultTest) {
   SetRenderSurfaceReason(grand_child3_, RenderSurfaceReason::kNone);
   grand_child3_->SetDrawsContent(false);
   EmulateDrawingOneFrame(root);
-  EXPECT_FALSE(GetRenderSurface(grand_child4_)
-                   ->can_use_cached_backdrop_filtered_result());
+  EXPECT_FALSE(GetRenderSurface(grand_child4_)->intersects_damage_under());
 }
 
 TEST_F(DamageTrackerTest, DamageRectOnlyVisibleContentsMoveToOutside) {