Quirks: Add plumbing for hole-punch testing

philn · philn · commit 21ed25200d1d · 2024-03-29T14:34:06.000Z
diff --git a/LayoutTests/platform/wpe/media/video-punch-hole-expected.txt b/LayoutTests/platform/wpe/media/video-punch-hole-expected.txt
@@ -0,0 +1,21 @@
+
+(GraphicsLayer
+  (anchor 0.00 0.00)
+  (bounds 1288.00 807.00)
+  (children 1
+    (GraphicsLayer
+      (bounds 1288.00 807.00)
+      (contentsOpaque 1)
+      (children 1
+        (GraphicsLayer
+          (position 8.00 8.00)
+          (bounds 1280.00 720.00)
+        )
+      )
+    )
+  )
+)
+RUN(internals.enableGStreamerHolePunching(video))
+RUN(video.src = findMediaFile('video', '../../../media/content/test'))
+RUN(video.play())
+
diff --git a/LayoutTests/platform/wpe/media/video-punch-hole.html b/LayoutTests/platform/wpe/media/video-punch-hole.html
@@ -0,0 +1,27 @@
+<!DOCTYPE html>
+<html>
+<head>
+    <script src="../../../media/media-file.js"></script>
+    <script src="../../../media/video-test.js"></script>
+    <script>
+    function dumpLayers()
+    {
+        if (window.testRunner) {
+            document.getElementById('outText').textContent = window.internals.layerTreeAsText(document);
+            testRunner.notifyDone();
+        }
+    }
+    window.addEventListener('load', async event => {
+        findMediaElement();
+        run("internals.enableGStreamerHolePunching(video)");
+        run("video.src = findMediaFile('video', '../../../media/content/test')");
+        run("video.play()");
+        setTimeout(dumpLayers, 500);
+    });
+    </script>
+</head>
+<body>
+    <video></video>
+    <pre id="outText"></pre>
+</body>
+</html>
diff --git a/Source/WebCore/html/HTMLVideoElement.h b/Source/WebCore/html/HTMLVideoElement.h
@@ -119,6 +119,11 @@ class HTMLVideoElement final : public HTMLMediaElement, public Supplementable<HT
     unsigned requestVideoFrameCallback(Ref<VideoFrameRequestCallback>&&);
     void cancelVideoFrameCallback(unsigned);
 
+#if USE(GSTREAMER)
+    void enableGStreamerHolePunching() { m_enableGStreamerHolePunching = true; }
+    bool isGStreamerHolePunchingEnabled() const final { return m_enableGStreamerHolePunching; }
+#endif
+
 private:
     HTMLVideoElement(const QualifiedName&, Document&, bool createdByParser);
 
@@ -175,6 +180,10 @@ class HTMLVideoElement final : public HTMLMediaElement, public Supplementable<HT
     Vector<UniqueRef<VideoFrameRequest>> m_videoFrameRequests;
     Vector<UniqueRef<VideoFrameRequest>> m_servicedVideoFrameRequests;
     unsigned m_nextVideoFrameRequestIndex { 0 };
+
+#if USE(GSTREAMER)
+    bool m_enableGStreamerHolePunching { false };
+#endif
 };
 
 } // namespace WebCore
diff --git a/Source/WebCore/platform/graphics/MediaPlayer.cpp b/Source/WebCore/platform/graphics/MediaPlayer.cpp
@@ -1625,6 +1625,11 @@ void MediaPlayer::simulateAudioInterruption()
 
     m_private->simulateAudioInterruption();
 }
+
+bool MediaPlayer::isGStreamerHolePunchingEnabled()
+{
+    return client().isGStreamerHolePunchingEnabled();
+}
 #endif
 
 void MediaPlayer::beginSimulatedHDCPError()
