[Rounded Display] Updates mojom traits for TextureDrawQuad.

We added RoundedDisplayMasksInfo property to TextureDrawQuad to plumb
display radii to viz. This CL adds RpimdedDisplayMaskInfo struct to
the mojom traits of TextureDrawQuad.

Bug: 1262970
Test: Covered by unittests
Change-Id: I9193b2791f8043a2d1639fc56ff8204449b8b1de
Reviewed-on: https://chromium-review.googlesource.com/c/chromium/src/+/4305198
Reviewed-by: Emily Stark <estark@chromium.org>
Reviewed-by: Peter McNeeley <petermcneeley@chromium.org>
Commit-Queue: Zoraiz Naeem <zoraiznaeem@chromium.org>
Cr-Commit-Position: refs/heads/main@{#1114838}

components/viz/common/quads/texture_draw_quad.h

@@ -93,7 +93,7 @@ class VIZ_COMMON_EXPORT TextureDrawQuad : public DrawQuad {
   // This optional damage is in target render pass coordinate space.
   absl::optional<gfx::Rect> damage_rect;
 
-  struct RoundedDisplayMasksInfo {
+  struct VIZ_COMMON_EXPORT RoundedDisplayMasksInfo {
     static constexpr size_t kMaxRoundedDisplayMasksCount = 2;
     static constexpr size_t kOriginRoundedDisplayMaskIndex = 0;
     static constexpr size_t kOtherRoundedDisplayMaskIndex = 1;

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

@@ -14,6 +14,7 @@
 #include "components/viz/common/quads/compositor_render_pass.h"
 #include "components/viz/common/quads/debug_border_draw_quad.h"
 #include "components/viz/common/quads/solid_color_draw_quad.h"
+#include "components/viz/common/quads/texture_draw_quad.h"
 #include "components/viz/common/resources/resource_format.h"
 #include "components/viz/common/resources/resource_settings.h"
 #include "components/viz/common/resources/returned_resource.h"
@@ -1046,16 +1047,40 @@ TEST_F(StructTraitsTest, QuadListBasic) {
   const gfx::Rect rect6(321, 765, 11109, 151413);
   const bool needs_blending6 = false;
   const ResourceId resource_id6(1234);
-  const gfx::Size resource_size_in_pixels(1234, 5678);
+  const gfx::Size resource_size_in_pixels6(1234, 5678);
   const float stream_draw_quad_opacity[] = {1, 1, 1, 1};
   TextureDrawQuad* stream_video_draw_quad =
       render_pass->CreateAndAppendDrawQuad<TextureDrawQuad>();
   stream_video_draw_quad->SetAll(
-      sqs, rect6, rect6, needs_blending6, resource_id6, resource_size_in_pixels,
-      false, uv_top_left, uv_bottom_right, SkColors::kTransparent,
-      stream_draw_quad_opacity, false, false, false, protected_video_type);
+      sqs, rect6, rect6, needs_blending6, resource_id6,
+      resource_size_in_pixels6, false, uv_top_left, uv_bottom_right,
+      SkColors::kTransparent, stream_draw_quad_opacity, false, false, false,
+      protected_video_type);
   stream_video_draw_quad->is_stream_video = true;
 
+  // Create a TextureDrawQuad with rounded-display masks.
+  const gfx::Rect rect7(421, 865, 11109, 151413);
+  const bool needs_blending7 = false;
+  const ResourceId resource_id7(4834);
+  const gfx::Size resource_size_in_pixels7(12894, 8878);
+  const float rounded_display_mask_quad_opacity[] = {1.0, 1.5, 1.8, 1.1};
+  const int origin_rounded_display_mask_radius = 10;
+  const int other_rounded_display_mask_radius = 15;
+  const bool is_horizontally_positioned = false;
+
+  TextureDrawQuad* rounded_display_mask_quad =
+      render_pass->CreateAndAppendDrawQuad<TextureDrawQuad>();
+  rounded_display_mask_quad->SetAll(
+      sqs, rect7, rect7, needs_blending7, resource_id7,
+      resource_size_in_pixels7, false, uv_top_left, uv_bottom_right,
+      SkColors::kTransparent, rounded_display_mask_quad_opacity, false, false,
+      false, protected_video_type);
+
+  rounded_display_mask_quad->rounded_display_masks_info =
+      TextureDrawQuad::RoundedDisplayMasksInfo::CreateRoundedDisplayMasksInfo(
+          origin_rounded_display_mask_radius, other_rounded_display_mask_radius,
+          is_horizontally_positioned);
+
   std::unique_ptr<CompositorRenderPass> output;
   mojo::test::SerializeAndDeserialize<mojom::CompositorRenderPass>(render_pass,
                                                                    output);
@@ -1137,10 +1162,33 @@ TEST_F(StructTraitsTest, QuadListBasic) {
   EXPECT_EQ(rect6, out_stream_video_draw_quad->visible_rect);
   EXPECT_EQ(needs_blending6, out_stream_video_draw_quad->needs_blending);
   EXPECT_EQ(resource_id6, out_stream_video_draw_quad->resource_id());
-  EXPECT_EQ(resource_size_in_pixels,
+  EXPECT_EQ(resource_size_in_pixels6,
             out_stream_video_draw_quad->resource_size_in_pixels());
   EXPECT_EQ(uv_top_left, out_stream_video_draw_quad->uv_top_left);
   EXPECT_EQ(uv_bottom_right, out_stream_video_draw_quad->uv_bottom_right);
+
+  const TextureDrawQuad* out_rounded_display_mask_quad =
+      TextureDrawQuad::MaterialCast(output->quad_list.ElementAt(6));
+  EXPECT_FALSE(out_rounded_display_mask_quad->is_stream_video);
+  EXPECT_EQ(rect7, out_rounded_display_mask_quad->rect);
+  EXPECT_EQ(rect7, out_rounded_display_mask_quad->visible_rect);
+  EXPECT_EQ(needs_blending7, out_rounded_display_mask_quad->needs_blending);
+  EXPECT_EQ(resource_id7, out_rounded_display_mask_quad->resource_id());
+  EXPECT_EQ(resource_size_in_pixels7,
+            out_rounded_display_mask_quad->resource_size_in_pixels());
+  EXPECT_EQ(uv_top_left, out_rounded_display_mask_quad->uv_top_left);
+  EXPECT_EQ(uv_bottom_right, out_rounded_display_mask_quad->uv_bottom_right);
+  EXPECT_EQ(origin_rounded_display_mask_radius,
+            out_rounded_display_mask_quad->rounded_display_masks_info
+                .radii[TextureDrawQuad::RoundedDisplayMasksInfo::
+                           kOriginRoundedDisplayMaskIndex]);
+  EXPECT_EQ(other_rounded_display_mask_radius,
+            out_rounded_display_mask_quad->rounded_display_masks_info
+                .radii[TextureDrawQuad::RoundedDisplayMasksInfo::
+                           kOtherRoundedDisplayMaskIndex]);
+  EXPECT_EQ(is_horizontally_positioned,
+            out_rounded_display_mask_quad->rounded_display_masks_info
+                .is_horizontally_positioned);
 }
 
 TEST_F(StructTraitsTest, SurfaceId) {

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

@@ -63,6 +63,22 @@ viz::DrawQuad* AllocateAndConstruct(
   return nullptr;
 }
 
+// static
+bool StructTraits<viz::mojom::RoundedDisplayMasksInfoDataView,
+                  viz::TextureDrawQuad::RoundedDisplayMasksInfo>::
+    Read(viz::mojom::RoundedDisplayMasksInfoDataView data,
+         viz::TextureDrawQuad::RoundedDisplayMasksInfo* out) {
+  viz::TextureDrawQuad::RoundedDisplayMasksInfo* info =
+      static_cast<viz::TextureDrawQuad::RoundedDisplayMasksInfo*>(out);
+  base::span<uint8_t> radii_array(info->radii);
+  if (!data.ReadRadii(&radii_array)) {
+    return false;
+  }
+
+  info->is_horizontally_positioned = data.is_horizontally_positioned();
+  return true;
+}
+
 // static
 bool StructTraits<viz::mojom::DebugBorderQuadStateDataView, viz::DrawQuad>::
     Read(viz::mojom::DebugBorderQuadStateDataView data, viz::DrawQuad* out) {
@@ -150,7 +166,8 @@ bool StructTraits<viz::mojom::TextureQuadStateDataView, viz::DrawQuad>::Read(
       !data.ReadProtectedVideoType(&protected_video_type) ||
       !data.ReadHdrMode(&quad->hdr_mode) ||
       !data.ReadHdrMetadata(&quad->hdr_metadata) ||
-      !data.ReadOverlayPriorityHint(&overlay_priority_hint)) {
+      !data.ReadOverlayPriorityHint(&overlay_priority_hint) ||
+      !data.ReadRoundedDisplayMasksInfo(&quad->rounded_display_masks_info)) {
     return false;
   }
   quad->protected_video_type = protected_video_type;

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

@@ -110,6 +110,23 @@ struct EnumTraits<viz::mojom::OverlayPriority, viz::OverlayPriority> {
   }
 };
 
+template <>
+struct StructTraits<viz::mojom::RoundedDisplayMasksInfoDataView,
+                    viz::TextureDrawQuad::RoundedDisplayMasksInfo> {
+  static bool is_horizontally_positioned(
+      const viz::TextureDrawQuad::RoundedDisplayMasksInfo& input) {
+    return input.is_horizontally_positioned;
+  }
+
+  static base::span<const uint8_t> radii(
+      const viz::TextureDrawQuad::RoundedDisplayMasksInfo& input) {
+    return input.radii;
+  }
+
+  static bool Read(viz::mojom::RoundedDisplayMasksInfoDataView data,
+                   viz::TextureDrawQuad::RoundedDisplayMasksInfo* out);
+};
+
 template <>
 struct UnionTraits<viz::mojom::DrawQuadStateDataView, viz::DrawQuad> {
   static viz::mojom::DrawQuadStateDataView::Tag GetTag(
@@ -396,6 +413,13 @@ struct StructTraits<viz::mojom::TextureQuadStateDataView, viz::DrawQuad> {
     return quad->resource_size_in_pixels();
   }
 
+  static viz::TextureDrawQuad::RoundedDisplayMasksInfo
+  rounded_display_masks_info(const viz::DrawQuad& input) {
+    const viz::TextureDrawQuad* quad =
+        viz::TextureDrawQuad::MaterialCast(&input);
+    return quad->rounded_display_masks_info;
+  }
+
   static bool premultiplied_alpha(const viz::DrawQuad& input) {
     const viz::TextureDrawQuad* quad =
         viz::TextureDrawQuad::MaterialCast(&input);

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

@@ -28,6 +28,11 @@ enum OverlayPriority {
   kRequired
 };
 
+struct RoundedDisplayMasksInfo {
+  bool is_horizontally_positioned;
+  array<uint8, 2> radii;
+};
+
 struct DebugBorderQuadState {
   // Debug border color.
   skia.mojom.SkColor4f color;
@@ -96,6 +101,7 @@ struct TextureQuadState {
   gfx.mojom.HDRMetadata? hdr_metadata;
   gfx.mojom.Rect? damage_rect;
   OverlayPriority overlay_priority_hint;
+  RoundedDisplayMasksInfo rounded_display_masks_info;
 };
 
 struct TileQuadState {