Diff
Modified: trunk/Source/WebCore/ChangeLog (284047 => 284048)
--- trunk/Source/WebCore/ChangeLog 2021-10-12 22:40:20 UTC (rev 284047)
+++ trunk/Source/WebCore/ChangeLog 2021-10-12 22:42:19 UTC (rev 284048)
@@ -1,3 +1,31 @@
+2021-10-12 Myles C. Maxfield <[email protected]>
+
+ [GPU Process] Unique RenderingResourceIdentifiers Part 9: Finish migrating RemoteResourceCache to QualifiedRenderingResourceIdentifier
+ https://bugs.webkit.org/show_bug.cgi?id=231414
+ <rdar://problem/84015584>
+
+ Reviewed by Said Abou-Hallawa.
+
+ We can delete a bunch of the methods of ResourceHeapImpl because they are only used in the
+ GPU Process-specific implementation.
+
+ No new tests because there is no behavior change.
+
+ * platform/graphics/displaylists/DisplayList.h:
+ * platform/graphics/displaylists/DisplayListResourceHeap.h:
+ (WebCore::DisplayList::ResourceHeap::add): Deleted.
+ (WebCore::DisplayList::ResourceHeap::getImageBuffer const): Deleted.
+ (WebCore::DisplayList::ResourceHeap::getNativeImage const): Deleted.
+ (WebCore::DisplayList::ResourceHeap::getFont const): Deleted.
+ (WebCore::DisplayList::ResourceHeap::hasImageBuffer const): Deleted.
+ (WebCore::DisplayList::ResourceHeap::hasNativeImage const): Deleted.
+ (WebCore::DisplayList::ResourceHeap::hasFont const): Deleted.
+ (WebCore::DisplayList::ResourceHeap::removeImageBuffer): Deleted.
+ (WebCore::DisplayList::ResourceHeap::removeNativeImage): Deleted.
+ (WebCore::DisplayList::ResourceHeap::removeFont): Deleted.
+ (WebCore::DisplayList::ResourceHeap::clear): Deleted.
+ (WebCore::DisplayList::ResourceHeap::deleteAllFonts): Deleted.
+
2021-10-12 David Kilzer <[email protected]>
Switch WTF::bridge_cast to use type traits
Modified: trunk/Source/WebCore/platform/graphics/displaylists/DisplayList.h (284047 => 284048)
--- trunk/Source/WebCore/platform/graphics/displaylists/DisplayList.h 2021-10-12 22:40:20 UTC (rev 284047)
+++ trunk/Source/WebCore/platform/graphics/displaylists/DisplayList.h 2021-10-12 22:42:19 UTC (rev 284048)
@@ -127,7 +127,7 @@
static bool shouldDumpForFlags(AsTextFlags, ItemHandle);
- ResourceHeap m_resourceHeap;
+ LocalResourceHeap m_resourceHeap;
std::unique_ptr<ItemBuffer> m_items;
Vector<std::optional<FloatRect>> m_drawingItemExtents;
bool m_tracksDrawingItemExtents { true };
Modified: trunk/Source/WebCore/platform/graphics/displaylists/DisplayListResourceHeap.h (284047 => 284048)
--- trunk/Source/WebCore/platform/graphics/displaylists/DisplayListResourceHeap.h 2021-10-12 22:40:20 UTC (rev 284047)
+++ trunk/Source/WebCore/platform/graphics/displaylists/DisplayListResourceHeap.h 2021-10-12 22:42:19 UTC (rev 284048)
@@ -37,85 +37,50 @@
class ResourceHeap {
public:
+ virtual ~ResourceHeap() = default;
+
+ virtual ImageBuffer* getImageBuffer(RenderingResourceIdentifier) const = 0;
+ virtual NativeImage* getNativeImage(RenderingResourceIdentifier) const = 0;
+ virtual Font* getFont(RenderingResourceIdentifier) const = 0;
+};
+
+class LocalResourceHeap : public ResourceHeap {
+public:
void add(RenderingResourceIdentifier renderingResourceIdentifier, Ref<ImageBuffer>&& imageBuffer)
{
- if (m_resources.add(renderingResourceIdentifier, RefPtr<ImageBuffer>(WTFMove(imageBuffer))).isNewEntry)
- ++m_imageBufferCount;
+ m_resources.add(renderingResourceIdentifier, WTFMove(imageBuffer));
}
void add(RenderingResourceIdentifier renderingResourceIdentifier, Ref<NativeImage>&& image)
{
- if (m_resources.add(renderingResourceIdentifier, RefPtr<NativeImage>(WTFMove(image))).isNewEntry)
- ++m_nativeImageCount;
+ m_resources.add(renderingResourceIdentifier, WTFMove(image));
}
void add(RenderingResourceIdentifier renderingResourceIdentifier, Ref<Font>&& font)
{
- if (m_resources.add(renderingResourceIdentifier, RefPtr<Font>(WTFMove(font))).isNewEntry)
- ++m_fontCount;
+ m_resources.add(renderingResourceIdentifier, WTFMove(font));
}
- ImageBuffer* getImageBuffer(RenderingResourceIdentifier renderingResourceIdentifier) const
+ ImageBuffer* getImageBuffer(RenderingResourceIdentifier renderingResourceIdentifier) const final
{
return get<ImageBuffer>(renderingResourceIdentifier);
}
- NativeImage* getNativeImage(RenderingResourceIdentifier renderingResourceIdentifier) const
+ NativeImage* getNativeImage(RenderingResourceIdentifier renderingResourceIdentifier) const final
{
return get<NativeImage>(renderingResourceIdentifier);
}
- Font* getFont(RenderingResourceIdentifier renderingResourceIdentifier) const
+ Font* getFont(RenderingResourceIdentifier renderingResourceIdentifier) const final
{
return get<Font>(renderingResourceIdentifier);
}
- bool hasImageBuffer() const
- {
- return m_imageBufferCount;
- }
-
- bool hasNativeImage() const
- {
- return m_nativeImageCount;
- }
-
- bool hasFont() const
- {
- return m_fontCount;
- }
-
- bool removeImageBuffer(RenderingResourceIdentifier renderingResourceIdentifier)
- {
- return remove<ImageBuffer>(renderingResourceIdentifier, m_imageBufferCount);
- }
-
- bool removeNativeImage(RenderingResourceIdentifier renderingResourceIdentifier)
- {
- return remove<NativeImage>(renderingResourceIdentifier, m_nativeImageCount);
- }
-
- bool removeFont(RenderingResourceIdentifier renderingResourceIdentifier)
- {
- return remove<Font>(renderingResourceIdentifier, m_fontCount);
- }
-
void clear()
{
m_resources.clear();
- m_imageBufferCount = 0;
- m_nativeImageCount = 0;
- m_fontCount = 0;
}
- void deleteAllFonts()
- {
- m_resources.removeIf([] (const auto& resource) {
- return std::holds_alternative<RefPtr<Font>>(resource.value);
- });
- m_fontCount = 0;
- }
-
private:
template <typename T>
T* get(RenderingResourceIdentifier renderingResourceIdentifier) const
@@ -123,30 +88,12 @@
auto iterator = m_resources.find(renderingResourceIdentifier);
if (iterator == m_resources.end())
return nullptr;
- if (!std::holds_alternative<RefPtr<T>>(iterator->value))
- return nullptr;
- return WTF::get<RefPtr<T>>(iterator->value).get();
+ ASSERT(std::holds_alternative<Ref<T>>(iterator->value));
+ return std::get<Ref<T>>(iterator->value).ptr();
}
- template <typename T>
- bool remove(RenderingResourceIdentifier renderingResourceIdentifier, unsigned& counter)
- {
- auto iterator = m_resources.find(renderingResourceIdentifier);
- if (iterator == m_resources.end())
- return false;
- if (!std::holds_alternative<RefPtr<T>>(iterator->value))
- return false;
- auto result = m_resources.remove(iterator);
- ASSERT(result);
- --counter;
- return result;
- }
-
- using Resource = Variant<RefPtr<ImageBuffer>, RefPtr<NativeImage>, RefPtr<Font>>;
+ using Resource = Variant<std::monostate, Ref<ImageBuffer>, Ref<NativeImage>, Ref<Font>>;
HashMap<RenderingResourceIdentifier, Resource> m_resources;
- unsigned m_imageBufferCount { 0 };
- unsigned m_nativeImageCount { 0 };
- unsigned m_fontCount { 0 };
};
}
Modified: trunk/Source/WebKit/ChangeLog (284047 => 284048)
--- trunk/Source/WebKit/ChangeLog 2021-10-12 22:40:20 UTC (rev 284047)
+++ trunk/Source/WebKit/ChangeLog 2021-10-12 22:42:19 UTC (rev 284048)
@@ -1,3 +1,40 @@
+2021-10-12 Myles C. Maxfield <[email protected]>
+
+ [GPU Process] Unique RenderingResourceIdentifiers Part 9: Finish migrating RemoteResourceCache to QualifiedRenderingResourceIdentifier
+ https://bugs.webkit.org/show_bug.cgi?id=231414
+ <rdar://problem/84015584>
+
+ Reviewed by Said Abou-Hallawa.
+
+ Now that DisplayList::ResourceHeap exists, we can make a ResourceHeap subclass specifically for
+ the GPU process. The implementation of this class holds QualifiedRenderingResourceIdentifiers
+ instead of RenderingResourceIdentifier.
+
+ * GPUProcess/graphics/QualifiedResourceHeap.h: Added.
+ (WebKit::QualifiedResourceHeap::QualifiedResourceHeap):
+ (WebKit::QualifiedResourceHeap::add):
+ (WebKit::QualifiedResourceHeap::getImageBuffer const):
+ (WebKit::QualifiedResourceHeap::getNativeImage const):
+ (WebKit::QualifiedResourceHeap::getFont const):
+ (WebKit::QualifiedResourceHeap::hasImageBuffer const):
+ (WebKit::QualifiedResourceHeap::hasNativeImage const):
+ (WebKit::QualifiedResourceHeap::hasFont const):
+ (WebKit::QualifiedResourceHeap::removeImageBuffer):
+ (WebKit::QualifiedResourceHeap::removeNativeImage):
+ (WebKit::QualifiedResourceHeap::removeFont):
+ (WebKit::QualifiedResourceHeap::deleteAllFonts):
+ * GPUProcess/graphics/RemoteResourceCache.cpp:
+ (WebKit::RemoteResourceCache::RemoteResourceCache):
+ (WebKit::RemoteResourceCache::cacheImageBuffer):
+ (WebKit::RemoteResourceCache::cachedImageBuffer const):
+ (WebKit::RemoteResourceCache::cacheNativeImage):
+ (WebKit::RemoteResourceCache::cachedNativeImage const):
+ (WebKit::RemoteResourceCache::cacheFont):
+ (WebKit::RemoteResourceCache::cachedFont const):
+ (WebKit::RemoteResourceCache::maybeRemoveResource):
+ * GPUProcess/graphics/RemoteResourceCache.h:
+ * WebKit.xcodeproj/project.pbxproj:
+
2021-10-12 Simon Fraser <[email protected]>
Scrolling thread animations need to commit layers on the scrolling thread
Added: trunk/Source/WebKit/GPUProcess/graphics/QualifiedResourceHeap.h (0 => 284048)
--- trunk/Source/WebKit/GPUProcess/graphics/QualifiedResourceHeap.h (rev 0)
+++ trunk/Source/WebKit/GPUProcess/graphics/QualifiedResourceHeap.h 2021-10-12 22:42:19 UTC (rev 284048)
@@ -0,0 +1,224 @@
+/*
+ * Copyright (C) 2021 Apple Inc. All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 1. Redistributions of source code must retain the above copyright
+ * notice, this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ * notice, this list of conditions and the following disclaimer in the
+ * documentation and/or other materials provided with the distribution.
+ *
+ * THIS SOFTWARE IS PROVIDED BY APPLE INC. ``AS IS'' AND ANY
+ * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
+ * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL APPLE INC. OR
+ * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
+ * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
+ * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
+ * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY
+ * OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+#pragma once
+
+#if ENABLE(GPU_PROCESS)
+
+#include "QualifiedRenderingResourceIdentifier.h"
+#include <WebCore/DisplayListResourceHeap.h>
+#include <WebCore/Font.h>
+#include <WebCore/ImageBuffer.h>
+#include <WebCore/NativeImage.h>
+#include <WebCore/ProcessIdentifier.h>
+#include <wtf/HashMap.h>
+
+namespace WebKit {
+
+class QualifiedResourceHeap : public WebCore::DisplayList::ResourceHeap {
+public:
+ QualifiedResourceHeap(WebCore::ProcessIdentifier webProcessIdentifier)
+ : m_webProcessIdentifier(webProcessIdentifier)
+ {
+ }
+
+ void add(QualifiedRenderingResourceIdentifier renderingResourceIdentifier, Ref<WebCore::ImageBuffer>&& imageBuffer)
+ {
+ add(renderingResourceIdentifier, WTFMove(imageBuffer), m_imageBufferCount);
+ }
+
+ void add(QualifiedRenderingResourceIdentifier renderingResourceIdentifier, Ref<WebCore::NativeImage>&& image)
+ {
+ add(renderingResourceIdentifier, WTFMove(image), m_nativeImageCount);
+ }
+
+ void add(QualifiedRenderingResourceIdentifier renderingResourceIdentifier, Ref<WebCore::Font>&& font)
+ {
+ add(renderingResourceIdentifier, WTFMove(font), m_fontCount);
+ }
+
+ WebCore::ImageBuffer* getImageBuffer(WebCore::RenderingResourceIdentifier renderingResourceIdentifier) const final
+ {
+ return get<WebCore::ImageBuffer>({ renderingResourceIdentifier, m_webProcessIdentifier });
+ }
+
+ WebCore::NativeImage* getNativeImage(WebCore::RenderingResourceIdentifier renderingResourceIdentifier) const final
+ {
+ return get<WebCore::NativeImage>({ renderingResourceIdentifier, m_webProcessIdentifier });
+ }
+
+ WebCore::Font* getFont(WebCore::RenderingResourceIdentifier renderingResourceIdentifier) const final
+ {
+ return get<WebCore::Font>({ renderingResourceIdentifier, m_webProcessIdentifier });
+ }
+
+ WebCore::ImageBuffer* getImageBuffer(QualifiedRenderingResourceIdentifier renderingResourceIdentifier) const
+ {
+ return get<WebCore::ImageBuffer>(renderingResourceIdentifier);
+ }
+
+ WebCore::NativeImage* getNativeImage(QualifiedRenderingResourceIdentifier renderingResourceIdentifier) const
+ {
+ return get<WebCore::NativeImage>(renderingResourceIdentifier);
+ }
+
+ WebCore::Font* getFont(QualifiedRenderingResourceIdentifier renderingResourceIdentifier) const
+ {
+ return get<WebCore::Font>(renderingResourceIdentifier);
+ }
+
+ bool hasImageBuffer() const
+ {
+ checkInvariants();
+ return m_imageBufferCount;
+ }
+
+ bool hasNativeImage() const
+ {
+ checkInvariants();
+ return m_nativeImageCount;
+ }
+
+ bool hasFont() const
+ {
+ checkInvariants();
+ return m_fontCount;
+ }
+
+ bool removeImageBuffer(QualifiedRenderingResourceIdentifier renderingResourceIdentifier)
+ {
+ return remove<WebCore::ImageBuffer>(renderingResourceIdentifier, m_imageBufferCount);
+ }
+
+ bool removeNativeImage(QualifiedRenderingResourceIdentifier renderingResourceIdentifier)
+ {
+ return remove<WebCore::NativeImage>(renderingResourceIdentifier, m_nativeImageCount);
+ }
+
+ bool removeFont(QualifiedRenderingResourceIdentifier renderingResourceIdentifier)
+ {
+ return remove<WebCore::Font>(renderingResourceIdentifier, m_fontCount);
+ }
+
+ void deleteAllFonts()
+ {
+ checkInvariants();
+
+ if (!m_fontCount)
+ return;
+
+ m_resources.removeIf([] (const auto& resource) {
+ return std::holds_alternative<Ref<WebCore::Font>>(resource.value);
+ });
+
+ m_fontCount = 0;
+
+ checkInvariants();
+ }
+
+private:
+ template <typename T>
+ void add(QualifiedRenderingResourceIdentifier renderingResourceIdentifier, Ref<T>&& object, unsigned& counter)
+ {
+ checkInvariants();
+
+ ASSERT(renderingResourceIdentifier.processIdentifier() == m_webProcessIdentifier);
+ if (m_resources.add(renderingResourceIdentifier, WTFMove(object)).isNewEntry)
+ ++counter;
+
+ checkInvariants();
+ }
+
+ template <typename T>
+ T* get(QualifiedRenderingResourceIdentifier renderingResourceIdentifier) const
+ {
+ checkInvariants();
+
+ auto iterator = m_resources.find(renderingResourceIdentifier);
+ if (iterator == m_resources.end())
+ return nullptr;
+ ASSERT(std::holds_alternative<Ref<T>>(iterator->value));
+ return WTF::get<Ref<T>>(iterator->value).ptr();
+ }
+
+ template <typename T>
+ bool remove(QualifiedRenderingResourceIdentifier renderingResourceIdentifier, unsigned& counter)
+ {
+ checkInvariants();
+
+ if (!counter)
+ return false;
+
+ auto iterator = m_resources.find(renderingResourceIdentifier);
+ if (iterator == m_resources.end())
+ return false;
+ if (!std::holds_alternative<Ref<T>>(iterator->value))
+ return false;
+
+ auto result = m_resources.remove(iterator);
+ ASSERT(result);
+ --counter;
+
+ checkInvariants();
+
+ return result;
+ }
+
+ void checkInvariants() const
+ {
+#if ASSERT_ENABLED
+ unsigned imageBufferCount = 0;
+ unsigned nativeImageCount = 0;
+ unsigned fontCount = 0;
+ for (const auto& pair : m_resources) {
+ WTF::switchOn(pair.value, [&] (std::monostate) {
+ ASSERT_NOT_REACHED();
+ }, [&] (const Ref<WebCore::ImageBuffer>&) {
+ ++imageBufferCount;
+ }, [&] (const Ref<WebCore::NativeImage>&) {
+ ++nativeImageCount;
+ }, [&] (const Ref<WebCore::Font>&) {
+ ++fontCount;
+ });
+ }
+ ASSERT(imageBufferCount == m_imageBufferCount);
+ ASSERT(nativeImageCount == m_nativeImageCount);
+ ASSERT(fontCount == m_fontCount);
+ ASSERT(m_resources.size() == m_imageBufferCount + m_nativeImageCount + m_fontCount);
+#endif
+ }
+
+ using Resource = Variant<std::monostate, Ref<WebCore::ImageBuffer>, Ref<WebCore::NativeImage>, Ref<WebCore::Font>>;
+ HashMap<QualifiedRenderingResourceIdentifier, Resource> m_resources;
+ WebCore::ProcessIdentifier m_webProcessIdentifier;
+ unsigned m_imageBufferCount { 0 };
+ unsigned m_nativeImageCount { 0 };
+ unsigned m_fontCount { 0 };
+
+};
+
+} // namespace WebKit
+
+#endif
Property changes on: trunk/Source/WebKit/GPUProcess/graphics/QualifiedResourceHeap.h
___________________________________________________________________
Added: svn:eol-style
+native
\ No newline at end of property
Added: svn:keywords
+Author Date Id Rev URL
\ No newline at end of property
Modified: trunk/Source/WebKit/GPUProcess/graphics/RemoteResourceCache.cpp (284047 => 284048)
--- trunk/Source/WebKit/GPUProcess/graphics/RemoteResourceCache.cpp 2021-10-12 22:40:20 UTC (rev 284047)
+++ trunk/Source/WebKit/GPUProcess/graphics/RemoteResourceCache.cpp 2021-10-12 22:42:19 UTC (rev 284048)
@@ -32,13 +32,12 @@
using namespace WebCore;
RemoteResourceCache::RemoteResourceCache(ProcessIdentifier webProcessIdentifier)
- : m_webProcessIdentifier(webProcessIdentifier)
+ : m_resourceHeap(webProcessIdentifier)
{
}
RemoteResourceCache::RemoteResourceCache(RemoteResourceCache&& other)
- : m_webProcessIdentifier(other.m_webProcessIdentifier)
- , m_resourceHeap(WTFMove(other.m_resourceHeap))
+ : m_resourceHeap(WTFMove(other.m_resourceHeap))
, m_resourceUseCounters(WTFMove(other.m_resourceUseCounters))
{
updateHasActiveDrawables();
@@ -47,8 +46,7 @@
void RemoteResourceCache::cacheImageBuffer(Ref<ImageBuffer>&& imageBuffer, QualifiedRenderingResourceIdentifier renderingResourceIdentifier)
{
ASSERT(renderingResourceIdentifier.object() == imageBuffer->renderingResourceIdentifier());
- ASSERT(renderingResourceIdentifier.processIdentifier() == m_webProcessIdentifier);
- m_resourceHeap.add(renderingResourceIdentifier.object(), WTFMove(imageBuffer));
+ m_resourceHeap.add(renderingResourceIdentifier, WTFMove(imageBuffer));
updateHasActiveDrawables();
ensureResourceUseCounter(renderingResourceIdentifier);
@@ -56,15 +54,13 @@
ImageBuffer* RemoteResourceCache::cachedImageBuffer(QualifiedRenderingResourceIdentifier renderingResourceIdentifier) const
{
- ASSERT(renderingResourceIdentifier.processIdentifier() == m_webProcessIdentifier);
- return m_resourceHeap.getImageBuffer(renderingResourceIdentifier.object());
+ return m_resourceHeap.getImageBuffer(renderingResourceIdentifier);
}
void RemoteResourceCache::cacheNativeImage(Ref<NativeImage>&& image, QualifiedRenderingResourceIdentifier renderingResourceIdentifier)
{
ASSERT(renderingResourceIdentifier.object() == image->renderingResourceIdentifier());
- ASSERT(renderingResourceIdentifier.processIdentifier() == m_webProcessIdentifier);
- m_resourceHeap.add(renderingResourceIdentifier.object(), WTFMove(image));
+ m_resourceHeap.add(renderingResourceIdentifier, WTFMove(image));
updateHasActiveDrawables();
ensureResourceUseCounter(renderingResourceIdentifier);
@@ -72,15 +68,13 @@
NativeImage* RemoteResourceCache::cachedNativeImage(QualifiedRenderingResourceIdentifier renderingResourceIdentifier) const
{
- ASSERT(renderingResourceIdentifier.processIdentifier() == m_webProcessIdentifier);
- return m_resourceHeap.getNativeImage(renderingResourceIdentifier.object());
+ return m_resourceHeap.getNativeImage(renderingResourceIdentifier);
}
void RemoteResourceCache::cacheFont(Ref<Font>&& font, QualifiedRenderingResourceIdentifier renderingResourceIdentifier)
{
ASSERT(renderingResourceIdentifier.object() == font->renderingResourceIdentifier());
- ASSERT(renderingResourceIdentifier.processIdentifier() == m_webProcessIdentifier);
- m_resourceHeap.add(renderingResourceIdentifier.object(), WTFMove(font));
+ m_resourceHeap.add(renderingResourceIdentifier, WTFMove(font));
ensureResourceUseCounter(renderingResourceIdentifier);
}
@@ -87,7 +81,7 @@
Font* RemoteResourceCache::cachedFont(QualifiedRenderingResourceIdentifier renderingResourceIdentifier) const
{
- return m_resourceHeap.getFont(renderingResourceIdentifier.object());
+ return m_resourceHeap.getFont(renderingResourceIdentifier);
}
void RemoteResourceCache::ensureResourceUseCounter(QualifiedRenderingResourceIdentifier renderingResourceIdentifier)
@@ -147,12 +141,12 @@
m_resourceUseCounters.remove(iterator);
- if (m_resourceHeap.removeImageBuffer(renderingResourceIdentifier.object())
- || m_resourceHeap.removeNativeImage(renderingResourceIdentifier.object())) {
+ if (m_resourceHeap.removeImageBuffer(renderingResourceIdentifier)
+ || m_resourceHeap.removeNativeImage(renderingResourceIdentifier)) {
updateHasActiveDrawables();
return true;
}
- if (m_resourceHeap.removeFont(renderingResourceIdentifier.object()))
+ if (m_resourceHeap.removeFont(renderingResourceIdentifier))
return true;
// Caching the remote resource should have happened before releasing it.
Modified: trunk/Source/WebKit/GPUProcess/graphics/RemoteResourceCache.h (284047 => 284048)
--- trunk/Source/WebKit/GPUProcess/graphics/RemoteResourceCache.h 2021-10-12 22:40:20 UTC (rev 284047)
+++ trunk/Source/WebKit/GPUProcess/graphics/RemoteResourceCache.h 2021-10-12 22:42:19 UTC (rev 284048)
@@ -28,6 +28,7 @@
#if ENABLE(GPU_PROCESS)
#include "QualifiedRenderingResourceIdentifier.h"
+#include "QualifiedResourceHeap.h"
#include <WebCore/Font.h>
#include <WebCore/ImageBuffer.h>
#include <WebCore/NativeImage.h>
@@ -85,12 +86,11 @@
void updateHasActiveDrawables();
- WebCore::ProcessIdentifier m_webProcessIdentifier;
+ QualifiedResourceHeap m_resourceHeap;
- WebCore::DisplayList::ResourceHeap m_resourceHeap;
+ ResourceUseCountersMap m_resourceUseCounters;
+
std::atomic<bool> m_hasActiveDrawables { false };
-
- ResourceUseCountersMap m_resourceUseCounters;
};
} // namespace WebKit
Modified: trunk/Source/WebKit/WebKit.xcodeproj/project.pbxproj (284047 => 284048)
--- trunk/Source/WebKit/WebKit.xcodeproj/project.pbxproj 2021-10-12 22:40:20 UTC (rev 284047)
+++ trunk/Source/WebKit/WebKit.xcodeproj/project.pbxproj 2021-10-12 22:42:19 UTC (rev 284048)
@@ -3100,6 +3100,7 @@
1CA8B944127C882A00576C2B /* WebInspectorUIProxyMessages.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; name = WebInspectorUIProxyMessages.h; path = DerivedSources/WebKit2/WebInspectorUIProxyMessages.h; sourceTree = BUILT_PRODUCTS_DIR; };
1CBBE49E19B66C53006B7D81 /* WebInspectorUIMessageReceiver.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = WebInspectorUIMessageReceiver.cpp; path = DerivedSources/WebKit2/WebInspectorUIMessageReceiver.cpp; sourceTree = BUILT_PRODUCTS_DIR; };
1CBBE49F19B66C53006B7D81 /* WebInspectorUIMessages.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; name = WebInspectorUIMessages.h; path = DerivedSources/WebKit2/WebInspectorUIMessages.h; sourceTree = BUILT_PRODUCTS_DIR; };
+ 1CBF9012271018B5000C457D /* QualifiedResourceHeap.h */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.c.h; path = QualifiedResourceHeap.h; sourceTree = "<group>"; };
1CC54AFD270F9654005BF8BE /* QualifiedRenderingResourceIdentifier.h */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.c.h; path = QualifiedRenderingResourceIdentifier.h; sourceTree = "<group>"; };
1CF18F3E26BB5D90004B1722 /* LogInitialization.cpp */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.cpp.cpp; path = LogInitialization.cpp; sourceTree = "<group>"; };
1D0530C9258EAB4400E436F7 /* combine-feature-flags-plist.py */ = {isa = PBXFileReference; lastKnownFileType = text.script.python; path = "combine-feature-flags-plist.py"; sourceTree = "<group>"; };
@@ -9110,6 +9111,7 @@
F4094CBB255304AF003D73E3 /* DisplayListReaderHandle.h */,
55AD09432408A0E600DE4D2F /* PlatformRemoteImageBuffer.h */,
1CC54AFD270F9654005BF8BE /* QualifiedRenderingResourceIdentifier.h */,
+ 1CBF9012271018B5000C457D /* QualifiedResourceHeap.h */,
F48BB8E026F96392001C1C40 /* RemoteDisplayListRecorder.cpp */,
F48BB8DF26F96392001C1C40 /* RemoteDisplayListRecorder.h */,
F451C1002703D853002BA03B /* RemoteDisplayListRecorder.messages.in */,
Modified: trunk/Tools/ChangeLog (284047 => 284048)
--- trunk/Tools/ChangeLog 2021-10-12 22:40:20 UTC (rev 284047)
+++ trunk/Tools/ChangeLog 2021-10-12 22:42:19 UTC (rev 284048)
@@ -1,3 +1,14 @@
+2021-10-12 Myles C. Maxfield <[email protected]>
+
+ [GPU Process] Unique RenderingResourceIdentifiers Part 9: Finish migrating RemoteResourceCache to QualifiedRenderingResourceIdentifier
+ https://bugs.webkit.org/show_bug.cgi?id=231414
+ <rdar://problem/84015584>
+
+ Reviewed by Said Abou-Hallawa.
+
+ * TestWebKitAPI/Tests/WebCore/cg/DisplayListTestsCG.cpp:
+ (TestWebKitAPI::TEST):
+
2021-10-12 Gabriel Nava Marino <[email protected]>
WebKitTestRunner should check mainFrameURL exists in InjectedBundlePage::willSendRequestForFrame
Modified: trunk/Tools/TestWebKitAPI/Tests/WebCore/cg/DisplayListTestsCG.cpp (284047 => 284048)
--- trunk/Tools/TestWebKitAPI/Tests/WebCore/cg/DisplayListTestsCG.cpp 2021-10-12 22:40:20 UTC (rev 284047)
+++ trunk/Tools/TestWebKitAPI/Tests/WebCore/cg/DisplayListTestsCG.cpp 2021-10-12 22:42:19 UTC (rev 284048)
@@ -73,7 +73,7 @@
{
auto imageBuffer = ImageBuffer::create({ 100, 100 }, RenderingMode::Unaccelerated, 1, colorSpace, PixelFormat::BGRA8);
- ResourceHeap resourceHeap;
+ LocalResourceHeap resourceHeap;
resourceHeap.add(imageBufferIdentifier, imageBuffer.releaseNonNull());
Replayer replayer { context, list, &resourceHeap };