diff --git a/Source/WebCore/platform/graphics/MediaPlayer.h b/Source/WebCore/platform/graphics/MediaPlayer.h
@@ -295,6 +295,8 @@ class MediaPlayerClient {
 
     virtual bool mediaPlayerShouldDisableHDR() const { return false; }
 
+    virtual bool isGStreamerHolePunchingEnabled() const { return false; }
+
 #if !RELEASE_LOG_DISABLED
     virtual const void* mediaPlayerLogIdentifier() { return nullptr; }
     virtual const Logger& mediaPlayerLogger() = 0;
@@ -620,6 +622,7 @@ class WEBCORE_EXPORT MediaPlayer : public MediaPlayerEnums, public ThreadSafeRef
 
 #if USE(GSTREAMER)
     void simulateAudioInterruption();
+    bool isGStreamerHolePunchingEnabled();
 #endif
 
     void beginSimulatedHDCPError();
diff --git a/Source/WebCore/platform/graphics/gstreamer/MediaPlayerPrivateGStreamer.cpp b/Source/WebCore/platform/graphics/gstreamer/MediaPlayerPrivateGStreamer.cpp
@@ -189,6 +189,11 @@ MediaPlayerPrivateGStreamer::MediaPlayerPrivateGStreamer(MediaPlayer* player)
 #endif
     m_isPlayerShuttingDown.store(false);
 
+    if (player->isGStreamerHolePunchingEnabled()) {
+        m_quirksManagerForTesting = GStreamerQuirksManager::createForTesting();
+        m_quirksManagerForTesting->setHolePunchEnabledForTesting(true);
+    }
+
 #if USE(TEXTURE_MAPPER_GL) && USE(NICOSIA)
     m_nicosiaLayer = Nicosia::ContentLayer::create(Nicosia::ContentLayerTextureMapperImpl::createFactory(*this,
         [&]() -> Ref<TextureMapperPlatformLayerProxy> {
@@ -4015,14 +4020,19 @@ GstElement* MediaPlayerPrivateGStreamer::createVideoSinkGL()
 }
 #endif // USE(GSTREAMER_GL)
 
-static void setRectangleToVideoSink(GstElement* videoSink, const IntRect& rect)
+static void setRectangleToVideoSink(GStreamerQuirksManager* quirksManagerForTesting, GstElement* videoSink, const IntRect& rect)
 {
     // Here goes the platform-dependant code to set to the videoSink the size
     // and position of the video rendering window.
 
     if (!videoSink)
         return;
 
+    if (quirksManagerForTesting) {
+        quirksManagerForTesting->setHolePunchVideoRectangle(videoSink, rect);
+        return;
+    }
+
     auto& quirksManager = GStreamerQuirksManager::singleton();
     quirksManager.setHolePunchVideoRectangle(videoSink, rect);
 }
@@ -4037,6 +4047,8 @@ class GStreamerHolePunchClient : public TextureMapperPlatformLayerBuffer::HolePu
 
 bool MediaPlayerPrivateGStreamer::isHolePunchRenderingEnabled() const
 {
+    if (m_quirksManagerForTesting)
+        return m_quirksManagerForTesting->supportsVideoHolePunchRendering();
     auto& quirksManager = GStreamerQuirksManager::singleton();
     return quirksManager.supportsVideoHolePunchRendering();
 }
@@ -4046,8 +4058,11 @@ GstElement* MediaPlayerPrivateGStreamer::createHolePunchVideoSink()
     if (!isHolePunchRenderingEnabled())
         return nullptr;
 
-    auto& quirksManager = GStreamerQuirksManager::singleton();
-    auto sink = quirksManager.createHolePunchVideoSink(m_isLegacyPlaybin, m_player);
+    GstElement* sink = nullptr;
+    if (m_quirksManagerForTesting)
+        sink = m_quirksManagerForTesting->createHolePunchVideoSink(m_isLegacyPlaybin, m_player);
+    else
+        sink = GStreamerQuirksManager::singleton().createHolePunchVideoSink(m_isLegacyPlaybin, m_player);
 
     // Configure sink before it allocates resources.
     if (sink)
@@ -4085,7 +4100,7 @@ void MediaPlayerPrivateGStreamer::setVideoRectangle(const IntRect& rect)
     Locker locker { m_holePunchLock };
 
     if (m_visible && !m_suspended)
-        setRectangleToVideoSink(m_videoSink.get(), rect);
+        setRectangleToVideoSink(m_quirksManagerForTesting.get(), m_videoSink.get(), rect);
 }
 
 bool MediaPlayerPrivateGStreamer::shouldIgnoreIntrinsicSize()
@@ -4463,7 +4478,7 @@ void MediaPlayerPrivateGStreamer::setPageIsVisible(bool visible)
         m_visible = visible;
 
         if (!m_visible)
-            setRectangleToVideoSink(m_videoSink.get(), IntRect());
+            setRectangleToVideoSink(m_quirksManagerForTesting.get(), m_videoSink.get(), IntRect());
     }
 }
 
