Add a switch for the new overlay damage method on Windows

A new feature switch DirectCompositionUseOverlayDamageList is added to
enable the new method that removes the overlay damage from the
root damage to get the final optimized damage rect.

This CL also adds a new histogram
GPU.DirectComposition.DCLayer.OverlayCount which records the total
number of overlays we are going to present in the DC overlay processor.

Bug:1117235

Change-Id: I1fb97d8b4fd96270ff6447b63ad86785d60c2eeb
Reviewed-on: https://chromium-review.googlesource.com/c/chromium/src/+/2416966
Commit-Queue: Maggie Chen <magchen@chromium.org>
Reviewed-by: Sunny Sachanandani <sunnyps@chromium.org>
Reviewed-by: Robert Kaplow <rkaplow@chromium.org>
Reviewed-by: Zhenyao Mo <zmo@chromium.org>
Cr-Commit-Position: refs/heads/master@{#813071}

components/viz/service/display/dc_layer_overlay.cc

@@ -6,6 +6,7 @@
 
 #include <limits>
 
+#include "base/metrics/histogram_functions.h"
 #include "base/metrics/histogram_macros.h"
 #include "base/threading/thread_task_runner_handle.h"
 #include "build/build_config.h"
@@ -19,6 +20,7 @@
 #include "components/viz/service/display/display_resource_provider.h"
 #include "components/viz/service/display/overlay_processor_interface.h"
 #include "gpu/GLES2/gl2extchromium.h"
+#include "gpu/config/gpu_finch_features.h"
 #include "ui/gfx/geometry/insets.h"
 #include "ui/gfx/geometry/rect.h"
 #include "ui/gfx/geometry/rect_conversions.h"
@@ -71,7 +73,8 @@ DCLayerResult ValidateYUVQuad(
     const YUVVideoDrawQuad* quad,
     const std::vector<gfx::Rect>& backdrop_filter_rects,
     bool has_overlay_support,
-    int current_frame_processed_overlay_count,
+    int allowed_yuv_overlay_count,
+    int processed_yuv_overlay_count,
     DisplayResourceProvider* resource_provider) {
   // Note: Do not override this value based on base::Feature values. It is the
   // result after the GPU blocklist has been consulted.
@@ -97,7 +100,7 @@ DCLayerResult ValidateYUVQuad(
     return DC_LAYER_FAILED_COMPLEX_TRANSFORM;
   }
 
-  if (current_frame_processed_overlay_count > 0)
+  if (processed_yuv_overlay_count >= allowed_yuv_overlay_count)
     return DC_LAYER_FAILED_TOO_MANY_OVERLAYS;
 
   // Rounded corner on overlays are not supported.
@@ -320,8 +323,13 @@ DCLayerOverlay::~DCLayerOverlay() = default;
 
 DCLayerOverlayProcessor::DCLayerOverlayProcessor(
     const DebugRendererSettings* debug_settings,
+    int allowed_yuv_overlay_count,
     bool skip_initialization_for_testing)
     : has_overlay_support_(skip_initialization_for_testing),
+      use_overlay_damage_list_(base::FeatureList::IsEnabled(
+          features::kDirectCompositionUseOverlayDamageList)),
+      allowed_yuv_overlay_count_(
+          use_overlay_damage_list_ ? allowed_yuv_overlay_count : 1),
       debug_settings_(debug_settings),
       viz_task_runner_(skip_initialization_for_testing
                            ? nullptr
@@ -406,6 +414,7 @@ void DCLayerOverlayProcessor::Process(
     gfx::Rect* damage_rect,
     DCLayerOverlayList* dc_layer_overlays) {
   gfx::Rect this_frame_underlay_rect;
+  processed_yuv_overlay_count_ = 0;
 
   // Which render passes have backdrop filters.
   base::flat_set<AggregatedRenderPassId> render_pass_has_backdrop_filters;
@@ -451,11 +460,13 @@ void DCLayerOverlayProcessor::Process(
     DCLayerResult result;
     switch (it->material) {
       case DrawQuad::Material::kYuvVideoContent:
-        result =
-            ValidateYUVQuad(YUVVideoDrawQuad::MaterialCast(*it),
-                            backdrop_filter_rects, has_overlay_support_,
-                            candidate_index_list.size(), resource_provider);
+        result = ValidateYUVQuad(
+            YUVVideoDrawQuad::MaterialCast(*it), backdrop_filter_rects,
+            has_overlay_support_, allowed_yuv_overlay_count_,
+            processed_yuv_overlay_count_, resource_provider);
         yuv_quads_in_quad_list++;
+        if (result == DC_LAYER_SUCCESS)
+          processed_yuv_overlay_count_++;
         break;
       case DrawQuad::Material::kTextureContent:
         result = ValidateTextureQuad(TextureDrawQuad::MaterialCast(*it),
@@ -483,11 +494,17 @@ void DCLayerOverlayProcessor::Process(
 
     candidate_index_list.push_back(index);
   }
+  // A YUV quad might be rejected later due to not allowed as an underlay.
+  // Recount the YUV overlays when they are added to the overlay list
+  // successfully.
+  processed_yuv_overlay_count_ = 0;
 
+  // TODO(magchen@): Revisit this code if allowed_yuv_overlay_count_ > 1.
   // We might not save power if there are more than one videos and only one is
   // promoted to overlay. Skip overlays for this frame unless there are
   // protected video or texture overlays.
-  if (candidate_index_list.size() > 0 && yuv_quads_in_quad_list > 1 &&
+  if (candidate_index_list.size() > 0 &&
+      yuv_quads_in_quad_list > allowed_yuv_overlay_count_ &&
       !has_protected_video_or_texture_overlays) {
     candidate_index_list.clear();
     // In this case, there is only one candidate in the list.
@@ -516,6 +533,12 @@ void DCLayerOverlayProcessor::Process(
     // skipped if they're not underlay compatible.
     const bool requires_overlay = IsProtectedVideo(it);
 
+    // TODO(magchen@): Since we reject underlays here, the max number of YUV
+    // overlays we can promote might not be accurate. We should allow all YUV
+    // quads to be put into candidate_index_list, but only
+    // |allowed_yuv_overlay_count_| YUV quads should be promoted to
+    // overlays/underlays from that list.
+
     // Skip quad if it's an underlay and underlays are not allowed.
     if (!is_overlay && !requires_overlay) {
       DCLayerResult result = IsUnderlayAllowed(it);
@@ -539,16 +562,23 @@ void DCLayerOverlayProcessor::Process(
   // found in this frame, the previous overlay rects would have been handled
   // above and |previous_frame_overlay_rect_union_| becomes empty.
   damage_rect->Union(previous_frame_overlay_rect_union_);
+  damage_rect->Intersect(gfx::ToEnclosingRect(display_rect));
+
   previous_frame_overlay_rect_union_ = current_frame_overlay_rect_union_;
   current_frame_overlay_rect_union_ = gfx::Rect();
   previous_frame_processed_overlay_count_ =
       current_frame_processed_overlay_count_;
   current_frame_processed_overlay_count_ = 0;
-
-  damage_rect->Intersect(gfx::ToEnclosingRect(display_rect));
   previous_display_rect_ = display_rect;
   previous_frame_underlay_rect_ = this_frame_underlay_rect;
 
+  if (!dc_layer_overlays->empty()) {
+    base::UmaHistogramExactLinear(
+        "GPU.DirectComposition.DCLayer.YUVOverlayCount",
+        /*sample=*/processed_yuv_overlay_count_,
+        /*value_max=*/10);
+  }
+
   if (debug_settings_->show_dc_layer_debug_borders &&
       dc_layer_overlays->size() > 0) {
     InsertDebugBorderDrawQuad(dc_layer_overlays, root_render_pass, display_rect,
@@ -576,6 +606,7 @@ void DCLayerOverlayProcessor::UpdateDCLayerOverlays(
     case DrawQuad::Material::kYuvVideoContent:
       FromYUVQuad(YUVVideoDrawQuad::MaterialCast(*it),
                   render_pass->transform_to_root_target, &dc_layer);
+      processed_yuv_overlay_count_++;
       break;
     case DrawQuad::Material::kTextureContent:
       FromTextureQuad(TextureDrawQuad::MaterialCast(*it),
@@ -624,7 +655,6 @@ void DCLayerOverlayProcessor::UpdateDCLayerOverlays(
 
   dc_layer_overlays->push_back(dc_layer);
 
-  // Only allow one overlay unless it's hardware protected video.
   current_frame_processed_overlay_count_++;
 }
 

components/viz/service/display/dc_layer_overlay.h

@@ -79,8 +79,14 @@ class VIZ_SERVICE_EXPORT DCLayerOverlayProcessor
  public:
   // When |skip_initialization_for_testing| is true, object will be isolated
   // for unit tests.
+  // allowed_yuv_overlay_count will be limited to 1 if
+  // |use_overlay_damage_list_| is not supported. This new method produces an
+  // empty root damage rect when the overlay quads are the only damages in the
+  // frames. If |use_overlay_damage_list_| is false, we should not allowed more
+  // than one YUV overlays since non-empty damage rect won't save any power.
   explicit DCLayerOverlayProcessor(
       const DebugRendererSettings* debug_settings,
+      int allowed_yuv_overlay_count,
       bool skip_initialization_for_testing = false);
   virtual ~DCLayerOverlayProcessor();
 
@@ -137,6 +143,11 @@ class VIZ_SERVICE_EXPORT DCLayerOverlayProcessor
                                  gfx::Rect* damage_rect);
 
   bool has_overlay_support_;
+  const bool use_overlay_damage_list_;
+  // TODO(magchen@): We are going to support more than one YUV overlay.
+  const int allowed_yuv_overlay_count_;
+  int processed_yuv_overlay_count_ = 0;
+
   // Reference to the global viz singleton.
   const DebugRendererSettings* const debug_settings_;
 

components/viz/service/display/gl_renderer_unittest.cc

@@ -2523,7 +2523,9 @@ TEST_F(MockOutputSurfaceTest, BackbufferDiscard) {
 class MockDCLayerOverlayProcessor : public DCLayerOverlayProcessor {
  public:
   MockDCLayerOverlayProcessor()
-      : DCLayerOverlayProcessor(&debug_settings_, true) {}
+      : DCLayerOverlayProcessor(&debug_settings_,
+                                /*allowed_yuv_overlay_count=*/1,
+                                true) {}
   ~MockDCLayerOverlayProcessor() override = default;
   MOCK_METHOD5(Process,
                void(DisplayResourceProvider* resource_provider,
@@ -3669,7 +3671,8 @@ TEST_F(GLRendererTest, DCLayerOverlaySwitch) {
 
   auto processor = std::make_unique<OverlayProcessorWin>(
       output_surface.get(),
-      std::make_unique<DCLayerOverlayProcessor>(&debug_settings_, true));
+      std::make_unique<DCLayerOverlayProcessor>(
+          &debug_settings_, /*allowed_yuv_overlay_count=*/1, true));
 
   RendererSettings settings;
   settings.partial_swap_enabled = true;

components/viz/service/display/overlay_dc_unittest.cc

@@ -101,10 +101,11 @@ class OverlayOutputSurface : public OutputSurface {
 class DCTestOverlayProcessor : public OverlayProcessorWin {
  public:
   explicit DCTestOverlayProcessor(OutputSurface* output_surface)
-      : OverlayProcessorWin(
-            output_surface,
-            std::make_unique<DCLayerOverlayProcessor>(&debug_settings_, true)) {
-  }
+      : OverlayProcessorWin(output_surface,
+                            std::make_unique<DCLayerOverlayProcessor>(
+                                &debug_settings_,
+                                /*allowed_yuv_overlay_count=*/1,
+                                true)) {}
   DebugRendererSettings debug_settings_;
 };
 

components/viz/service/display/overlay_processor_interface.cc

@@ -92,8 +92,8 @@ OverlayProcessorInterface::CreateOverlayProcessor(
                                                enable_ca_overlay);
 #elif defined(OS_WIN)
   return std::make_unique<OverlayProcessorWin>(
-      output_surface,
-      std::make_unique<DCLayerOverlayProcessor>(debug_settings));
+      output_surface, std::make_unique<DCLayerOverlayProcessor>(
+                          debug_settings, /*allowed_yuv_overlay_count=*/1));
 #elif defined(USE_OZONE)
   if (!features::IsUsingOzonePlatform())
     return std::make_unique<OverlayProcessorStub>();

gpu/config/gpu_finch_features.cc

@@ -52,6 +52,11 @@ const base::Feature kDefaultEnableOopRasterization{
 // Use a high priority for GPU process on Windows.
 const base::Feature kGpuProcessHighPriorityWin{
     "GpuProcessHighPriorityWin", base::FEATURE_ENABLED_BY_DEFAULT};
+
+// Compute the root damage rect from the surface damage list for overlays on
+// Windows.
+const base::Feature kDirectCompositionUseOverlayDamageList{
+    "DirectCompositionUseOverlayDamageList", base::FEATURE_ENABLED_BY_DEFAULT};
 #endif
 
 // Use ThreadPriority::DISPLAY for GPU main, viz compositor and IO threads.

gpu/config/gpu_finch_features.h

@@ -28,6 +28,8 @@ GPU_EXPORT extern const base::Feature kDefaultEnableOopRasterization;
 
 #if defined(OS_WIN)
 GPU_EXPORT extern const base::Feature kGpuProcessHighPriorityWin;
+
+GPU_EXPORT extern const base::Feature kDirectCompositionUseOverlayDamageList;
 #endif
 
 GPU_EXPORT extern const base::Feature kGpuUseDisplayThreadPriority;

tools/metrics/histograms/histograms_xml/gpu/histograms.xml

@@ -366,6 +366,17 @@ reviews. Googlers can read more about this at go/gwsq-gerrit.
   </summary>
 </histogram>
 
+<histogram name="GPU.DirectComposition.DCLayer.YUVOverlayCount"
+    units="overlays" expires_after="2021-03-15">
+  <owner>magchen@chromium.org</owner>
+  <owner>zmo@chromium.org</owner>
+  <summary>
+    The number of YUV overlays we are going to present in each frame if the
+    number is not 0. Recorded when the overlay processor is called for drawing a
+    frame.
+  </summary>
+</histogram>
+
 <histogram name="GPU.DirectComposition.DCLayerResult.Texture"
     enum="DCLayerResult" expires_after="2020-12-31">
   <owner>sunnyps@chromium.org</owner>