Replace video quad with a transparent quad

The video hole doesn't make practical use of the overlay API. Rather
than pretend to show anything via overlays, just replace the video quad
with a transparent quad.

This also allows the video hole to work with Ozone platforms other than
Cast since the Ozone platform is no longer expected to lie about
supporting the video hole overlay.

Bug: b/74998539
Test: Played video on device
Cq-Include-Trybots: luci.chromium.try:android_optional_gpu_tests_rel
Change-Id: Ia9b63f718d16ab8d933221a3ce551dbbf06b5748
Reviewed-on: https://chromium-review.googlesource.com/970910Reviewed-by: Daniele Castagna <dcastagna@chromium.org>
Reviewed-by: Sadrul Chowdhury <sadrul@chromium.org>
Reviewed-by: Sergey Volk <servolk@chromium.org>
Reviewed-by: Luke Halliwell <halliwell@chromium.org>
Commit-Queue: Daniel Nicoara <dnicoara@chromium.org>
Cr-Commit-Position: refs/heads/master@{#548780}

chromecast/browser/BUILD.gn

@@ -122,6 +122,7 @@ cast_source_set("browser") {
     "//components/network_session_configurator/common",
     "//components/prefs",
     "//components/proxy_config",
+    "//components/viz/service",
     "//content",
     "//content/public/browser",
     "//content/public/common",
@@ -138,6 +139,7 @@ cast_source_set("browser") {
     "//ui/compositor",
     "//ui/display",
     "//ui/events",
+    "//ui/events/devices",
     "//ui/gl",
   ]
 

chromecast/browser/DEPS

@@ -51,4 +51,9 @@ include_rules = [
 
   # TODO(slan): Remove this when the network service is shipped on Cast.
   "+services/network",
+
+  # Needed to insert video plane callback.
+  # TODO(halliwell): Need to re-work this dependency otherwise Cast can't run
+  # with Viz out of process.
+  "+components/viz/service/display/overlay_strategy_underlay_cast.h",
 ]

chromecast/browser/cast_browser_main_parts.cc

@@ -90,8 +90,8 @@
 // callback.
 #include "chromecast/browser/cast_display_configurator.h"
 #include "chromecast/graphics/cast_screen.h"
+#include "components/viz/service/display/overlay_strategy_underlay_cast.h"  // nogncheck
 #include "ui/display/screen.h"
-#include "ui/ozone/platform/cast/overlay_manager_cast.h"  // nogncheck
 #endif
 
 #if BUILDFLAG(ENABLE_CHROMECAST_EXTENSIONS)
@@ -518,9 +518,9 @@ void CastBrowserMainParts::PreMainMessageLoopRun() {
       display::Screen::GetScreen()->GetPrimaryDisplay().GetSizeInPixel();
   video_plane_controller_.reset(new media::VideoPlaneController(
       Size(display_size.width(), display_size.height()), GetMediaTaskRunner()));
-  ui::OverlayManagerCast::SetOverlayCompositedCallback(
-      base::Bind(&media::VideoPlaneController::SetGeometry,
-                 base::Unretained(video_plane_controller_.get())));
+  viz::OverlayStrategyUnderlayCast::SetOverlayCompositedCallback(
+      base::BindRepeating(&media::VideoPlaneController::SetGeometryGfx,
+                          base::Unretained(video_plane_controller_.get())));
 #endif
 
   window_manager_ = CastWindowManager::Create(

chromecast/media/DEPS

@@ -4,4 +4,5 @@ include_rules = [
   "+media/base",
   "+media/cdm",
   "+ui/gfx/geometry",
+  "+ui/gfx/overlay_transform.h",
 ]

chromecast/media/base/BUILD.gn

@@ -106,5 +106,7 @@ cast_source_set("video_plane_controller") {
   deps = [
     "//base",
     "//chromecast/media:libcast_media",
+    "//ui/gfx",
+    "//ui/gfx/geometry",
   ]
 }

chromecast/media/base/video_plane_controller.cc

@@ -38,6 +38,30 @@ bool ResolutionSizeValid(const Size& s) {
   return s.width >= 0 && s.height >= 0;
 }
 
+// Translates a gfx::OverlayTransform into a VideoPlane::Transform.
+// Could be just a lookup table once we have unit tests for this code
+// to ensure it stays in sync with OverlayTransform.
+chromecast::media::VideoPlane::Transform ConvertTransform(
+    gfx::OverlayTransform transform) {
+  switch (transform) {
+    case gfx::OVERLAY_TRANSFORM_NONE:
+      return chromecast::media::VideoPlane::TRANSFORM_NONE;
+    case gfx::OVERLAY_TRANSFORM_FLIP_HORIZONTAL:
+      return chromecast::media::VideoPlane::FLIP_HORIZONTAL;
+    case gfx::OVERLAY_TRANSFORM_FLIP_VERTICAL:
+      return chromecast::media::VideoPlane::FLIP_VERTICAL;
+    case gfx::OVERLAY_TRANSFORM_ROTATE_90:
+      return chromecast::media::VideoPlane::ROTATE_90;
+    case gfx::OVERLAY_TRANSFORM_ROTATE_180:
+      return chromecast::media::VideoPlane::ROTATE_180;
+    case gfx::OVERLAY_TRANSFORM_ROTATE_270:
+      return chromecast::media::VideoPlane::ROTATE_270;
+    default:
+      NOTREACHED();
+      return chromecast::media::VideoPlane::TRANSFORM_NONE;
+  }
+}
+
 }  // namespace
 
 // Helper class for calling VideoPlane::SetGeometry with rate-limiting.
@@ -155,6 +179,13 @@ VideoPlaneController::VideoPlaneController(
 
 VideoPlaneController::~VideoPlaneController() {}
 
+void VideoPlaneController::SetGeometryGfx(const gfx::RectF& display_rect,
+                                          gfx::OverlayTransform transform) {
+  chromecast::RectF rect(display_rect.x(), display_rect.y(),
+                         display_rect.width(), display_rect.height());
+  SetGeometry(rect, ConvertTransform(transform));
+}
+
 void VideoPlaneController::SetGeometry(const RectF& display_rect,
                                        VideoPlane::Transform transform) {
   DCHECK(thread_checker_.CalledOnValidThread());

chromecast/media/base/video_plane_controller.h

@@ -11,6 +11,8 @@
 #include "base/threading/thread_checker.h"
 #include "chromecast/public/graphics_types.h"
 #include "chromecast/public/video_plane.h"
+#include "ui/gfx/geometry/rect_f.h"
+#include "ui/gfx/overlay_transform.h"
 
 namespace base {
 class SingleThreadTaskRunner;
@@ -36,9 +38,13 @@ class VideoPlaneController {
       const Size& graphics_resolution,
       scoped_refptr<base::SingleThreadTaskRunner> media_task_runner);
   ~VideoPlaneController();
+
   // Sets the video plane geometry in *graphics plane coordinates*. If there is
   // no change to video plane parameters from the last call to this method, it
   // is a no-op.
+  void SetGeometryGfx(const gfx::RectF& display_rect,
+                      gfx::OverlayTransform transform);
+
   void SetGeometry(const RectF& display_rect, VideoPlane::Transform transform);
 
   // Sets physical screen resolution. This must be called at least once when

components/viz/service/display/overlay_strategy_underlay_cast.cc

@@ -5,11 +5,18 @@
 #include "components/viz/service/display/overlay_strategy_underlay_cast.h"
 
 #include "base/containers/adapters.h"
+#include "base/lazy_instance.h"
 #include "components/viz/common/quads/draw_quad.h"
 #include "components/viz/common/quads/solid_color_draw_quad.h"
 #include "ui/gfx/geometry/rect_conversions.h"
 
 namespace viz {
+namespace {
+
+base::LazyInstance<OverlayStrategyUnderlayCast::OverlayCompositedCallback>::
+    DestructorAtExit g_overlay_composited_callback = LAZY_INSTANCE_INITIALIZER;
+
+}  // namespace
 
 OverlayStrategyUnderlayCast::OverlayStrategyUnderlayCast(
     OverlayCandidateValidator* capability_checker)
@@ -23,10 +30,10 @@ bool OverlayStrategyUnderlayCast::Attempt(
     RenderPass* render_pass,
     cc::OverlayCandidateList* candidate_list,
     std::vector<gfx::Rect>* content_bounds) {
-  const QuadList& const_quad_list = render_pass->quad_list;
+  QuadList& quad_list = render_pass->quad_list;
   bool found_underlay = false;
   gfx::Rect content_rect;
-  for (const auto* quad : base::Reversed(const_quad_list)) {
+  for (const auto* quad : base::Reversed(quad_list)) {
     if (cc::OverlayCandidate::IsInvisibleQuad(quad))
       continue;
 
@@ -55,15 +62,37 @@ bool OverlayStrategyUnderlayCast::Attempt(
     }
   }
 
-  const bool result = OverlayStrategyUnderlay::Attempt(
-      output_color_matrix, resource_provider, render_pass, candidate_list,
-      content_bounds);
+  if (found_underlay) {
+    for (auto it = quad_list.begin(); it != quad_list.end(); ++it) {
+      cc::OverlayCandidate candidate;
+      if (!cc::OverlayCandidate::FromDrawQuad(
+              resource_provider, output_color_matrix, *it, &candidate)) {
+        continue;
+      }
+
+      render_pass->quad_list.ReplaceExistingQuadWithOpaqueTransparentSolidColor(
+          it);
+
+      if (!g_overlay_composited_callback.Get().is_null()) {
+        g_overlay_composited_callback.Get().Run(candidate.display_rect,
+                                                candidate.transform);
+      }
+
+      break;
+    }
+  }
+
   DCHECK(content_bounds && content_bounds->empty());
-  DCHECK(result == found_underlay);
   if (found_underlay) {
     content_bounds->push_back(content_rect);
   }
-  return result;
+  return found_underlay;
+}
+
+// static
+void OverlayStrategyUnderlayCast::SetOverlayCompositedCallback(
+    const OverlayCompositedCallback& cb) {
+  g_overlay_composited_callback.Get() = cb;
 }
 
 }  // namespace viz

components/viz/service/display/overlay_strategy_underlay_cast.h

@@ -5,9 +5,11 @@
 #ifndef COMPONENTS_VIZ_SERVICE_DISPLAY_OVERLAY_STRATEGY_UNDERLAY_CAST_H_
 #define COMPONENTS_VIZ_SERVICE_DISPLAY_OVERLAY_STRATEGY_UNDERLAY_CAST_H_
 
+#include "base/callback.h"
 #include "base/macros.h"
 #include "components/viz/service/display/overlay_strategy_underlay.h"
 #include "components/viz/service/viz_service_export.h"
+#include "ui/gfx/overlay_transform.h"
 
 namespace viz {
 
@@ -27,6 +29,13 @@ class VIZ_SERVICE_EXPORT OverlayStrategyUnderlayCast
                cc::OverlayCandidateList* candidate_list,
                std::vector<gfx::Rect>* content_bounds) override;
 
+  // Callback that's made whenever an overlay quad is processed in the
+  // compositor. Used to allow hardware video plane to be positioned to match
+  // compositor hole.
+  using OverlayCompositedCallback =
+      base::RepeatingCallback<void(const gfx::RectF&, gfx::OverlayTransform)>;
+  static void SetOverlayCompositedCallback(const OverlayCompositedCallback& cb);
+
  private:
   DISALLOW_COPY_AND_ASSIGN(OverlayStrategyUnderlayCast);
 };

ui/ozone/platform/cast/overlay_manager_cast.cc

@@ -4,72 +4,18 @@
 
 #include "ui/ozone/platform/cast/overlay_manager_cast.h"
 
-#include "base/lazy_instance.h"
-#include "base/memory/ptr_util.h"
-#include "ui/gfx/geometry/rect_conversions.h"
 #include "ui/ozone/public/overlay_candidates_ozone.h"
 
 namespace ui {
 namespace {
 
-base::LazyInstance<OverlayManagerCast::OverlayCompositedCallback>::
-    DestructorAtExit g_overlay_composited_callback = LAZY_INSTANCE_INITIALIZER;
-
-// Translates a gfx::OverlayTransform into a VideoPlane::Transform.
-// Could be just a lookup table once we have unit tests for this code
-// to ensure it stays in sync with OverlayTransform.
-chromecast::media::VideoPlane::Transform ConvertTransform(
-    gfx::OverlayTransform transform) {
-  switch (transform) {
-    case gfx::OVERLAY_TRANSFORM_NONE:
-      return chromecast::media::VideoPlane::TRANSFORM_NONE;
-    case gfx::OVERLAY_TRANSFORM_FLIP_HORIZONTAL:
-      return chromecast::media::VideoPlane::FLIP_HORIZONTAL;
-    case gfx::OVERLAY_TRANSFORM_FLIP_VERTICAL:
-      return chromecast::media::VideoPlane::FLIP_VERTICAL;
-    case gfx::OVERLAY_TRANSFORM_ROTATE_90:
-      return chromecast::media::VideoPlane::ROTATE_90;
-    case gfx::OVERLAY_TRANSFORM_ROTATE_180:
-      return chromecast::media::VideoPlane::ROTATE_180;
-    case gfx::OVERLAY_TRANSFORM_ROTATE_270:
-      return chromecast::media::VideoPlane::ROTATE_270;
-    default:
-      NOTREACHED();
-      return chromecast::media::VideoPlane::TRANSFORM_NONE;
-  }
-}
-
 class OverlayCandidatesCast : public OverlayCandidatesOzone {
  public:
   OverlayCandidatesCast() {}
 
-  void CheckOverlaySupport(OverlaySurfaceCandidateList* surfaces) override;
+  void CheckOverlaySupport(OverlaySurfaceCandidateList* surfaces) override {}
 };
 
-void OverlayCandidatesCast::CheckOverlaySupport(
-    OverlaySurfaceCandidateList* surfaces) {
-  for (auto& candidate : *surfaces) {
-    if (candidate.plane_z_order != -1)
-      continue;
-
-    candidate.overlay_handled = true;
-
-    // Compositor requires all overlay rectangles to have integer coords.
-    candidate.display_rect =
-        gfx::RectF(gfx::ToEnclosedRect(candidate.display_rect));
-
-    chromecast::RectF display_rect(
-        candidate.display_rect.x(), candidate.display_rect.y(),
-        candidate.display_rect.width(), candidate.display_rect.height());
-
-    // Update video plane geometry + transform to match compositor quad.
-    if (!g_overlay_composited_callback.Get().is_null())
-      g_overlay_composited_callback.Get().Run(
-          display_rect, ConvertTransform(candidate.transform));
-    return;
-  }
-}
-
 }  // namespace
 
 OverlayManagerCast::OverlayManagerCast() {
@@ -83,10 +29,4 @@ OverlayManagerCast::CreateOverlayCandidates(gfx::AcceleratedWidget w) {
   return std::make_unique<OverlayCandidatesCast>();
 }
 
-// static
-void OverlayManagerCast::SetOverlayCompositedCallback(
-    const OverlayCompositedCallback& cb) {
-  g_overlay_composited_callback.Get() = cb;
-}
-
 }  // namespace ui

ui/ozone/platform/cast/overlay_manager_cast.h

@@ -7,16 +7,12 @@
 
 #include <memory>
 
-#include "base/callback.h"
 #include "base/macros.h"
-#include "chromecast/public/graphics_types.h"
-#include "chromecast/public/video_plane.h"
-#include "ui/ozone/ozone_export.h"
 #include "ui/ozone/public/overlay_manager_ozone.h"
 
 namespace ui {
 
-class OZONE_EXPORT OverlayManagerCast : public OverlayManagerOzone {
+class OverlayManagerCast : public OverlayManagerOzone {
  public:
   OverlayManagerCast();
   ~OverlayManagerCast() override;
@@ -25,16 +21,7 @@ class OZONE_EXPORT OverlayManagerCast : public OverlayManagerOzone {
   std::unique_ptr<OverlayCandidatesOzone> CreateOverlayCandidates(
       gfx::AcceleratedWidget w) override;
 
-  // Callback that's made whenever an overlay quad is processed
-  // in the compositor.  Used to allow hardware video plane to
-  // be positioned to match compositor hole.
-  using OverlayCompositedCallback =
-      base::Callback<void(const chromecast::RectF&,
-                          chromecast::media::VideoPlane::Transform)>;
-  static void SetOverlayCompositedCallback(const OverlayCompositedCallback& cb);
-
  private:
-
   DISALLOW_COPY_AND_ASSIGN(OverlayManagerCast);
 };