@@ -4475,7 +4490,7 @@ void MediaPlayerPrivateGStreamer::setPageIsSuspended(bool suspended)
         m_suspended = suspended;
 
         if (m_suspended)
-            setRectangleToVideoSink(m_videoSink.get(), IntRect());
+            setRectangleToVideoSink(m_quirksManagerForTesting.get(), m_videoSink.get(), IntRect());
     }
 }
 
diff --git a/Source/WebCore/platform/graphics/gstreamer/MediaPlayerPrivateGStreamer.h b/Source/WebCore/platform/graphics/gstreamer/MediaPlayerPrivateGStreamer.h
@@ -29,6 +29,7 @@
 #include "AbortableTaskQueue.h"
 #include "GStreamerCommon.h"
 #include "GStreamerEMEUtilities.h"
+#include "GStreamerQuirks.h"
 #include "ImageOrientation.h"
 #include "Logging.h"
 #include "MainThreadNotifier.h"
@@ -673,6 +674,8 @@ class MediaPlayerPrivateGStreamer : public MediaPlayerPrivateInterface
     // Specific to MediaStream playback.
     MediaTime m_startTime;
     MediaTime m_pausedTime;
+
+    RefPtr<GStreamerQuirksManager> m_quirksManagerForTesting;
 };
 
 }
diff --git a/Source/WebCore/platform/gstreamer/GStreamerQuirks.cpp b/Source/WebCore/platform/gstreamer/GStreamerQuirks.cpp
@@ -43,20 +43,28 @@ GST_DEBUG_CATEGORY_STATIC(webkit_quirks_debug);
 
 GStreamerQuirksManager& GStreamerQuirksManager::singleton()
 {
-    static NeverDestroyed<GStreamerQuirksManager> sharedInstance;
+    static NeverDestroyed<GStreamerQuirksManager> sharedInstance(false, true);
     return sharedInstance;
 }
 
-GStreamerQuirksManager::GStreamerQuirksManager()
+GStreamerQuirksManager::GStreamerQuirksManager(bool isForTesting, bool loadQuirksFromEnvironment)
+    : m_isForTesting(isForTesting)
 {
-    GST_DEBUG_CATEGORY_INIT(webkit_quirks_debug, "webkitquirks", 0, "WebKit Quirks");
+    static std::once_flag debugRegisteredFlag;
+    std::call_once(debugRegisteredFlag, [] {
+        GST_DEBUG_CATEGORY_INIT(webkit_quirks_debug, "webkitquirks", 0, "WebKit Quirks");
+    });
 
     // For the time being keep this disabled on non-WPE platforms. GTK on desktop shouldn't require
     // quirks, for instance.
 #if !PLATFORM(WPE)
     return;
 #endif
 
+    GST_DEBUG("Quirk manager created%s", m_isForTesting ? " for testing." : ".");
+    if (!loadQuirksFromEnvironment)
+        return;
+
     const char* quirksListFromEnvironment = g_getenv("WEBKIT_GST_QUIRKS");
     StringBuilder quirksListBuilder;
     if (quirksListFromEnvironment)
@@ -235,6 +243,14 @@ Vector<String> GStreamerQuirksManager::disallowedWebAudioDecoders() const
     return result;
 }
 
+void GStreamerQuirksManager::setHolePunchEnabledForTesting(bool enabled)
+{
+    if (enabled)
+        m_holePunchQuirk = WTF::makeUnique<GStreamerHolePunchQuirkFake>();
+    else
+        m_holePunchQuirk = nullptr;
+}
+
 #undef GST_CAT_DEFAULT
 
 } // namespace WebCore
