Attachment 434137 Details for Bug 228222 – Reworked struct ResourceUseCounter

[patch] Reworked struct ResourceUseCounter

bug-228222-20210723161103.patch (text/plain), 25.53 KB, created by Myles C. Maxfield on 2021-07-23 16:11:04 PDT

(hide)

Description:

Filename:

MIME Type:

Creator: Myles C. Maxfield

Created: 2021-07-23 16:11:04 PDT

Size: 25.53 KB

patch

obsolete

>Subversion Revision: 280258
>diff --git a/Source/WebCore/ChangeLog b/Source/WebCore/ChangeLog
>index c2109bbbc4c49cfbf1df2ec69c2ab9fd16595f47..fb3771c8198daa4f23bf1cdb09bb3cbd72e2e28a 100644
>--- a/Source/WebCore/ChangeLog
>+++ b/Source/WebCore/ChangeLog
>@@ -1,3 +1,29 @@
>+2021-07-23  Myles C. Maxfield  <mmaxfield@apple.com>
>+
>+        [GPU Process] Add resource use counter infrastructure to RemoteResourceCache
>+        https://bugs.webkit.org/show_bug.cgi?id=228222
>+
>+        Reviewed by NOBODY (OOPS!).
>+
>+        This is part 2 of https://bugs.webkit.org/show_bug.cgi?id=228216.
>+
>+        Using DisplayList::Replayer::Delegate to track how many times a resource is used in a display list is a natural fit.
>+        However, if the GPU process determines that a resource has hit its use limit and is ready to be destroyed, it can't
>+        actually destroy it immediately, because the delegate's callback is called before actually executing the display
>+        list item (which needs to see the resource). And it has to execute before executing the display list item because
>+        the delegate actually implements the display list item for things like getImageData. So, this patch adds another
>+        method to the delegate: didCompleteReplaying(), which is called at the end of the replay. The GPU process will
>+        remember which resources were used during the replay, and increment the relevant counters, but only once the replay
>+        has finished can the GPU process actually delete these resources. That occurs in this new delegate method.
>+
>+        No new tests because there is no behavior change yet. This patch is just adding infrastructure. For now, all these
>+        use counts sent by the web process are 0 - I'll implement that part in 3 follow-up patches.
>+
>+        * platform/graphics/displaylists/DisplayListReplayer.cpp:
>+        (WebCore::DisplayList::Replayer::replay):
>+        * platform/graphics/displaylists/DisplayListReplayer.h:
>+        (WebCore::DisplayList::Replayer::Delegate::didCompleteReplaying):
>+
> 2021-07-23  Alexey Shvayka  <shvaikalesh@gmail.com>
> 
>         [JSC] Call custom accessors / values with their holder's global object
>diff --git a/Source/WebKit/ChangeLog b/Source/WebKit/ChangeLog
>index 9c6e4e579cfebe45f28276bae16d2d330757233e..5be0c19bbe7d557aa4b30d8223d718d8c63ac53f 100644
>--- a/Source/WebKit/ChangeLog
>+++ b/Source/WebKit/ChangeLog
>@@ -1,3 +1,56 @@
>+2021-07-23  Myles C. Maxfield  <mmaxfield@apple.com>
>+
>+        [GPU Process] Add resource use counter infrastructure to RemoteResourceCache
>+        https://bugs.webkit.org/show_bug.cgi?id=228222
>+
>+        Reviewed by NOBODY (OOPS!).
>+
>+        This patch adds the infrastructure for associating a counter with each resource in the RemoteResourceCache.
>+        As the web process uses a resource during display list recording, it increments a counter, and as the GPU
>+        process uses a resource, it increments a counter in the RemoteResourceCache. When the web process is done
>+        with a resource, it sends a release message to the GPU process which crucially includes the web process's
>+        counter. The GPU process has to then wait to actually delete the resource until its own use counter matches
>+        the one it received from the web process. This patch implements this deferred deletion infrastructure
>+        in the GPU process.
>+
>+        * GPUProcess/graphics/RemoteRenderingBackend.cpp:
>+        (WebKit::RemoteRenderingBackend::ReplayerDelegate::didCompleteReplaying): See the WebCore ChangeLog for an
>+        explanation of this.
>+        (WebKit::RemoteRenderingBackend::releaseRemoteResource): Pass the use count to the RemoteResourceCache.
>+        * GPUProcess/graphics/RemoteRenderingBackend.h: Add the use count field.
>+        * GPUProcess/graphics/RemoteRenderingBackend.messages.in: Ditto.
>+        * GPUProcess/graphics/RemoteResourceCache.cpp:
>+        (WebKit::RemoteResourceCache::cacheImageBuffer): It's actually okay if there's already an resource cached.
>+        That just means that the web process started using a resource again before the GPU process consumed all
>+        commands that used it the first time. All we need to do is increment the open count.
>+        (WebKit::RemoteResourceCache::cacheNativeImage): Ditto.
>+        (WebKit::RemoteResourceCache::cacheFont): Ditto.
>+        (WebKit::RemoteResourceCache::ensureResourceUseCounter):
>+        (WebKit::RemoteResourceCache::maybeRemoveResource): This is called whenever it's possible for us to be in
>+        situation where we should be removing a resource (aka whenever the use count increments). It checks to see
>+        if we can remove the resource, and if it can, does so.
>+        (WebKit::RemoteResourceCache::recordResourceUse): The callback that runs for each resource use during
>+        replaying. It can't actually delete any resources, so instead it just records which resources had their
>+        use counts incremented, and waits for prune() to actually call maybeRemoveResource().
>+        (WebKit::RemoteResourceCache::prune): After the replay is complete, call maybeRemoveResource() on all the
>+        resources which had their use counters touched.
>+        (WebKit::RemoteResourceCache::releaseRemoteResource): Put the relevant resource into the state where we
>+        are waiting for the use counters to match before we can delete the resource. Also, call maybeRemoveResource()
>+        so it can be deleted immediately if the counters already match.
>+        * GPUProcess/graphics/RemoteResourceCache.h: Add a new data structure to hold the use counters. There's
>+        a big comment in here that describes what these fields mean.
>+        * WebProcess/GPU/graphics/RemoteImageBufferProxy.h:
>+        (WebKit::RemoteImageBufferProxy::~RemoteImageBufferProxy): Send a dummy use count for now. This will be
>+        implemented in a follow-up patch.
>+        * WebProcess/GPU/graphics/RemoteRenderingBackendProxy.cpp:
>+        (WebKit::RemoteRenderingBackendProxy::releaseRemoteResource): Add the useCount parameter.
>+        * WebProcess/GPU/graphics/RemoteRenderingBackendProxy.h: Ditto.
>+        * WebProcess/GPU/graphics/RemoteResourceCacheProxy.cpp:
>+        (WebKit::RemoteResourceCacheProxy::releaseNativeImage): Send a dummy use count for now. This will be
>+        implemented in a follow-up patch.
>+        (WebKit::RemoteResourceCacheProxy::clearFontMap): Ditto.
>+        (WebKit::RemoteResourceCacheProxy::finalizeRenderingUpdateForFonts): Ditto.
>+
> 2021-07-23  Robert Jenner  <Jenner@apple.com>
> 
>         Unreviewed, reverting r280205.
>diff --git a/Source/WebCore/platform/graphics/displaylists/DisplayListReplayer.cpp b/Source/WebCore/platform/graphics/displaylists/DisplayListReplayer.cpp
>index f370b4118d0243a1b29bba0210f897472937a853..3561da0bd1226cbc9527eafed134577ddf8d3e37 100644
>--- a/Source/WebCore/platform/graphics/displaylists/DisplayListReplayer.cpp
>+++ b/Source/WebCore/platform/graphics/displaylists/DisplayListReplayer.cpp
>@@ -232,6 +232,9 @@ ReplayResult Replayer::replay(const FloatRect& initialClip, bool trackReplayList
>         }
>     }
> 
>+    if (m_delegate)
>+        m_delegate->didCompleteReplaying();
>+
>     result.trackedDisplayList = WTFMove(replayList);
>     return result;
> }
>diff --git a/Source/WebCore/platform/graphics/displaylists/DisplayListReplayer.h b/Source/WebCore/platform/graphics/displaylists/DisplayListReplayer.h
>index 16627a0206e309243f8b7bd18cdb3da586078a8f..57939ee977ed4ec458a0d4592d9dcdb72afcf030 100644
>--- a/Source/WebCore/platform/graphics/displaylists/DisplayListReplayer.h
>+++ b/Source/WebCore/platform/graphics/displaylists/DisplayListReplayer.h
>@@ -68,6 +68,7 @@ public:
>         virtual bool apply(ItemHandle, GraphicsContext&) { return false; }
>         virtual void didCreateMaskImageBuffer(WebCore::ImageBuffer&) { }
>         virtual void didResetMaskImageBuffer() { }
>+        virtual void didCompleteReplaying() { }
>     };
>     
> private:
>diff --git a/Source/WebKit/GPUProcess/graphics/RemoteRenderingBackend.cpp b/Source/WebKit/GPUProcess/graphics/RemoteRenderingBackend.cpp
>index ea8286da0c9de4dfca7de35be337df032c037e7e..c106f42cc4f35554ed9232b035e3835ab202c892 100644
>--- a/Source/WebKit/GPUProcess/graphics/RemoteRenderingBackend.cpp
>+++ b/Source/WebKit/GPUProcess/graphics/RemoteRenderingBackend.cpp
>@@ -214,6 +214,12 @@ void RemoteRenderingBackend::ReplayerDelegate::didResetMaskImageBuffer()
>     m_remoteRenderingBackend.didResetMaskImageBuffer();
> }
> 
>+void RemoteRenderingBackend::ReplayerDelegate::didCompleteReplaying()
>+{
>+    auto messagesAreInOrder = m_remoteRenderingBackend.remoteResourceCache().prune();
>+    MESSAGE_CHECK(messagesAreInOrder, "Web process tried to release a resource that wasn't cached");
>+}
>+
> DisplayList::ReplayResult RemoteRenderingBackend::submit(const DisplayList::DisplayList& displayList, ImageBuffer& destination)
> {
>     if (displayList.isEmpty())
>@@ -509,10 +515,11 @@ void RemoteRenderingBackend::deleteAllFonts()
>     m_remoteResourceCache.deleteAllFonts();
> }
> 
>-void RemoteRenderingBackend::releaseRemoteResource(RenderingResourceIdentifier renderingResourceIdentifier)
>+void RemoteRenderingBackend::releaseRemoteResource(RenderingResourceIdentifier renderingResourceIdentifier, uint64_t useCount)
> {
>     ASSERT(!RunLoop::isMain());
>-    m_remoteResourceCache.releaseRemoteResource(renderingResourceIdentifier);
>+    auto success = m_remoteResourceCache.releaseRemoteResource(renderingResourceIdentifier, useCount);
>+    MESSAGE_CHECK(success, "Resource is being released before being cached.");
>     updateRenderingResourceRequest();
> }
> 
>diff --git a/Source/WebKit/GPUProcess/graphics/RemoteRenderingBackend.h b/Source/WebKit/GPUProcess/graphics/RemoteRenderingBackend.h
>index f7bf6bc3b073adbeae6f6b862fa367f6ab00e5b0..872629f0253bf4b693682b70223285ffb61356d3 100644
>--- a/Source/WebKit/GPUProcess/graphics/RemoteRenderingBackend.h
>+++ b/Source/WebKit/GPUProcess/graphics/RemoteRenderingBackend.h
>@@ -144,7 +144,7 @@ private:
>     void cacheNativeImage(const ShareableBitmap::Handle&, WebCore::RenderingResourceIdentifier);
>     void cacheFont(Ref<WebCore::Font>&&);
>     void deleteAllFonts();
>-    void releaseRemoteResource(WebCore::RenderingResourceIdentifier);
>+    void releaseRemoteResource(WebCore::RenderingResourceIdentifier, uint64_t useCount);
>     void didCreateSharedDisplayListHandle(WebCore::DisplayList::ItemBufferIdentifier, const SharedMemory::IPCHandle&, WebCore::RenderingResourceIdentifier destinationBufferIdentifier);
> 
>     class ReplayerDelegate : public WebCore::DisplayList::Replayer::Delegate {
>@@ -155,6 +155,7 @@ private:
>         bool apply(WebCore::DisplayList::ItemHandle, WebCore::GraphicsContext&) final;
>         void didCreateMaskImageBuffer(WebCore::ImageBuffer&) final;
>         void didResetMaskImageBuffer() final;
>+        void didCompleteReplaying() final;
> 
>         WebCore::ImageBuffer& m_destination;
>         RemoteRenderingBackend& m_remoteRenderingBackend;
>diff --git a/Source/WebKit/GPUProcess/graphics/RemoteRenderingBackend.messages.in b/Source/WebKit/GPUProcess/graphics/RemoteRenderingBackend.messages.in
>index 4b3fe9a0262e8a5491852c6d6a04045d6a696397..ff62af511f3e2e5cebf4741bb350338494e38eb7 100644
>--- a/Source/WebKit/GPUProcess/graphics/RemoteRenderingBackend.messages.in
>+++ b/Source/WebKit/GPUProcess/graphics/RemoteRenderingBackend.messages.in
>@@ -36,7 +36,7 @@ messages -> RemoteRenderingBackend {
>     CacheFont(IPC::FontReference font)
>     DeleteAllFonts()
>     DidCreateSharedDisplayListHandle(WebCore::DisplayList::ItemBufferIdentifier identifier, WebKit::SharedMemory::IPCHandle handle, WebCore::RenderingResourceIdentifier destinationBufferIdentifier)
>-    ReleaseRemoteResource(WebCore::RenderingResourceIdentifier renderingResourceIdentifier)
>+    ReleaseRemoteResource(WebCore::RenderingResourceIdentifier renderingResourceIdentifier, uint64_t useCount)
> }
> 
> #endif // ENABLE(GPU_PROCESS)
>diff --git a/Source/WebKit/GPUProcess/graphics/RemoteResourceCache.cpp b/Source/WebKit/GPUProcess/graphics/RemoteResourceCache.cpp
>index 81dde0bffcf0bd6cc1c28e5dd246374b34646278..6526fd5cc0ce56abd50f5d1fe657bd011948b42c 100644
>--- a/Source/WebKit/GPUProcess/graphics/RemoteResourceCache.cpp
>+++ b/Source/WebKit/GPUProcess/graphics/RemoteResourceCache.cpp
>@@ -33,8 +33,10 @@ using namespace WebCore;
> 
> void RemoteResourceCache::cacheImageBuffer(Ref<ImageBuffer>&& imageBuffer)
> {
>-    auto addResult = m_imageBuffers.add(imageBuffer->renderingResourceIdentifier(), WTFMove(imageBuffer));
>-    ASSERT_UNUSED(addResult, addResult.isNewEntry);
>+    auto renderingResourceIdentifier = imageBuffer->renderingResourceIdentifier();
>+    m_imageBuffers.add(renderingResourceIdentifier, WTFMove(imageBuffer));
>+
>+    ensureResourceUseCounter(renderingResourceIdentifier);
> }
> 
> ImageBuffer* RemoteResourceCache::cachedImageBuffer(RenderingResourceIdentifier renderingResourceIdentifier)
>@@ -44,14 +46,28 @@ ImageBuffer* RemoteResourceCache::cachedImageBuffer(RenderingResourceIdentifier
> 
> void RemoteResourceCache::cacheNativeImage(Ref<NativeImage>&& image)
> {
>-    auto addResult = m_nativeImages.add(image->renderingResourceIdentifier(), WTFMove(image));
>-    ASSERT_UNUSED(addResult, addResult.isNewEntry);
>+    auto renderingResourceIdentifier = image->renderingResourceIdentifier();
>+    m_nativeImages.add(renderingResourceIdentifier, WTFMove(image));
>+
>+    ensureResourceUseCounter(renderingResourceIdentifier);
> }
> 
> void RemoteResourceCache::cacheFont(Ref<Font>&& font)
> {
>-    auto addResult = m_fonts.add(font->renderingResourceIdentifier(), WTFMove(font));
>-    ASSERT_UNUSED(addResult, addResult.isNewEntry);
>+    auto renderingResourceIdentifier = font->renderingResourceIdentifier();
>+    m_fonts.add(renderingResourceIdentifier, WTFMove(font));
>+
>+    ensureResourceUseCounter(renderingResourceIdentifier);
>+}
>+
>+void RemoteResourceCache::ensureResourceUseCounter(WebCore::RenderingResourceIdentifier renderingResourceIdentifier)
>+{
>+    auto result = m_resourceUseCounters.ensure(renderingResourceIdentifier, [&] {
>+        return ResourceUseCounter { };
>+    });
>+    auto& state = result.iterator->value.state;
>+    RELEASE_ASSERT(state == ResourceState::ToBeDeleted);
>+    state = ResourceState::Alive;
> }
> 
> void RemoteResourceCache::deleteAllFonts()
>@@ -59,16 +75,70 @@ void RemoteResourceCache::deleteAllFonts()
>     m_fonts.clear();
> }
> 
>-void RemoteResourceCache::releaseRemoteResource(RenderingResourceIdentifier renderingResourceIdentifier)
>+bool RemoteResourceCache::maybeRemoveResource(WebCore::RenderingResourceIdentifier renderingResourceIdentifier, ResourceUseCountersMap::iterator iterator)
> {
>+    // It's actually okay if useCount > 0.
>+    // It just means that there's a cache message pending, and we've eagerly used a previously-cached resource.
>+    // Which is fine.
>+    // FIXME: Maybe we shouldn't actually remove the resource in this situation?
>+    // We may actually be able to get a head start on some display list items if they're ready for us and we have the resources they depend on.
>+
>+    auto& value = iterator->value;
>+    if (value.state == ResourceState::Alive || value.useOrPendingCount < 0)
>+        return true;
>+
>+    if (!value.useOrPendingCount)
>+        m_resourceUseCounters.remove(iterator);
>+
>     if (m_imageBuffers.remove(renderingResourceIdentifier))
>-        return;
>+        return true;
>     if (m_nativeImages.remove(renderingResourceIdentifier))
>-        return;
>+        return true;
>     if (m_fonts.remove(renderingResourceIdentifier))
>-        return;
>+        return true;
>+
>     // Caching the remote resource should have happened before releasing it.
>-    ASSERT_NOT_REACHED();
>+    return false;
>+}
>+
>+void RemoteResourceCache::recordResourceUse(WebCore::RenderingResourceIdentifier renderingResourceIdentifier)
>+{
>+    auto iterator = m_resourceUseCounters.find(renderingResourceIdentifier);
>+
>+    if (iterator == m_resourceUseCounters.end()) {
>+        // The display list items won the race against the cacheFont message.
>+        // When we receive the cacheFont message, we will retry the display list item.
>+        return;
>+    }
>+
>+    ResourceUseCounter& useCounter = iterator->value;
>+    ++useCounter.useOrPendingCount;
>+
>+    m_resourcesForMaybeRemoving.add(renderingResourceIdentifier);
>+}
>+
>+bool RemoteResourceCache::prune()
>+{
>+    for (auto renderingResourceIdentifier : m_resourcesForMaybeRemoving) {
>+        auto iterator = m_resourceUseCounters.find(renderingResourceIdentifier);
>+        ASSERT(iterator != m_resourceUseCounters.end());
>+        auto messagesAreInOrder = maybeRemoveResource(renderingResourceIdentifier, iterator);
>+        if (!messagesAreInOrder)
>+            return false;
>+    }
>+    m_resourcesForMaybeRemoving.clear();
>+    return true;
>+}
>+
>+bool RemoteResourceCache::releaseRemoteResource(RenderingResourceIdentifier renderingResourceIdentifier, uint64_t useCount)
>+{
>+    auto iterator = m_resourceUseCounters.find(renderingResourceIdentifier);
>+    if (iterator == m_resourceUseCounters.end())
>+        return false;
>+    ResourceUseCounter& useCounter = iterator->value;
>+    useCounter.state = ResourceState::ToBeDeleted;
>+    useCounter.useOrPendingCount -= useCount;
>+    return maybeRemoveResource(renderingResourceIdentifier, iterator);
> }
> 
> } // namespace WebKit
>diff --git a/Source/WebKit/GPUProcess/graphics/RemoteResourceCache.h b/Source/WebKit/GPUProcess/graphics/RemoteResourceCache.h
>index 2ced909f48110c66656de1bfe3811dbabaaa9f4f..7cef785080b138a000b4fe19ec0d88dc5027ae25 100644
>--- a/Source/WebKit/GPUProcess/graphics/RemoteResourceCache.h
>+++ b/Source/WebKit/GPUProcess/graphics/RemoteResourceCache.h
>@@ -46,16 +46,48 @@ public:
>     void cacheNativeImage(Ref<WebCore::NativeImage>&&);
>     void cacheFont(Ref<WebCore::Font>&&);
>     void deleteAllFonts();
>-    void releaseRemoteResource(WebCore::RenderingResourceIdentifier);
>+    bool releaseRemoteResource(WebCore::RenderingResourceIdentifier, uint64_t useCount);
>+    void recordResourceUse(WebCore::RenderingResourceIdentifier);
>+    bool prune();
> 
>     const WebCore::ImageBufferHashMap& imageBuffers() const { return m_imageBuffers; }
>     const WebCore::NativeImageHashMap& nativeImages() const { return m_nativeImages; }
>     const WebCore::FontRenderingResourceMap& fonts() const { return m_fonts; }
> 
> private:
>+    // Because the cache/release messages are sent asynchronously from the display list items which
>+    // reference the resources, it's totally possible that we see a release message before we've
>+    // executed all the display list items which reference the resource. The web process tells us
>+    // how many display list items will reference this resource, and we defer deletion of the resource
>+    // until we execute that many display list items.
>+    //
>+    // It's actually a bit worse than this, though, because we may actually see a *new* cache message
>+    // during the time when deletion is deferred, so we need a second count of the number of cache
>+    // messages which don't have an accompanying release messages.
>+    //
>+    // We can only safely delete a resource when:
>+    // 1. All the cache messages have an accompanying release message, and
>+    // 2. We've processed as many display list items that reference a particular resource as the web
>+    // process has encoded.
>+    enum class ResourceState {
>+        Alive,
>+        ToBeDeleted
>+    };
>+    struct ResourceUseCounter {
>+        ResourceState state { ResourceState::ToBeDeleted };
>+        int64_t useOrPendingCount { 0 };
>+    };
>+    using ResourceUseCountersMap = HashMap<WebCore::RenderingResourceIdentifier, ResourceUseCounter>;
>+
>+    bool maybeRemoveResource(WebCore::RenderingResourceIdentifier, ResourceUseCountersMap::iterator);
>+    void ensureResourceUseCounter(WebCore::RenderingResourceIdentifier);
>+
>     WebCore::ImageBufferHashMap m_imageBuffers;
>     WebCore::NativeImageHashMap m_nativeImages;
>     WebCore::FontRenderingResourceMap m_fonts;
>+
>+    ResourceUseCountersMap m_resourceUseCounters;
>+    HashSet<WebCore::RenderingResourceIdentifier> m_resourcesForMaybeRemoving;
> };
> 
> } // namespace WebKit
>diff --git a/Source/WebKit/WebKit.xcodeproj/xcshareddata/xcschemes/WebKit.xcscheme b/Source/WebKit/WebKit.xcodeproj/xcshareddata/xcschemes/WebKit.xcscheme
>index 61039b1c71738f3233db8b359843c44c83ef9c9f..218db2b376990c458b5e983b15d82f9dc4a3186a 100644
>--- a/Source/WebKit/WebKit.xcodeproj/xcshareddata/xcschemes/WebKit.xcscheme
>+++ b/Source/WebKit/WebKit.xcodeproj/xcshareddata/xcschemes/WebKit.xcscheme
>@@ -31,7 +31,7 @@
>       </Testables>
>    </TestAction>
>    <LaunchAction
>-      buildConfiguration = "Release"
>+      buildConfiguration = "Debug"
>       selectedDebuggerIdentifier = "Xcode.DebuggerFoundation.Debugger.LLDB"
>       selectedLauncherIdentifier = "Xcode.DebuggerFoundation.Launcher.LLDB"
>       launchStyle = "0"
>diff --git a/Source/WebKit/WebProcess/GPU/graphics/RemoteImageBufferProxy.h b/Source/WebKit/WebProcess/GPU/graphics/RemoteImageBufferProxy.h
>index b448b37f97fe7ae65dbebb2a85ab0c994e1f26bd..d4cbc2c0c9034305968f277b55361bb27482fea8 100644
>--- a/Source/WebKit/WebProcess/GPU/graphics/RemoteImageBufferProxy.h
>+++ b/Source/WebKit/WebProcess/GPU/graphics/RemoteImageBufferProxy.h
>@@ -72,7 +72,7 @@ public:
> 
>         flushDrawingContext();
>         m_remoteRenderingBackendProxy->remoteResourceCacheProxy().releaseImageBuffer(m_renderingResourceIdentifier);
>-        m_remoteRenderingBackendProxy->releaseRemoteResource(m_renderingResourceIdentifier);
>+        m_remoteRenderingBackendProxy->releaseRemoteResource(m_renderingResourceIdentifier, 0); // FIXME: Pass the real use count here.
>     }
> 
>     ImageBufferBackendHandle createImageBufferBackendHandle()
>diff --git a/Source/WebKit/WebProcess/GPU/graphics/RemoteRenderingBackendProxy.cpp b/Source/WebKit/WebProcess/GPU/graphics/RemoteRenderingBackendProxy.cpp
>index 09ce4c6ef6d6abe71e03eab7fa8cd214ff68b0fe..e95f1ad3934f254bd5f99d23a5b4655535ce0930 100644
>--- a/Source/WebKit/WebProcess/GPU/graphics/RemoteRenderingBackendProxy.cpp
>+++ b/Source/WebKit/WebProcess/GPU/graphics/RemoteRenderingBackendProxy.cpp
>@@ -249,12 +249,12 @@ void RemoteRenderingBackendProxy::deleteAllFonts()
>     send(Messages::RemoteRenderingBackend::DeleteAllFonts(), renderingBackendIdentifier(), IPC::SendOption::DispatchMessageEvenWhenWaitingForSyncReply);
> }
> 
>-void RemoteRenderingBackendProxy::releaseRemoteResource(RenderingResourceIdentifier renderingResourceIdentifier)
>+void RemoteRenderingBackendProxy::releaseRemoteResource(RenderingResourceIdentifier renderingResourceIdentifier, uint64_t useCount)
> {
>     if (renderingResourceIdentifier == m_currentDestinationImageBufferIdentifier)
>         m_currentDestinationImageBufferIdentifier = std::nullopt;
> 
>-    send(Messages::RemoteRenderingBackend::ReleaseRemoteResource(renderingResourceIdentifier), renderingBackendIdentifier(), IPC::SendOption::DispatchMessageEvenWhenWaitingForSyncReply);
>+    send(Messages::RemoteRenderingBackend::ReleaseRemoteResource(renderingResourceIdentifier, useCount), renderingBackendIdentifier(), IPC::SendOption::DispatchMessageEvenWhenWaitingForSyncReply);
> }
> 
> void RemoteRenderingBackendProxy::didCreateImageBufferBackend(ImageBufferBackendHandle handle, RenderingResourceIdentifier renderingResourceIdentifier)
>diff --git a/Source/WebKit/WebProcess/GPU/graphics/RemoteRenderingBackendProxy.h b/Source/WebKit/WebProcess/GPU/graphics/RemoteRenderingBackendProxy.h
>index 63149670a3594e25a2da5cd197611461c6179740..b2ce3d8c28ab191253519027fc9074d20ed17282 100644
>--- a/Source/WebKit/WebProcess/GPU/graphics/RemoteRenderingBackendProxy.h
>+++ b/Source/WebKit/WebProcess/GPU/graphics/RemoteRenderingBackendProxy.h
>@@ -104,7 +104,7 @@ public:
>     void cacheNativeImage(const ShareableBitmap::Handle&, WebCore::RenderingResourceIdentifier);
>     void cacheFont(Ref<WebCore::Font>&&);
>     void deleteAllFonts();
>-    void releaseRemoteResource(WebCore::RenderingResourceIdentifier);
>+    void releaseRemoteResource(WebCore::RenderingResourceIdentifier, uint64_t useCount);
> 
>     enum class DidReceiveBackendCreationResult : bool {
>         ReceivedAnyResponse,
>diff --git a/Source/WebKit/WebProcess/GPU/graphics/RemoteResourceCacheProxy.cpp b/Source/WebKit/WebProcess/GPU/graphics/RemoteResourceCacheProxy.cpp
>index 03f34b33a22dd4928d4260e47862d391371101af..414e1996e8bc2995b7f7076ae6a5214d6367668b 100644
>--- a/Source/WebKit/WebProcess/GPU/graphics/RemoteResourceCacheProxy.cpp
>+++ b/Source/WebKit/WebProcess/GPU/graphics/RemoteResourceCacheProxy.cpp
>@@ -121,8 +121,7 @@ void RemoteResourceCacheProxy::releaseNativeImage(RenderingResourceIdentifier re
>     if (!m_nativeImages.remove(renderingResourceIdentifier))
>         return;
> 
>-    // Tell the GPU process to remove this resource.
>-    m_remoteRenderingBackendProxy.releaseRemoteResource(renderingResourceIdentifier);
>+    m_remoteRenderingBackendProxy.releaseRemoteResource(renderingResourceIdentifier, 0); // FIXME: Pass the real use count here.
> }
> 
> void RemoteResourceCacheProxy::prepareForNextRenderingUpdate()
>@@ -134,7 +133,7 @@ void RemoteResourceCacheProxy::prepareForNextRenderingUpdate()
> void RemoteResourceCacheProxy::clearFontMap()
> {
>     for (auto& item : m_fontIdentifierToLastRenderingUpdateVersionMap)
>-        m_remoteRenderingBackendProxy.releaseRemoteResource(item.key);
>+        m_remoteRenderingBackendProxy.releaseRemoteResource(item.key, 0); // FIXME: Pass the real use count here.
>     m_fontIdentifierToLastRenderingUpdateVersionMap.clear();
>     m_numberOfFontsUsedInCurrentRenderingUpdate = 0;
> }
>@@ -152,7 +151,7 @@ void RemoteResourceCacheProxy::finalizeRenderingUpdateForFonts()
>     for (auto& item : m_fontIdentifierToLastRenderingUpdateVersionMap) {
>         if (m_currentRenderingUpdateVersion - item.value >= minimumRenderingUpdateCountToKeepFontAlive) {
>             toRemove.add(item.key);
>-            m_remoteRenderingBackendProxy.releaseRemoteResource(item.key);
>+            m_remoteRenderingBackendProxy.releaseRemoteResource(item.key, 0); // FIXME: Pass the real use count here.
>         }
>     }
>

Actions: View | Formatted Diff | Diff

Attachments on bug 228222: 434067 | 434072 | 434094 | 434137 | 434138 | 434139 | 434145 | 434159 | 434264