REGRESSION(278304@main): Caused lower numbers on canvas sub-tests whe…

…n rerunning MotionMark

https://bugs.webkit.org/show_bug.cgi?id=274193
rdar://128019812

Unreviewed: This reverts commit 78038e7.

Canvas tests fall back to unaccelerated rendering when rerunning MotionMark.

Canonical link: https://commits.webkit.org/278790@main

LayoutTests/platform/glib/TestExpectations

@@ -2989,9 +2989,6 @@ media/track/in-band/track-in-band-kate-ogg-kind.html [ Skip ]
 media/track/in-band/track-in-band-kate-ogg-language.html [ Skip ]
 media/track/in-band/track-in-band-kate-ogg-track-order.html [ Skip ]
 
-# This only works with GPU process.
-fast/canvas/image-buffer-backend-count-limit.html [ Skip ]
-
 #////////////////////////////////////////////////////////////////////////////////////////
 # End of UNSUPPORTED tests.
 #////////////////////////////////////////////////////////////////////////////////////////

LayoutTests/platform/mac-wk1/TestExpectations

@@ -2825,6 +2825,3 @@ http/tests/media/hls/hls-webvtt-style.html [ Pass Timeout ]
 [ Ventura Debug ] imported/w3c/web-platform-tests/html/semantics/embedded-content/media-elements/track/track-element/track-mode.html [ Skip ]
 
 webkit.org/b/273577 [ Ventura ] http/tests/media/hls/track-webvtt-multitracks.html [ Skip ]
-
-# Limiting accelerated canvases not implemented for WK1
-fast/canvas/image-buffer-backend-count-limit.html [ Skip ]

LayoutTests/platform/wincairo/TestExpectations

@@ -416,9 +416,6 @@ webgl/webgl-worker.html [ Skip ]
 # Accelerated canvas isn't supported yet
 fast/canvas/canvas-will-read-frequently.html [ Skip ]
 
-# Limiting accelerated canvases not implemented for WK1
-fast/canvas/image-buffer-backend-count-limit.html [ Skip ]
-
 #//////////////////////////////////////////////////////////////////////////////////////////
 # These areas are not implemented well on WinCairo
 #//////////////////////////////////////////////////////////////////////////////////////////

Source/WebKit/GPUProcess/RemoteSharedResourceCache.cpp

@@ -31,20 +31,6 @@
 namespace WebKit {
 using namespace WebCore;
 
-// Per GPU process limit of accelerated image buffers.
-// These consume limited global OS resources.
-constexpr size_t acceleratedImageBufferGlobalLimit = 30000;
-
-// Per GPU process count of current accelerated image buffers.
-static std::atomic<size_t> acceleratedImageBufferGlobalCount;
-
-// Per WebContent process limit of accelerated image buffers.
-constexpr size_t acceleratedImageBufferLimit = 5000;
-
-// Per WebContent process limit of accelerated image buffers for 2d context.
-// It is most common to leak 2d contexts.
-constexpr size_t acceleratedImageBuffer2DContextLimit = 1000;
-
 constexpr Seconds defaultRemoteSharedResourceCacheTimeout = 15_s;
 
 Ref<RemoteSharedResourceCache> RemoteSharedResourceCache::create()
@@ -71,30 +57,6 @@ void RemoteSharedResourceCache::releaseSerializedImageBuffer(WebCore::RenderingR
     m_serializedImageBuffers.remove({ { identifier, 0 }, 0 });
 }
 
-void RemoteSharedResourceCache::didAddAcceleratedImageBuffer()
-{
-    ++acceleratedImageBufferGlobalCount;
-    ++m_acceleratedImageBufferCount;
-}
-
-void RemoteSharedResourceCache::didTakeAcceleratedImageBuffer()
-{
-    --acceleratedImageBufferGlobalCount;
-    --m_acceleratedImageBufferCount;
-}
-
-WebCore::RenderingMode RemoteSharedResourceCache::adjustAcceleratedImageBufferRenderingMode(RenderingPurpose renderingPurpose) const
-{
-    // These are naturally racy, but the limits are heuristic in nature.
-    if (acceleratedImageBufferGlobalCount >= acceleratedImageBufferGlobalLimit)
-        return RenderingMode::Unaccelerated;
-    if (m_acceleratedImageBufferCount >= acceleratedImageBufferLimit)
-        return RenderingMode::Unaccelerated;
-    if (renderingPurpose == RenderingPurpose::Canvas && m_acceleratedImageBufferCount >= acceleratedImageBuffer2DContextLimit)
-        return RenderingMode::Unaccelerated;
-    return RenderingMode::Accelerated;
-}
-
 } // namespace WebKit
 
 #endif // ENABLE(GPU_PROCESS)

Source/WebKit/GPUProcess/RemoteSharedResourceCache.h

@@ -32,14 +32,13 @@
 #include "ThreadSafeObjectHeap.h"
 #include <WebCore/ImageBuffer.h>
 #include <WebCore/RenderingResourceIdentifier.h>