diff --git a/Source/WebCore/platform/gstreamer/GStreamerQuirks.h b/Source/WebCore/platform/gstreamer/GStreamerQuirks.h
@@ -25,6 +25,7 @@
 #include "GRefPtrGStreamer.h"
 #include "MediaPlayer.h"
 #include <wtf/Forward.h>
+#include <wtf/RefCounted.h>
 #include <wtf/Vector.h>
 
 namespace WebCore {
@@ -70,13 +71,18 @@ class GStreamerHolePunchQuirk : public GStreamerQuirkBase {
     virtual bool setHolePunchVideoRectangle(GstElement*, const IntRect&) { return false; }
 };
 
-class GStreamerQuirksManager {
+class GStreamerQuirksManager : public RefCounted<GStreamerQuirksManager> {
     friend NeverDestroyed<GStreamerQuirksManager>;
     WTF_MAKE_FAST_ALLOCATED;
 
 public:
     static GStreamerQuirksManager& singleton();
 
+    static RefPtr<GStreamerQuirksManager> createForTesting()
+    {
+        return adoptRef(*new GStreamerQuirksManager(true, false));
+    }
+
     bool isEnabled() const;
 
     GstElement* createWebAudioSink();
@@ -89,11 +95,14 @@ class GStreamerQuirksManager {
     GstElement* createHolePunchVideoSink(bool isLegacyPlaybin, const MediaPlayer*);
     void setHolePunchVideoRectangle(GstElement*, const IntRect&);
 
+    void setHolePunchEnabledForTesting(bool);
+
 private:
-    GStreamerQuirksManager();
+    GStreamerQuirksManager(bool, bool);
 
     Vector<std::unique_ptr<GStreamerQuirk>> m_quirks;
     std::unique_ptr<GStreamerHolePunchQuirk> m_holePunchQuirk;
+    bool m_isForTesting { false };
 };
 
 } // namespace WebCore
diff --git a/Source/WebCore/testing/Internals.cpp b/Source/WebCore/testing/Internals.cpp
@@ -4116,6 +4116,15 @@ ExceptionOr<void> Internals::setOverridePreferredDynamicRangeMode(HTMLMediaEleme
     return { };
 }
 
+void Internals::enableGStreamerHolePunching(HTMLVideoElement& element)
+{
+#if USE(GSTREAMER)
+    element.enableGStreamerHolePunching();
+#else
+    UNUSED_PARAM(element);
+#endif
+}
+
 #endif
 
 bool Internals::isSelectPopupVisible(HTMLSelectElement& element)
diff --git a/Source/WebCore/testing/Internals.h b/Source/WebCore/testing/Internals.h
@@ -705,6 +705,8 @@ class Internals final : public RefCounted<Internals>, private ContextDestruction
     double elementEffectivePlaybackRate(const HTMLMediaElement&);
 
     ExceptionOr<void> setOverridePreferredDynamicRangeMode(HTMLMediaElement&, const String&);
+
+    void enableGStreamerHolePunching(HTMLVideoElement&);
 #endif
 
     ExceptionOr<void> setIsPlayingToBluetoothOverride(std::optional<bool>);
diff --git a/Source/WebCore/testing/Internals.idl b/Source/WebCore/testing/Internals.idl
@@ -776,6 +776,8 @@ typedef (FetchRequest or FetchResponse) FetchObject;
     [Conditional=VIDEO] undefined setOverridePreferredDynamicRangeMode(HTMLMediaElement media, DOMString mode);
     [Conditional=VIDEO] double elementEffectivePlaybackRate(HTMLMediaElement media);
 
+    [Conditional=VIDEO] undefined enableGStreamerHolePunching(HTMLVideoElement element);
+
     undefined setIsPlayingToBluetoothOverride(optional boolean? isPlaying = null);
 
     [Conditional=LEGACY_ENCRYPTED_MEDIA] undefined initializeMockCDM();
