Support software protected videos in YUVVideoDrawQuad

Screen capture on protected videos will no longer work after software protected
videos are supported.

This CL handles YUVVideoDrawQuad only. The other part of the support on the gpu
side was checked in separately. The main change in this CL is to replace the
existing flag |is_protected_video| with |protected_video_type| which includes
clear, softwareProtected and hardwareProtected.

NOTE: Before this CL, |PROTECTED_VIDEO| means hardware protected video. After
this CL, |PROTECTED_VIDEO| means both software and hardware and |HW_PROTECTED|
will differentiate whether it's protected by software or hardware.

Bug:903552

Change-Id: I8c025bdcbafaed224a5e1f9ea6fa14b42bdfe192
Reviewed-on: https://chromium-review.googlesource.com/c/1334099Reviewed-by: Daniel Cheng <dcheng@chromium.org>
Reviewed-by: Rintaro Kuroiwa <rkuroiwa@chromium.org>
Reviewed-by: Antoine Labour <piman@chromium.org>
Reviewed-by: Xiaohan Wang <xhwang@chromium.org>
Reviewed-by: Zhenyao Mo <zmo@chromium.org>
Commit-Queue: Maggie Chen <magchen@chromium.org>
Cr-Commit-Position: refs/heads/master@{#609818}

components/viz/common/quads/DEPS

@@ -8,6 +8,7 @@ include_rules = [
 
   "+gpu/command_buffer/common",
   "+third_party/skia",
+  "+ui/gl/dc_renderer_layer_params.h",
   "+ui/latency",
 ]
 

components/viz/common/quads/draw_quad_unittest.cc

@@ -400,7 +400,8 @@ TEST(DrawQuadTest, CopyYUVVideoDrawQuad) {
   float resource_multiplier = 2.001f;
   uint32_t bits_per_channel = 5;
   bool require_overlay = true;
-  bool is_protected_video = true;
+  ui::ProtectedVideoType protected_video_type =
+      ui::ProtectedVideoType::kHardwareProtected;
   gfx::ColorSpace video_color_space = gfx::ColorSpace::CreateJpeg();
   CREATE_SHARED_STATE();
 
@@ -424,13 +425,13 @@ TEST(DrawQuadTest, CopyYUVVideoDrawQuad) {
   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_FALSE(copy_quad->is_protected_video);
+  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, is_protected_video);
+                  bits_per_channel, require_overlay, 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 +445,7 @@ TEST(DrawQuadTest, CopyYUVVideoDrawQuad) {
   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(is_protected_video, copy_quad->is_protected_video);
+  EXPECT_EQ(protected_video_type, copy_quad->protected_video_type);
 }
 
 TEST(DrawQuadTest, CopyPictureDrawQuad) {

components/viz/common/quads/yuv_video_draw_quad.cc

@@ -67,7 +67,7 @@ void YUVVideoDrawQuad::SetAll(const SharedQuadState* shared_quad_state,
                               float multiplier,
                               uint32_t bits_per_channel,
                               bool require_overlay,
-                              bool is_protected_video) {
+                              ui::ProtectedVideoType protected_video_type) {
   DrawQuad::SetAll(shared_quad_state, DrawQuad::YUV_VIDEO_CONTENT, rect,
                    visible_rect, needs_blending);
   this->ya_tex_coord_rect = ya_tex_coord_rect;
@@ -84,7 +84,7 @@ void YUVVideoDrawQuad::SetAll(const SharedQuadState* shared_quad_state,
   this->resource_multiplier = multiplier;
   this->bits_per_channel = bits_per_channel;
   this->require_overlay = require_overlay;
-  this->is_protected_video = is_protected_video;
+  this->protected_video_type = protected_video_type;
 }
 
 const YUVVideoDrawQuad* YUVVideoDrawQuad::MaterialCast(const DrawQuad* quad) {
@@ -107,7 +107,8 @@ void YUVVideoDrawQuad::ExtendValue(
   value->SetInteger("a_plane_resource_id",
                     resources.ids[kAPlaneResourceIdIndex]);
   value->SetBoolean("require_overlay", require_overlay);
-  value->SetBoolean("is_protected_video", is_protected_video);
+  value->SetInteger("protected_video_type",
+                    static_cast<int>(protected_video_type));
 }
 
 }  // namespace viz

components/viz/common/quads/yuv_video_draw_quad.h

@@ -14,6 +14,7 @@
 #include "ui/gfx/color_space.h"
 #include "ui/gfx/geometry/rect_f.h"
 #include "ui/gfx/geometry/size.h"
+#include "ui/gl/dc_renderer_layer_params.h"
 
 namespace viz {
 
@@ -71,7 +72,7 @@ class VIZ_COMMON_EXPORT YUVVideoDrawQuad : public DrawQuad {
               float multiplier,
               uint32_t bits_per_channel,
               bool require_overlay,
-              bool is_protected_video);
+              ui::ProtectedVideoType protected_video_type);
 
   gfx::RectF ya_tex_coord_rect;
   gfx::RectF uv_tex_coord_rect;
@@ -83,7 +84,7 @@ class VIZ_COMMON_EXPORT YUVVideoDrawQuad : public DrawQuad {
   // TODO(hubbe): Move to ResourceProvider::ScopedSamplerGL.
   gfx::ColorSpace video_color_space;
   bool require_overlay = false;
-  bool is_protected_video = false;
+  ui::ProtectedVideoType protected_video_type = ui::ProtectedVideoType::kClear;
 
   static const YUVVideoDrawQuad* MaterialCast(const DrawQuad*);
 

components/viz/service/display/dc_layer_overlay.cc

@@ -31,13 +31,10 @@ DCLayerOverlayProcessor::DCLayerResult FromYUVQuad(
   dc_layer_overlay->filter = GL_LINEAR;
   dc_layer_overlay->color_space = quad->video_color_space;
   dc_layer_overlay->require_overlay = quad->require_overlay;
-  if (quad->is_protected_video) {
-    dc_layer_overlay->protected_video_type =
-        ui::ProtectedVideoType::kHardwareProtected;
-  }
-  // Protected Videos have to go through the overlay swapchain path,
+  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 (dc_layer_overlay->IsProtectedVideo())
+  if (quad->protected_video_type == ui::ProtectedVideoType::kHardwareProtected)
     dc_layer_overlay->require_overlay = true;
 
   return DCLayerOverlayProcessor::DC_LAYER_SUCCESS;

media/base/video_frame_metadata.h

@@ -111,9 +111,13 @@ class MEDIA_EXPORT VideoFrameMetadata {
     // notified about its promotability to an overlay.
     WANTS_PROMOTION_HINT,
 
-    // Windows only: this video has protected content.
+    // This video frame comes from protected content.
     PROTECTED_VIDEO,
 
+    // Windows only: this video frame is protected by hardware. This option is
+    // valid if PROTECTED_VIDEO is also set to true.
+    HW_PROTECTED,
+
     // Whether this frame was decoded in a power efficient way.
     POWER_EFFICIENT,
 

media/gpu/windows/d3d11_video_decoder.cc

@@ -575,8 +575,10 @@ void D3D11VideoDecoder::OutputResult(const CodecPicture* picture,
   // that ALLOW_OVERLAY is required for encrypted video path.
   frame->metadata()->SetBoolean(VideoFrameMetadata::ALLOW_OVERLAY, true);
 
-  if (is_encrypted_)
+  if (is_encrypted_) {
     frame->metadata()->SetBoolean(VideoFrameMetadata::PROTECTED_VIDEO, true);
+    frame->metadata()->SetBoolean(VideoFrameMetadata::HW_PROTECTED, true);
+  }
 
   frame->set_color_space(picture->get_colorspace().ToGfxColorSpace());
   output_cb_.Run(frame);

media/renderers/video_resource_updater.cc

@@ -479,8 +479,15 @@ void VideoResourceUpdater::AppendQuads(viz::RenderPass* render_pass,
           frame_resources_.size() > 3 ? frame_resources_[3].id : 0,
           frame->ColorSpace(), frame_resource_offset_,
           frame_resource_multiplier_, frame_bits_per_channel_);
-      yuv_video_quad->is_protected_video =
-          frame->metadata()->IsTrue(VideoFrameMetadata::PROTECTED_VIDEO);
+      if (frame->metadata()->IsTrue(VideoFrameMetadata::PROTECTED_VIDEO)) {
+        if (frame->metadata()->IsTrue(VideoFrameMetadata::HW_PROTECTED)) {
+          yuv_video_quad->protected_video_type =
+              ui::ProtectedVideoType::kHardwareProtected;
+        } else {
+          yuv_video_quad->protected_video_type =
+              ui::ProtectedVideoType::kSoftwareProtected;
+        }
+      }
 
       for (viz::ResourceId resource_id : yuv_video_quad->resources) {
         resource_provider_->ValidateResource(resource_id);

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

@@ -175,7 +175,8 @@ bool StructTraits<viz::mojom::YUVVideoQuadStateDataView, viz::DrawQuad>::Read(
       !data.ReadUvTexCoordRect(&quad->uv_tex_coord_rect) ||
       !data.ReadYaTexSize(&quad->ya_tex_size) ||
       !data.ReadUvTexSize(&quad->uv_tex_size) ||
-      !data.ReadVideoColorSpace(&quad->video_color_space)) {
+      !data.ReadVideoColorSpace(&quad->video_color_space) ||
+      !data.ReadProtectedVideoType(&quad->protected_video_type)) {
     return false;
   }
   quad->resources.ids[viz::YUVVideoDrawQuad::kYPlaneResourceIdIndex] =
@@ -199,7 +200,6 @@ bool StructTraits<viz::mojom::YUVVideoQuadStateDataView, viz::DrawQuad>::Read(
     return false;
   }
   quad->require_overlay = data.require_overlay();
-  quad->is_protected_video = data.is_protected_video();
   return true;
 }
 

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

@@ -30,6 +30,39 @@ viz::DrawQuad* AllocateAndConstruct(
     viz::mojom::DrawQuadStateDataView::Tag material,
     viz::QuadList* list);
 
+template <>
+struct EnumTraits<viz::mojom::ProtectedVideoState, ui::ProtectedVideoType> {
+  static viz::mojom::ProtectedVideoState ToMojom(ui::ProtectedVideoType input) {
+    switch (input) {
+      case ui::ProtectedVideoType::kClear:
+        return viz::mojom::ProtectedVideoState::kClear;
+      case ui::ProtectedVideoType::kHardwareProtected:
+        return viz::mojom::ProtectedVideoState::kHardwareProtected;
+      case ui::ProtectedVideoType::kSoftwareProtected:
+        return viz::mojom::ProtectedVideoState::kSoftwareProtected;
+    }
+    NOTREACHED();
+    return viz::mojom::ProtectedVideoState::kClear;
+  }
+
+  static bool FromMojom(viz::mojom::ProtectedVideoState input,
+                        ui::ProtectedVideoType* out) {
+    switch (input) {
+      case viz::mojom::ProtectedVideoState::kClear:
+        *out = ui::ProtectedVideoType::kClear;
+        return true;
+      case viz::mojom::ProtectedVideoState::kHardwareProtected:
+        *out = ui::ProtectedVideoType::kHardwareProtected;
+        return true;
+      case viz::mojom::ProtectedVideoState::kSoftwareProtected:
+        *out = ui::ProtectedVideoType::kSoftwareProtected;
+        return true;
+    }
+    NOTREACHED();
+    return false;
+  }
+};
+
 template <>
 struct UnionTraits<viz::mojom::DrawQuadStateDataView, viz::DrawQuad> {
   static viz::mojom::DrawQuadStateDataView::Tag GetTag(
@@ -449,12 +482,12 @@ struct StructTraits<viz::mojom::YUVVideoQuadStateDataView, viz::DrawQuad> {
         viz::YUVVideoDrawQuad::MaterialCast(&input);
     return quad->require_overlay;
   }
-  static bool is_protected_video(const viz::DrawQuad& input) {
+  static ui::ProtectedVideoType protected_video_type(
+      const viz::DrawQuad& input) {
     const viz::YUVVideoDrawQuad* quad =
         viz::YUVVideoDrawQuad::MaterialCast(&input);
-    return quad->is_protected_video;
+    return quad->protected_video_type;
   }
-
   static bool Read(viz::mojom::YUVVideoQuadStateDataView data,
                    viz::DrawQuad* out);
 };

services/viz/public/cpp/compositing/render_pass.typemap

@@ -6,6 +6,7 @@ mojom = "//services/viz/public/interfaces/compositing/render_pass.mojom"
 public_headers = [
   "//components/viz/common/quads/draw_quad.h",
   "//components/viz/common/quads/render_pass.h",
+  "//ui/gl/dc_renderer_layer_params.h",
 ]
 traits_headers = [
   "//services/viz/public/cpp/compositing/quads_struct_traits.h",
@@ -15,4 +16,7 @@ sources = [
   "//services/viz/public/cpp/compositing/quads_struct_traits.cc",
   "//services/viz/public/cpp/compositing/render_pass_struct_traits.cc",
 ]
-type_mappings = [ "viz.mojom.RenderPass=std::unique_ptr<viz::RenderPass>[move_only,nullable_is_same_type]" ]
+type_mappings = [
+  "viz.mojom.RenderPass=std::unique_ptr<viz::RenderPass>[move_only,nullable_is_same_type]",
+  "viz::mojom::ProtectedVideoState=ui::ProtectedVideoType",
+]

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

@@ -1125,7 +1125,8 @@ TEST_F(StructTraitsTest, YUVDrawQuad) {
   const float resource_multiplier = 1234.6f;
   const uint32_t bits_per_channel = 13;
   const bool require_overlay = true;
-  const bool is_protected_video = true;
+  const ui::ProtectedVideoType protected_video_type =
+      ui::ProtectedVideoType::kSoftwareProtected;
 
   SharedQuadState* sqs = render_pass->CreateAndAppendSharedQuadState();
   YUVVideoDrawQuad* quad =
@@ -1134,7 +1135,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, is_protected_video);
+               bits_per_channel, require_overlay, protected_video_type);
 
   std::unique_ptr<RenderPass> output;
   mojo::test::SerializeAndDeserialize<mojom::RenderPass>(&render_pass, &output);
@@ -1159,7 +1160,7 @@ TEST_F(StructTraitsTest, YUVDrawQuad) {
   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(is_protected_video, out_quad->is_protected_video);
+  EXPECT_EQ(protected_video_type, out_quad->protected_video_type);
 }
 
 TEST_F(StructTraitsTest, CopyOutputResult_Empty) {

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

@@ -84,6 +84,12 @@ struct TileQuadState {
   bool force_anti_aliasing_off;
 };
 
+enum ProtectedVideoState {
+  kClear,
+  kSoftwareProtected,
+  kHardwareProtected,
+};
+
 struct YUVVideoQuadState {
   gfx.mojom.RectF ya_tex_coord_rect;
   gfx.mojom.RectF uv_tex_coord_rect;
@@ -98,7 +104,7 @@ struct YUVVideoQuadState {
   uint32 bits_per_channel;
   gfx.mojom.ColorSpace video_color_space;
   bool require_overlay;
-  bool is_protected_video;
+  ProtectedVideoState protected_video_type;
 };
 
 union DrawQuadState {