-#include <atomic>
 #include <wtf/FastMalloc.h>
 #include <wtf/Ref.h>
 #include <wtf/ThreadSafeRefCounted.h>
 
 namespace WebKit {
 
-// Class holding GPU process resources per WebContent process.
+// Class holding GPU process resources per Web Process.
 // Thread-safe.
 class RemoteSharedResourceCache final : public ThreadSafeRefCounted<RemoteSharedResourceCache>, IPC::MessageReceiver {
     WTF_MAKE_FAST_ALLOCATED;
@@ -50,10 +49,6 @@ class RemoteSharedResourceCache final : public ThreadSafeRefCounted<RemoteShared
     void addSerializedImageBuffer(WebCore::RenderingResourceIdentifier, Ref<WebCore::ImageBuffer>);
     RefPtr<WebCore::ImageBuffer> takeSerializedImageBuffer(WebCore::RenderingResourceIdentifier);
 
-    void didAddAcceleratedImageBuffer();
-    void didTakeAcceleratedImageBuffer();
-    WebCore::RenderingMode adjustAcceleratedImageBufferRenderingMode(WebCore::RenderingPurpose) const;
-
     // IPC::MessageReceiver
     void didReceiveMessage(IPC::Connection&, IPC::Decoder&) final;
 
@@ -64,9 +59,9 @@ class RemoteSharedResourceCache final : public ThreadSafeRefCounted<RemoteShared
     void releaseSerializedImageBuffer(WebCore::RenderingResourceIdentifier);
 
     IPC::ThreadSafeObjectHeap<RemoteSerializedImageBufferIdentifier, RefPtr<WebCore::ImageBuffer>> m_serializedImageBuffers;
-    std::atomic<size_t> m_acceleratedImageBufferCount { 0 };
 };
 
+
 } // namespace WebKit
 
 #endif // ENABLE(GPU_PROCESS)

Source/WebKit/GPUProcess/graphics/RemoteRenderingBackend.cpp

@@ -208,9 +208,6 @@ void RemoteRenderingBackend::didFailCreateImageBuffer(RenderingResourceIdentifie
 
 void RemoteRenderingBackend::didCreateImageBuffer(Ref<ImageBuffer> imageBuffer)
 {
-    if (imageBuffer->renderingMode() == RenderingMode::Accelerated)
-        m_sharedResourceCache->didAddAcceleratedImageBuffer();
-
     auto imageBufferIdentifier = imageBuffer->renderingResourceIdentifier();
     auto* sharing = imageBuffer->toBackendSharing();
     auto handle = downcast<ImageBufferBackendHandleSharing>(*sharing).createBackendHandle();
@@ -287,8 +284,6 @@ RefPtr<ImageBuffer> RemoteRenderingBackend::allocateImageBuffer(const FloatSize&
 #endif
 
     RefPtr<ImageBuffer> imageBuffer;
-    if (renderingMode == RenderingMode::Accelerated)
-        renderingMode = m_sharedResourceCache->adjustAcceleratedImageBufferRenderingMode(purpose);
 
 #if ENABLE(RE_DYNAMIC_CONTENT_SCALING)
     if (m_gpuConnectionToWebProcess->isDynamicContentScalingEnabled() && (purpose == RenderingPurpose::LayerBacking || purpose == RenderingPurpose::DOM))
@@ -319,8 +314,8 @@ void RemoteRenderingBackend::releaseImageBuffer(RenderingResourceIdentifier rend
 {
     assertIsCurrent(workQueue());
     m_remoteDisplayLists.take(renderingResourceIdentifier);
-    auto imageBuffer = takeImageBuffer(renderingResourceIdentifier);
-    MESSAGE_CHECK(imageBuffer, "Resource is being released before being cached."_s);
+    bool success = m_remoteImageBuffers.take(renderingResourceIdentifier).get();
+    MESSAGE_CHECK(success, "Resource is being released before being cached."_s);
 }
 
 void RemoteRenderingBackend::createRemoteImageBufferSet(RemoteImageBufferSetIdentifier bufferSetIdentifier, WebCore::RenderingResourceIdentifier displayListIdentifier)
@@ -604,10 +599,7 @@ RefPtr<ImageBuffer> RemoteRenderingBackend::takeImageBuffer(RenderingResourceIde
     RefPtr remoteImageBuffer = remoteImageBufferReceiveQueue.get();
     remoteImageBufferReceiveQueue.reset();
     ASSERT(remoteImageBuffer->hasOneRef());
-    Ref imageBuffer = remoteImageBuffer->imageBuffer();
-    if (imageBuffer->renderingMode() == RenderingMode::Accelerated)
-        m_sharedResourceCache->didTakeAcceleratedImageBuffer();
-    return imageBuffer;
+    return remoteImageBuffer->imageBuffer();
 }
 
 void RemoteRenderingBackend::terminateWebProcess(ASCIILiteral message)