Remove |require_overlay|

This flag is no longer used in YUV draw quad and dc layer overlay. The first clean-up
of this flag in video frame metadata has been checked in. This CL will remove this
flag completely.

Bug:1340270



Change-Id: Id5816ca0aaf4dc99f22988c4eba4ff5818a94678
Reviewed-on: https://chromium-review.googlesource.com/c/1340270
Commit-Queue: Maggie Chen <magchen@chromium.org>
Reviewed-by: Daniel Cheng <dcheng@chromium.org>
Reviewed-by: Antoine Labour <piman@chromium.org>
Reviewed-by: Zhenyao Mo <zmo@chromium.org>
Cr-Commit-Position: refs/heads/master@{#609941}

components/viz/common/quads/draw_quad_unittest.cc

@@ -399,7 +399,6 @@ TEST(DrawQuadTest, CopyYUVVideoDrawQuad) {
   float resource_offset = 0.5f;
   float resource_multiplier = 2.001f;
   uint32_t bits_per_channel = 5;
-  bool require_overlay = true;
   ui::ProtectedVideoType protected_video_type =
       ui::ProtectedVideoType::kHardwareProtected;
   gfx::ColorSpace video_color_space = gfx::ColorSpace::CreateJpeg();
@@ -424,14 +423,13 @@ TEST(DrawQuadTest, CopyYUVVideoDrawQuad) {
   EXPECT_EQ(resource_offset, copy_quad->resource_offset);
   EXPECT_EQ(resource_multiplier, copy_quad->resource_multiplier);
   EXPECT_EQ(bits_per_channel, copy_quad->bits_per_channel);
-  EXPECT_FALSE(copy_quad->require_overlay);
   EXPECT_EQ(ui::ProtectedVideoType::kClear, copy_quad->protected_video_type);
 
   CREATE_QUAD_ALL(YUVVideoDrawQuad, ya_tex_coord_rect, uv_tex_coord_rect,
                   ya_tex_size, uv_tex_size, y_plane_resource_id,
                   u_plane_resource_id, v_plane_resource_id, a_plane_resource_id,
                   video_color_space, resource_offset, resource_multiplier,
-                  bits_per_channel, require_overlay, protected_video_type);
+                  bits_per_channel, protected_video_type);
   EXPECT_EQ(DrawQuad::YUV_VIDEO_CONTENT, copy_quad->material);
   EXPECT_EQ(ya_tex_coord_rect, copy_quad->ya_tex_coord_rect);
   EXPECT_EQ(uv_tex_coord_rect, copy_quad->uv_tex_coord_rect);
@@ -444,7 +442,6 @@ TEST(DrawQuadTest, CopyYUVVideoDrawQuad) {
   EXPECT_EQ(resource_offset, copy_quad->resource_offset);
   EXPECT_EQ(resource_multiplier, copy_quad->resource_multiplier);
   EXPECT_EQ(bits_per_channel, copy_quad->bits_per_channel);
-  EXPECT_EQ(require_overlay, copy_quad->require_overlay);
   EXPECT_EQ(protected_video_type, copy_quad->protected_video_type);
 }
 

components/viz/common/quads/yuv_video_draw_quad.cc

@@ -66,7 +66,6 @@ void YUVVideoDrawQuad::SetAll(const SharedQuadState* shared_quad_state,
                               float offset,
                               float multiplier,
                               uint32_t bits_per_channel,
-                              bool require_overlay,
                               ui::ProtectedVideoType protected_video_type) {
   DrawQuad::SetAll(shared_quad_state, DrawQuad::YUV_VIDEO_CONTENT, rect,
                    visible_rect, needs_blending);
@@ -83,7 +82,6 @@ void YUVVideoDrawQuad::SetAll(const SharedQuadState* shared_quad_state,
   this->resource_offset = offset;
   this->resource_multiplier = multiplier;
   this->bits_per_channel = bits_per_channel;
-  this->require_overlay = require_overlay;
   this->protected_video_type = protected_video_type;
 }
 
@@ -106,7 +104,6 @@ void YUVVideoDrawQuad::ExtendValue(
                     resources.ids[kVPlaneResourceIdIndex]);
   value->SetInteger("a_plane_resource_id",
                     resources.ids[kAPlaneResourceIdIndex]);
-  value->SetBoolean("require_overlay", require_overlay);
   value->SetInteger("protected_video_type",
                     static_cast<int>(protected_video_type));
 }

components/viz/common/quads/yuv_video_draw_quad.h

@@ -71,7 +71,6 @@ class VIZ_COMMON_EXPORT YUVVideoDrawQuad : public DrawQuad {
               float offset,
               float multiplier,
               uint32_t bits_per_channel,
-              bool require_overlay,
               ui::ProtectedVideoType protected_video_type);
 
   gfx::RectF ya_tex_coord_rect;
@@ -83,7 +82,6 @@ class VIZ_COMMON_EXPORT YUVVideoDrawQuad : public DrawQuad {
   uint32_t bits_per_channel = 8;
   // TODO(hubbe): Move to ResourceProvider::ScopedSamplerGL.
   gfx::ColorSpace video_color_space;
-  bool require_overlay = false;
   ui::ProtectedVideoType protected_video_type = ui::ProtectedVideoType::kClear;
 
   static const YUVVideoDrawQuad* MaterialCast(const DrawQuad*);

components/viz/service/display/dc_layer_overlay.cc

@@ -30,12 +30,7 @@ DCLayerOverlayProcessor::DCLayerResult FromYUVQuad(
   dc_layer_overlay->contents_rect = quad->ya_tex_coord_rect;
   dc_layer_overlay->filter = GL_LINEAR;
   dc_layer_overlay->color_space = quad->video_color_space;
-  dc_layer_overlay->require_overlay = quad->require_overlay;
   dc_layer_overlay->protected_video_type = quad->protected_video_type;
-  // HW Protected Videos have to go through the overlay swapchain path,
-  // so they can be protected by Windows OS and hardware
-  if (quad->protected_video_type == ui::ProtectedVideoType::kHardwareProtected)
-    dc_layer_overlay->require_overlay = true;
 
   return DCLayerOverlayProcessor::DC_LAYER_SUCCESS;
 }
@@ -280,7 +275,7 @@ void DCLayerOverlayProcessor::ProcessRenderPass(
 
     if (!it->shared_quad_state->quad_to_target_transform
              .Preserves2dAxisAlignment() &&
-        !dc_layer.require_overlay &&
+        !dc_layer.RequiresOverlay() &&
         !base::FeatureList::IsEnabled(
             features::kDirectCompositionComplexOverlays)) {
       RecordDCLayerResult(DC_LAYER_FAILED_COMPLEX_TRANSFORM);
@@ -311,7 +306,7 @@ void DCLayerOverlayProcessor::ProcessRenderPass(
     // TODO(magchen): Collect all overlay candidates, and filter the list at the
     // end to find the best candidates (largest size?).
     if (is_root &&
-        (!processed_overlay_in_frame_ || dc_layer.IsProtectedVideo()) &&
+        (!processed_overlay_in_frame_ || dc_layer.RequiresOverlay()) &&
         ProcessForOverlay(display_rect, quad_list, quad_rectangle,
                           occlusion_bounding_box, &it, damage_rect)) {
       // ProcessForOverlay makes the iterator point to the next value on
@@ -380,7 +375,7 @@ bool DCLayerOverlayProcessor::ProcessForUnderlay(
     gfx::Rect* this_frame_underlay_rect,
     gfx::Rect* this_frame_underlay_occlusion,
     DCLayerOverlay* dc_layer) {
-  if (!dc_layer->require_overlay) {
+  if (!dc_layer->RequiresOverlay()) {
     if (!base::FeatureList::IsEnabled(features::kDirectCompositionUnderlays)) {
       RecordDCLayerResult(DC_LAYER_FAILED_OCCLUDED);
       return false;

components/viz/service/display/dc_layer_overlay.h

@@ -45,6 +45,14 @@ class VIZ_SERVICE_EXPORT DCLayerOverlay {
   bool IsProtectedVideo() const {
     return (protected_video_type != ui::ProtectedVideoType::kClear);
   }
+  // TODO(magchen): Once software protected video is enabled for all GPUs and
+  // all configurations, RequiresOverlay() will be equivalent to
+  // IsProtectedVideo. Currently, we only force the overlay swap chain path
+  // (RequiresOverlay) for hardware protected video and soon for Finch
+  // experiment on software protected video.
+  bool RequiresOverlay() const {
+    return (protected_video_type == ui::ProtectedVideoType::kHardwareProtected);
+  }
 
   // State that is frequently shared between consecutive DCLayerOverlays.
   scoped_refptr<DCLayerOverlaySharedState> shared_state;
@@ -71,7 +79,6 @@ class VIZ_SERVICE_EXPORT DCLayerOverlay {
   // normally BT.709.
   gfx::ColorSpace color_space;
 
-  bool require_overlay = false;
   ui::ProtectedVideoType protected_video_type = ui::ProtectedVideoType::kClear;
 };
 

components/viz/service/display/overlay_unittest.cc

@@ -2409,7 +2409,8 @@ TEST_F(DCLayerOverlayTest, AllowRequiredNonAxisAlignedTransform) {
   YUVVideoDrawQuad* yuv_quad = CreateFullscreenCandidateYUVVideoQuad(
       resource_provider_.get(), child_resource_provider_.get(),
       child_provider_.get(), pass->shared_quad_state_list.back(), pass.get());
-  yuv_quad->require_overlay = true;
+  // Set the protected video flag will force DCLayerOverlay to use hw overlay
+  yuv_quad->protected_video_type = ui::ProtectedVideoType::kHardwareProtected;
   pass->shared_quad_state_list.back()
       ->quad_to_target_transform.RotateAboutZAxis(45.f);
 
@@ -2448,7 +2449,9 @@ TEST_F(DCLayerOverlayTest, Occluded) {
     auto* second_video_quad = CreateFullscreenCandidateYUVVideoQuad(
         resource_provider_.get(), child_resource_provider_.get(),
         child_provider_.get(), pass->shared_quad_state_list.back(), pass.get());
-    second_video_quad->require_overlay = true;
+    // Set the protected video flag will force DCLayerOverlay to use hw overlay
+    second_video_quad->protected_video_type =
+        ui::ProtectedVideoType::kHardwareProtected;
     second_video_quad->rect.set_origin(gfx::Point(2, 2));
     second_video_quad->visible_rect.set_origin(gfx::Point(2, 2));
 
@@ -2482,7 +2485,8 @@ TEST_F(DCLayerOverlayTest, Occluded) {
     auto* second_video_quad = CreateFullscreenCandidateYUVVideoQuad(
         resource_provider_.get(), child_resource_provider_.get(),
         child_provider_.get(), pass->shared_quad_state_list.back(), pass.get());
-    second_video_quad->require_overlay = true;
+    second_video_quad->protected_video_type =
+        ui::ProtectedVideoType::kHardwareProtected;
     second_video_quad->rect.set_origin(gfx::Point(2, 2));
     second_video_quad->visible_rect.set_origin(gfx::Point(2, 2));
 
@@ -2560,7 +2564,9 @@ TEST_F(DCLayerOverlayTest, MultiplePassDamageRect) {
       resource_provider_.get(), child_resource_provider_.get(),
       child_provider_.get(), child_pass1->shared_quad_state_list.back(),
       child_pass1.get());
-  yuv_quad_required->require_overlay = true;
+  // Set the protected video flag will force DCLayerOverlay to use hw overlay
+  yuv_quad_required->protected_video_type =
+      ui::ProtectedVideoType::kHardwareProtected;
 
   RenderPassId child_pass2_id(6);
   std::unique_ptr<RenderPass> child_pass2 = CreateRenderPass();
@@ -2575,7 +2581,6 @@ TEST_F(DCLayerOverlayTest, MultiplePassDamageRect) {
           resource_provider_.get(), child_resource_provider_.get(),
           child_provider_.get(), child_pass2->shared_quad_state_list.back(),
           child_pass2.get());
-  yuv_quad_not_required->require_overlay = false;
 
   std::unique_ptr<RenderPass> root_pass = CreateRenderPass();
   root_pass->CreateAndAppendSharedQuadState();
@@ -2626,7 +2631,7 @@ TEST_F(DCLayerOverlayTest, MultiplePassDamageRect) {
   EXPECT_EQ(0U, overlay_list.size());
   EXPECT_EQ(0U, output_surface_->bind_framebuffer_count());
 
-  // Only the |require_overlay| video quad produces damage.
+  // Only the kHardwareProtectedVideo video quad produces damage.
   ASSERT_EQ(1U, dc_layer_list.size());
   EXPECT_EQ(-1, dc_layer_list[0].shared_state->z_order);
   EXPECT_EQ(gfx::Rect(0, 0, 256, 256), pass_list[0]->damage_rect);
@@ -2639,8 +2644,8 @@ TEST_F(DCLayerOverlayTest, MultiplePassDamageRect) {
   EXPECT_EQ(DrawQuad::SOLID_COLOR,
             pass_list[0]->quad_list.ElementAt(0)->material);
 
-  // The |require_overlay| video quad is put into an underlay, and replaced by a
-  // solid color quad.
+  // The kHardwareProtectedVideo video quad is put into an underlay, and
+  // replaced by a solid color quad.
   auto* yuv_solid_color_quad =
       static_cast<SolidColorDrawQuad*>(pass_list[0]->quad_list.ElementAt(0));
   EXPECT_EQ(SK_ColorBLACK, yuv_solid_color_quad->color);

services/viz/public/cpp/compositing/quads_struct_traits.cc

@@ -199,7 +199,6 @@ bool StructTraits<viz::mojom::YUVVideoQuadStateDataView, viz::DrawQuad>::Read(
       quad->bits_per_channel > viz::YUVVideoDrawQuad::kMaxBitsPerChannel) {
     return false;
   }
-  quad->require_overlay = data.require_overlay();
   return true;
 }
 

services/viz/public/cpp/compositing/quads_struct_traits.h

@@ -477,11 +477,6 @@ struct StructTraits<viz::mojom::YUVVideoQuadStateDataView, viz::DrawQuad> {
         viz::YUVVideoDrawQuad::MaterialCast(&input);
     return quad->video_color_space;
   }
-  static bool require_overlay(const viz::DrawQuad& input) {
-    const viz::YUVVideoDrawQuad* quad =
-        viz::YUVVideoDrawQuad::MaterialCast(&input);
-    return quad->require_overlay;
-  }
   static ui::ProtectedVideoType protected_video_type(
       const viz::DrawQuad& input) {
     const viz::YUVVideoDrawQuad* quad =

services/viz/public/cpp/compositing/struct_traits_unittest.cc

@@ -1124,7 +1124,6 @@ TEST_F(StructTraitsTest, YUVDrawQuad) {
   const float resource_offset = 1337.5f;
   const float resource_multiplier = 1234.6f;
   const uint32_t bits_per_channel = 13;
-  const bool require_overlay = true;
   const ui::ProtectedVideoType protected_video_type =
       ui::ProtectedVideoType::kSoftwareProtected;
 
@@ -1135,7 +1134,7 @@ TEST_F(StructTraitsTest, YUVDrawQuad) {
                uv_tex_coord_rect, ya_tex_size, uv_tex_size, y_plane_resource_id,
                u_plane_resource_id, v_plane_resource_id, a_plane_resource_id,
                video_color_space, resource_offset, resource_multiplier,
-               bits_per_channel, require_overlay, protected_video_type);
+               bits_per_channel, protected_video_type);
 
   std::unique_ptr<RenderPass> output;
   mojo::test::SerializeAndDeserialize<mojom::RenderPass>(&render_pass, &output);
@@ -1159,7 +1158,6 @@ TEST_F(StructTraitsTest, YUVDrawQuad) {
   EXPECT_EQ(resource_offset, out_quad->resource_offset);
   EXPECT_EQ(resource_multiplier, out_quad->resource_multiplier);
   EXPECT_EQ(bits_per_channel, out_quad->bits_per_channel);
-  EXPECT_EQ(require_overlay, out_quad->require_overlay);
   EXPECT_EQ(protected_video_type, out_quad->protected_video_type);
 }
 

services/viz/public/interfaces/compositing/quads.mojom

@@ -103,7 +103,6 @@ struct YUVVideoQuadState {
   float resource_multiplier;
   uint32 bits_per_channel;
   gfx.mojom.ColorSpace video_color_space;
-  bool require_overlay;
   ProtectedVideoState protected_video_type;
 };