Improved overlay strategy damage for specific contexts.

In the situation of there being damage above an overlay we currently do
not remove the damage of the underlay. A good example of where this
occurs is the timeline controls on top of a youtube video. So instead of
doing the smallest amount of damage (say for the seconds counter) we
damage the entire video display region. There are other contexts for
which the overlay damage region is not removed but in the end these all
come down to the difficulty of subtracting damage from the incoming root
damage.

In this change we move from subtracting overlay damage to excluding it
via the |SurfaceDamageList|. This results in much more accurate final
damage and thus improve power usage. This change also dramatically
reduces the complexity of previously error prone overlay damage
subtraction computations.

Finally, this change moves us closer to our goal of doing damage
extraction on a per quad level in surface aggregator.
See this document for more information:
 https://docs.google.com/document/d/
1yDnz1DKcSwfMZwmeRR_RRS3QznpzqLnsMeeYIk-ORfA/edit?usp=sharing



Change-Id: Ia5901546bd3982b8054b5ae9d0f397c22d7e5228
Reviewed-on: https://chromium-review.googlesource.com/c/chromium/src/+/2558918Reviewed-by: Maggie Chen <magchen@chromium.org>
Reviewed-by: Robert Kroeger <rjkroege@chromium.org>
Commit-Queue: Peter McNeeley <petermcneeley@chromium.org>
Cr-Commit-Position: refs/heads/master@{#836164}

components/viz/service/display/overlay_candidate.cc

@@ -26,6 +26,10 @@
 
 namespace viz {
 
+// There is a bug in |base::optional| which causes the 'value_or' function to
+// capture parameters (even constexpr parameters) as a reference.
+constexpr uint32_t OverlayCandidate::kInvalidDamageIndex;
+
 namespace {
 // Tolerance for considering axis vector elements to be zero.
 const SkScalar kEpsilon = std::numeric_limits<float>::epsilon();
@@ -82,30 +86,6 @@ gfx::OverlayTransform GetOverlayTransform(const gfx::Transform& quad_transform,
     return gfx::OVERLAY_TRANSFORM_INVALID;
 }
 
-bool HasOccludingDamage(const SharedQuadState* shared_quad_state,
-                        SurfaceDamageRectList* surface_damage_rect_list) {
-  if (!shared_quad_state->overlay_damage_index.has_value())
-    return true;
-
-  size_t overlay_damage_index = shared_quad_state->overlay_damage_index.value();
-  // Invalid index.
-  if (overlay_damage_index >= surface_damage_rect_list->size()) {
-    DCHECK(false);
-    return true;
-  }
-
-  // Damage rects in surface_damage_rect_list are arranged from top to bottom.
-  // (*surface_damage_rect_list)[0] is the one on the very top.
-  // (*surface_damage_rect_list)[overlay_damage_index] is the damage rect of
-  // this overlay surface.
-  for (size_t i = 0; i < overlay_damage_index; ++i) {
-    if (!(*surface_damage_rect_list)[i].IsEmpty())
-      return true;  // A damaged surface on top is found.
-  }
-
-  return false;  // No occluding damages
-}
-
 gfx::Rect GetDamageRect(const DrawQuad* quad,
                         SurfaceDamageRectList* surface_damage_rect_list) {
   const SharedQuadState* sqs = quad->shared_quad_state;
@@ -147,13 +127,11 @@ OverlayCandidate::OverlayCandidate()
       uv_rect(0.f, 0.f, 1.f, 1.f),
       is_clipped(false),
       is_opaque(false),
-      no_occluding_damage(false),
       resource_id(0),
 #if defined(OS_ANDROID)
       is_backed_by_surface_texture(false),
       is_promotable_hint(false),
 #endif
-      is_unoccluded(false),
       overlay_handled(false),
       gpu_fence_id(0) {
 }
@@ -178,6 +156,11 @@ bool OverlayCandidate::FromDrawQuad(
   // We don't support an opacity value different than one for an overlay plane.
   if (quad->shared_quad_state->opacity != 1.f)
     return false;
+
+  candidate->overlay_damage_index =
+      quad->shared_quad_state->overlay_damage_index.value_or(
+          kInvalidDamageIndex);
+
   // We can't support overlays with mask filter.
   if (!quad->shared_quad_state->mask_filter_info.IsEmpty())
     return false;
@@ -340,8 +323,6 @@ bool OverlayCandidate::FromDrawQuadResource(
   candidate->clip_rect = quad->shared_quad_state->clip_rect;
   candidate->is_clipped = quad->shared_quad_state->is_clipped;
   candidate->is_opaque = !quad->ShouldDrawWithBlending();
-  candidate->no_occluding_damage =
-      !HasOccludingDamage(quad->shared_quad_state, surface_damage_rect_list);
   // For underlays the function 'EstimateVisibleDamage()' is called to update
   // |damage_area_estimate| to more accurately reflect the actual visible
   // damage.
@@ -371,8 +352,6 @@ bool OverlayCandidate::FromVideoHoleQuad(
   candidate->display_rect = gfx::RectF(quad->rect);
   transform.TransformRect(&candidate->display_rect);
   candidate->transform = overlay_transform;
-  candidate->no_occluding_damage =
-      !HasOccludingDamage(quad->shared_quad_state, surface_damage_rect_list);
   // For underlays the function 'EstimateVisibleDamage()' is called to update
   // |damage_area_estimate| to more accurately reflect the actual visible
   // damage.

components/viz/service/display/overlay_candidate.h

@@ -99,8 +99,6 @@ class VIZ_SERVICE_EXPORT OverlayCandidate {
   bool is_clipped;
   // If the quad doesn't require blending.
   bool is_opaque;
-  // The quad's occluding damage rect is empty.
-  bool no_occluding_damage;
   // Texture resource to present in an overlay.
   unsigned resource_id;
   // Mailbox from resource_id. It is used by SkiaRenderer.
@@ -121,11 +119,6 @@ class VIZ_SERVICE_EXPORT OverlayCandidate {
   // which is 0. Signed to allow for "underlays".
   int plane_z_order = 0;
 
-  // True if the overlay does not have any visible quads on top of it. Set by
-  // the strategy so the OverlayProcessor can consider subtracting damage caused
-  // by underlay quads.
-  bool is_unoccluded;
-
   // To be modified by the implementer if this candidate can go into
   // an overlay.
   bool overlay_handled;
@@ -138,6 +131,10 @@ class VIZ_SERVICE_EXPORT OverlayCandidate {
   int damage_area_estimate = 0;
 
   // Result of call to 'RequiresOverlay' function w/ associated quad.
+  static constexpr uint32_t kInvalidDamageIndex = UINT_MAX;
+  uint32_t overlay_damage_index = kInvalidDamageIndex;
+
+  // Cached result of call to 'RequiresOverlay' function.
   bool requires_overlay = false;
 
  private:

components/viz/service/display/overlay_processor_using_strategy.h

@@ -170,8 +170,8 @@ class VIZ_SERVICE_EXPORT OverlayProcessorUsingStrategy
   Strategy* last_successful_strategy_ = nullptr;
 
   gfx::Rect overlay_damage_rect_;
-  gfx::Rect previous_frame_underlay_rect_;
-  bool previous_frame_underlay_was_unoccluded_ = false;
+  bool previous_is_underlay = false;
+  gfx::Rect previous_frame_overlay_rect_;
 
   struct OverlayPrioritizationConfig {
     // Threshold criteria required for a proposed candidate to be considered for
@@ -190,8 +190,7 @@ class VIZ_SERVICE_EXPORT OverlayProcessorUsingStrategy
  private:
   // Update |damage_rect| by removing damage caused by |candidates|.
   void UpdateDamageRect(OverlayCandidateList* candidates,
-                        const gfx::Rect& previous_frame_underlay_rect,
-                        bool previous_frame_underlay_was_unoccluded,
+                        SurfaceDamageRectList* surface_damage_rect_list,
                         const QuadList* quad_list,
                         gfx::Rect* damage_rect);
 

components/viz/service/display/overlay_strategy_underlay.cc

@@ -77,12 +77,8 @@ bool OverlayStrategyUnderlay::Attempt(
     // If the candidate can be handled by an overlay, create a pass for it. We
     // need to switch out the video quad with a black transparent one.
     if (new_candidate_list.back().overlay_handled) {
-      new_candidate_list.back().is_unoccluded =
-          !OverlayCandidate::IsOccluded(candidate, quad_list.cbegin(), it);
-
       render_pass->ReplaceExistingQuadWithOpaqueTransparentSolidColor(it);
       candidate_list->swap(new_candidate_list);
-
       return true;
     }
   }
@@ -146,7 +142,7 @@ bool OverlayStrategyUnderlay::AttemptPrioritized(
   // Before we attempt an overlay strategy, the candidate list should be empty.
   DCHECK(candidate_list->empty());
   auto* render_pass = render_pass_list->back().get();
-  QuadList& quad_list = render_pass->quad_list;
+
   // Add the overlay.
   OverlayCandidateList new_candidate_list = *candidate_list;
   new_candidate_list.push_back(proposed_candidate->candidate);
@@ -170,10 +166,6 @@ bool OverlayStrategyUnderlay::AttemptPrioritized(
   // If the candidate can be handled by an overlay, create a pass for it. We
   // need to switch out the video quad with a black transparent one.
   if (new_candidate_list.back().overlay_handled) {
-    new_candidate_list.back().is_unoccluded = !OverlayCandidate::IsOccluded(
-        proposed_candidate->candidate, quad_list.cbegin(),
-        proposed_candidate->quad_iter);
-
     render_pass->ReplaceExistingQuadWithOpaqueTransparentSolidColor(
         proposed_candidate->quad_iter);
     candidate_list->swap(new_candidate_list);