Title: [269503] trunk/Source
Revision
269503
Author
[email protected]
Date
2020-11-05 23:27:31 -0800 (Thu, 05 Nov 2020)

Log Message

[GPU Process] Use the Ref counting of ImageBuffer to control its life cycle in Web Process and GPU Process
https://bugs.webkit.org/show_bug.cgi?id=218529

Reviewed by Simon Fraser.

Source/WebCore:

Every ImageBuffer will have a valid RenderingResourceIdentifer. It can be
either generated when the ImageBuffer is created. Or it can be set by the
caller. Setting it by the caller will happen only in the GPUP where we
need it match what was generated in the WebP.

When recording a DrawImageBuffer item, a Ref<ImageBuffer> of the source
ImageBuffer will be added to a HashSet in DisplayList. The goal is keep
this ImageBuffer alive till the DisplayList is cleared. The HashSet will
be cleared in DisplayList::clear() which will happen when either the
DisplayList is replayed back or sent to the GPUP.

This HashSet can be used to resolve the RenderingResourceIdentifer to an
ImageBuffer when replaying back the DisplayList either in WebP or in GPUP.

* platform/graphics/ConcreteImageBuffer.h:
(WebCore::ConcreteImageBuffer::ConcreteImageBuffer):
* platform/graphics/GraphicsContext.cpp:
(WebCore::GraphicsContext::drawImageBuffer):
(WebCore::GraphicsContext::drawConsumingImageBuffer):
* platform/graphics/GraphicsContextImpl.h:
* platform/graphics/ImageBuffer.h:
* platform/graphics/cairo/GraphicsContextImplCairo.cpp:
(WebCore::GraphicsContextImplCairo::drawImageBuffer):
* platform/graphics/cairo/GraphicsContextImplCairo.h:
* platform/graphics/displaylists/DisplayList.cpp:
(WebCore::DisplayList::DisplayList::clear):
* platform/graphics/displaylists/DisplayList.h:
(WebCore::DisplayList::DisplayList::imageBuffers const):
(WebCore::DisplayList::DisplayList::cacheImageBuffer):
* platform/graphics/displaylists/DisplayListItemType.cpp:
(WebCore::DisplayList::isInlineItem):
* platform/graphics/displaylists/DisplayListItems.cpp:
(WebCore::DisplayList::DrawImageBuffer::DrawImageBuffer):
(WebCore::DisplayList::DrawImageBuffer::apply const):
* platform/graphics/displaylists/DisplayListItems.h:
* platform/graphics/displaylists/DisplayListRecorder.cpp:
(WebCore::DisplayList::Recorder::drawImageBuffer):
* platform/graphics/displaylists/DisplayListRecorder.h:
(WebCore::DisplayList::Recorder::Delegate::~Delegate):
(WebCore::DisplayList::Recorder::Delegate::lockRemoteImageBuffer): Deleted.
* platform/graphics/displaylists/DisplayListReplayer.cpp:
(WebCore::DisplayList::Replayer::Replayer):
(WebCore::DisplayList::Replayer::applyItem):
(WebCore::DisplayList::Replayer::replay):
* platform/graphics/displaylists/DisplayListReplayer.h:
* platform/graphics/nicosia/cairo/NicosiaCairoOperationRecorder.cpp:
(Nicosia::CairoOperationRecorder::drawImageBuffer):
* platform/graphics/nicosia/cairo/NicosiaCairoOperationRecorder.h:

Source/WebKit:

When a DrawImageBuffer item is appended to DisplayList, a Ref<ImageBuffer>
will be cached till the DisplayList items list is cleared. So no need to
lock the remote resource in RemoteResourceCacheProxy.

All we need to is to pass the ImageBufferHashMap which is maintained by
the DisplayList or by RemoteResourceCache to the DisplayList::Replayer.
It is going to be used to resolve the RenderingResourceIdentifer to an
ImageBuffer so the DrawImageBuffer can be applied.

No need to special-case DrawImageBuffer::apply() in the RemoteImageBuffer.

* GPUProcess/graphics/RemoteImageBuffer.h:
(WebKit::RemoteImageBuffer::RemoteImageBuffer):
* GPUProcess/graphics/RemoteRenderingBackend.cpp:
(WebKit::RemoteRenderingBackend::createImageBuffer):
(WebKit::RemoteRenderingBackend::applyResourceItem): Deleted.
* GPUProcess/graphics/RemoteRenderingBackend.h:
(WebKit::RemoteRenderingBackend::remoteResourceCache):
* GPUProcess/graphics/RemoteResourceCache.cpp:
(WebKit::RemoteResourceCache::cacheImageBuffer):
* GPUProcess/graphics/RemoteResourceCache.h:
(WebKit::RemoteResourceCache::imageBuffers const):
* WebProcess/GPU/graphics/RemoteImageBufferProxy.h:
(WebKit::RemoteImageBufferProxy::~RemoteImageBufferProxy):
* WebProcess/GPU/graphics/RemoteRenderingBackendProxy.cpp:
(WebKit::RemoteRenderingBackendProxy::releaseRemoteResource):
* WebProcess/GPU/graphics/RemoteRenderingBackendProxy.h:
* WebProcess/GPU/graphics/RemoteResourceCacheProxy.cpp:
(WebKit::RemoteResourceCacheProxy::releaseImageBuffer):
(WebKit::RemoteResourceCacheProxy::RemoteResourceCacheProxy): Deleted.
(WebKit::RemoteResourceCacheProxy::lockRemoteImageBufferForRemoteClient): Deleted.
(WebKit::RemoteResourceCacheProxy::lockRemoteResourceForRemoteClient): Deleted.
(WebKit::RemoteResourceCacheProxy::releaseRemoteResource): Deleted.
(WebKit::RemoteResourceCacheProxy::unlockRemoteResourcesForRemoteClient): Deleted.
* WebProcess/GPU/graphics/RemoteResourceCacheProxy.h:

Modified Paths

Diff

Modified: trunk/Source/WebCore/ChangeLog (269502 => 269503)


--- trunk/Source/WebCore/ChangeLog	2020-11-06 04:18:57 UTC (rev 269502)
+++ trunk/Source/WebCore/ChangeLog	2020-11-06 07:27:31 UTC (rev 269503)
@@ -1,3 +1,59 @@
+2020-11-05  Said Abou-Hallawa  <[email protected]>
+
+        [GPU Process] Use the Ref counting of ImageBuffer to control its life cycle in Web Process and GPU Process
+        https://bugs.webkit.org/show_bug.cgi?id=218529
+
+        Reviewed by Simon Fraser.
+
+        Every ImageBuffer will have a valid RenderingResourceIdentifer. It can be
+        either generated when the ImageBuffer is created. Or it can be set by the
+        caller. Setting it by the caller will happen only in the GPUP where we
+        need it match what was generated in the WebP.
+
+        When recording a DrawImageBuffer item, a Ref<ImageBuffer> of the source
+        ImageBuffer will be added to a HashSet in DisplayList. The goal is keep
+        this ImageBuffer alive till the DisplayList is cleared. The HashSet will
+        be cleared in DisplayList::clear() which will happen when either the 
+        DisplayList is replayed back or sent to the GPUP.
+
+        This HashSet can be used to resolve the RenderingResourceIdentifer to an
+        ImageBuffer when replaying back the DisplayList either in WebP or in GPUP.
+
+        * platform/graphics/ConcreteImageBuffer.h:
+        (WebCore::ConcreteImageBuffer::ConcreteImageBuffer):
+        * platform/graphics/GraphicsContext.cpp:
+        (WebCore::GraphicsContext::drawImageBuffer):
+        (WebCore::GraphicsContext::drawConsumingImageBuffer):
+        * platform/graphics/GraphicsContextImpl.h:
+        * platform/graphics/ImageBuffer.h:
+        * platform/graphics/cairo/GraphicsContextImplCairo.cpp:
+        (WebCore::GraphicsContextImplCairo::drawImageBuffer):
+        * platform/graphics/cairo/GraphicsContextImplCairo.h:
+        * platform/graphics/displaylists/DisplayList.cpp:
+        (WebCore::DisplayList::DisplayList::clear):
+        * platform/graphics/displaylists/DisplayList.h:
+        (WebCore::DisplayList::DisplayList::imageBuffers const):
+        (WebCore::DisplayList::DisplayList::cacheImageBuffer):
+        * platform/graphics/displaylists/DisplayListItemType.cpp:
+        (WebCore::DisplayList::isInlineItem):
+        * platform/graphics/displaylists/DisplayListItems.cpp:
+        (WebCore::DisplayList::DrawImageBuffer::DrawImageBuffer):
+        (WebCore::DisplayList::DrawImageBuffer::apply const):
+        * platform/graphics/displaylists/DisplayListItems.h:
+        * platform/graphics/displaylists/DisplayListRecorder.cpp:
+        (WebCore::DisplayList::Recorder::drawImageBuffer):
+        * platform/graphics/displaylists/DisplayListRecorder.h:
+        (WebCore::DisplayList::Recorder::Delegate::~Delegate):
+        (WebCore::DisplayList::Recorder::Delegate::lockRemoteImageBuffer): Deleted.
+        * platform/graphics/displaylists/DisplayListReplayer.cpp:
+        (WebCore::DisplayList::Replayer::Replayer):
+        (WebCore::DisplayList::Replayer::applyItem):
+        (WebCore::DisplayList::Replayer::replay):
+        * platform/graphics/displaylists/DisplayListReplayer.h:
+        * platform/graphics/nicosia/cairo/NicosiaCairoOperationRecorder.cpp:
+        (Nicosia::CairoOperationRecorder::drawImageBuffer):
+        * platform/graphics/nicosia/cairo/NicosiaCairoOperationRecorder.h:
+
 2020-11-05  Chris Dumez  <[email protected]>
 
         window.event should not be affected by nodes moving post-dispatch

Modified: trunk/Source/WebCore/platform/graphics/ConcreteImageBuffer.h (269502 => 269503)


--- trunk/Source/WebCore/platform/graphics/ConcreteImageBuffer.h	2020-11-06 04:18:57 UTC (rev 269502)
+++ trunk/Source/WebCore/platform/graphics/ConcreteImageBuffer.h	2020-11-06 07:27:31 UTC (rev 269503)
@@ -54,15 +54,16 @@
     bool isAccelerated() const override { return BackendType::isAccelerated; }
 
 protected:
-    ConcreteImageBuffer(std::unique_ptr<BackendType>&& backend)
+    ConcreteImageBuffer(std::unique_ptr<BackendType>&& backend = nullptr, RenderingResourceIdentifier renderingResourceIdentifier = RenderingResourceIdentifier::generate())
         : m_backend(WTFMove(backend))
+        , m_renderingResourceIdentifier(renderingResourceIdentifier)
     {
     }
 
-    ConcreteImageBuffer() = default;
-
     virtual BackendType* ensureBackendCreated() const { return m_backend.get(); }
 
+    RenderingResourceIdentifier renderingResourceIdentifier() const override { return m_renderingResourceIdentifier; }
+
     GraphicsContext& context() const override
     {
         ASSERT(m_backend);
@@ -250,6 +251,7 @@
     }
 
     std::unique_ptr<BackendType> m_backend;
+    RenderingResourceIdentifier m_renderingResourceIdentifier;
 };
 
 } // namespace WebCore

Modified: trunk/Source/WebCore/platform/graphics/GraphicsContext.cpp (269502 => 269503)


--- trunk/Source/WebCore/platform/graphics/GraphicsContext.cpp	2020-11-06 04:18:57 UTC (rev 269502)
+++ trunk/Source/WebCore/platform/graphics/GraphicsContext.cpp	2020-11-06 07:27:31 UTC (rev 269503)
@@ -812,8 +812,10 @@
     if (paintingDisabled())
         return;
 
-    if (m_impl && m_impl->drawImageBuffer(image, destination, source, options))
+    if (m_impl) {
+        m_impl->drawImageBuffer(image, destination, source, options);
         return;
+    }
 
     InterpolationQualityMaintainer interpolationQualityForThisScope(*this, options.interpolationQuality());
     image.draw(*this, destination, source, options);
@@ -840,8 +842,10 @@
     if (paintingDisabled() || !image)
         return;
 
-    if (m_impl && m_impl->drawImageBuffer(*image, destination, source, options))
+    if (m_impl) {
+        m_impl->drawImageBuffer(*image, destination, source, options);
         return;
+    }
 
     InterpolationQualityMaintainer interpolationQualityForThisScope(*this, options.interpolationQuality());
     ImageBuffer::drawConsuming(WTFMove(image), *this, destination, source, options);

Modified: trunk/Source/WebCore/platform/graphics/GraphicsContextImpl.h (269502 => 269503)


--- trunk/Source/WebCore/platform/graphics/GraphicsContextImpl.h	2020-11-06 04:18:57 UTC (rev 269502)
+++ trunk/Source/WebCore/platform/graphics/GraphicsContextImpl.h	2020-11-06 07:27:31 UTC (rev 269503)
@@ -73,7 +73,7 @@
     virtual ImageDrawResult drawTiledImage(Image&, const FloatRect& destination, const FloatPoint& source, const FloatSize& tileSize, const FloatSize& spacing, const ImagePaintingOptions&) = 0;
     virtual ImageDrawResult drawTiledImage(Image&, const FloatRect& destination, const FloatRect& source, const FloatSize& tileScaleFactor, Image::TileRule hRule, Image::TileRule vRule, const ImagePaintingOptions&) = 0;
 
-    virtual bool drawImageBuffer(ImageBuffer&, const FloatRect& destination, const FloatRect& source, const ImagePaintingOptions&) = 0;
+    virtual void drawImageBuffer(ImageBuffer&, const FloatRect& destination, const FloatRect& source, const ImagePaintingOptions&) = 0;
     virtual void drawNativeImage(const NativeImagePtr&, const FloatSize& selfSize, const FloatRect& destRect, const FloatRect& srcRect, const ImagePaintingOptions&) = 0;
     virtual void drawPattern(Image&, const FloatRect& destRect, const FloatRect& srcRect, const AffineTransform&, const FloatPoint& phase, const FloatSize& spacing, const ImagePaintingOptions&) = 0;
 

Modified: trunk/Source/WebCore/platform/graphics/ImageBuffer.h (269502 => 269503)


--- trunk/Source/WebCore/platform/graphics/ImageBuffer.h	2020-11-06 04:18:57 UTC (rev 269502)
+++ trunk/Source/WebCore/platform/graphics/ImageBuffer.h	2020-11-06 07:27:31 UTC (rev 269503)
@@ -119,4 +119,6 @@
     virtual void drawConsuming(GraphicsContext&, const FloatRect& destRect, const FloatRect& srcRect, const ImagePaintingOptions&) = 0;
 };
 
+using ImageBufferHashMap = HashMap<RenderingResourceIdentifier, Ref<ImageBuffer>>;
+
 } // namespace WebCore

Modified: trunk/Source/WebCore/platform/graphics/cairo/GraphicsContextImplCairo.cpp (269502 => 269503)


--- trunk/Source/WebCore/platform/graphics/cairo/GraphicsContextImplCairo.cpp	2020-11-06 04:18:57 UTC (rev 269502)
+++ trunk/Source/WebCore/platform/graphics/cairo/GraphicsContextImplCairo.cpp	2020-11-06 07:27:31 UTC (rev 269503)
@@ -279,10 +279,9 @@
     return GraphicsContextImpl::drawTiledImageImpl(graphicsContext(), image, destination, source, tileScaleFactor, hRule, vRule, imagePaintingOptions);
 }
 
-bool GraphicsContextImplCairo::drawImageBuffer(ImageBuffer&, const FloatRect&, const FloatRect&, const ImagePaintingOptions&)
+void GraphicsContextImplCairo::drawImageBuffer(ImageBuffer&, const FloatRect&, const FloatRect&, const ImagePaintingOptions&)
 {
     // FIXME: Not implemented.
-    return false;
 }
 
 void GraphicsContextImplCairo::drawNativeImage(const NativeImagePtr& image, const FloatSize& imageSize, const FloatRect& destRect, const FloatRect& srcRect, const ImagePaintingOptions& options)

Modified: trunk/Source/WebCore/platform/graphics/cairo/GraphicsContextImplCairo.h (269502 => 269503)


--- trunk/Source/WebCore/platform/graphics/cairo/GraphicsContextImplCairo.h	2020-11-06 04:18:57 UTC (rev 269502)
+++ trunk/Source/WebCore/platform/graphics/cairo/GraphicsContextImplCairo.h	2020-11-06 07:27:31 UTC (rev 269503)
@@ -75,7 +75,7 @@
     ImageDrawResult drawTiledImage(Image&, const FloatRect&, const FloatPoint&, const FloatSize&, const FloatSize&, const ImagePaintingOptions&) override;
     ImageDrawResult drawTiledImage(Image&, const FloatRect&, const FloatRect&, const FloatSize&, Image::TileRule, Image::TileRule, const ImagePaintingOptions&) override;
     
-    bool drawImageBuffer(ImageBuffer&, const FloatRect&, const FloatRect&, const ImagePaintingOptions&) override;
+    void drawImageBuffer(ImageBuffer&, const FloatRect&, const FloatRect&, const ImagePaintingOptions&) override;
     void drawNativeImage(const NativeImagePtr&, const FloatSize&, const FloatRect&, const FloatRect&, const ImagePaintingOptions&) override;
     void drawPattern(Image&, const FloatRect&, const FloatRect&, const AffineTransform&, const FloatPoint&, const FloatSize&, const ImagePaintingOptions&) override;
 

Modified: trunk/Source/WebCore/platform/graphics/displaylists/DisplayList.cpp (269502 => 269503)


--- trunk/Source/WebCore/platform/graphics/displaylists/DisplayList.cpp	2020-11-06 04:18:57 UTC (rev 269502)
+++ trunk/Source/WebCore/platform/graphics/displaylists/DisplayList.cpp	2020-11-06 07:27:31 UTC (rev 269503)
@@ -51,6 +51,7 @@
 void DisplayList::clear()
 {
     m_list.clear();
+    m_imageBuffers.clear();
 }
 
 bool DisplayList::shouldDumpForFlags(AsTextFlags flags, const Item& item)

Modified: trunk/Source/WebCore/platform/graphics/displaylists/DisplayList.h (269502 => 269503)


--- trunk/Source/WebCore/platform/graphics/displaylists/DisplayList.h	2020-11-06 04:18:57 UTC (rev 269502)
+++ trunk/Source/WebCore/platform/graphics/displaylists/DisplayList.h	2020-11-06 07:27:31 UTC (rev 269503)
@@ -28,7 +28,9 @@
 #include "DisplayListItemType.h"
 #include "FloatRect.h"
 #include "GraphicsContext.h"
+#include "ImageBuffer.h"
 #include <wtf/FastMalloc.h>
+#include <wtf/HashSet.h>
 #include <wtf/Noncopyable.h>
 #include <wtf/text/WTFString.h>
 
@@ -101,6 +103,8 @@
     
     String asText(AsTextFlags) const;
 
+    const ImageBufferHashMap& imageBuffers() const { return m_imageBuffers; }
+
 #if !defined(NDEBUG) || !LOG_DISABLED
     WTF::CString description() const;
     WEBCORE_EXPORT void dump() const;
@@ -109,7 +113,6 @@
     template<class Encoder> void encode(Encoder&) const;
     template<class Decoder> static Optional<DisplayList> decode(Decoder&);
 
-
 private:
     Item& append(Ref<Item>&& item)
     {
@@ -123,11 +126,17 @@
         m_list.append(item);
     }
 
+    void cacheImageBuffer(Ref<WebCore::ImageBuffer>&& imageBuffer)
+    {
+        m_imageBuffers.add(imageBuffer->renderingResourceIdentifier(), WTFMove(imageBuffer));
+    }
+
     static bool shouldDumpForFlags(AsTextFlags, const Item&);
 
     Vector<Ref<Item>>& list() { return m_list; }
 
     Vector<Ref<Item>> m_list;
+    ImageBufferHashMap m_imageBuffers;
 };
 
 

Modified: trunk/Source/WebCore/platform/graphics/displaylists/DisplayListItemType.cpp (269502 => 269503)


--- trunk/Source/WebCore/platform/graphics/displaylists/DisplayListItemType.cpp	2020-11-06 04:18:57 UTC (rev 269502)
+++ trunk/Source/WebCore/platform/graphics/displaylists/DisplayListItemType.cpp	2020-11-06 07:27:31 UTC (rev 269503)
@@ -245,7 +245,6 @@
     case ItemType::DrawFocusRingRects:
     case ItemType::DrawGlyphs:
     case ItemType::DrawImage:
-    case ItemType::DrawImageBuffer:
     case ItemType::DrawLinesForText:
     case ItemType::DrawNativeImage:
     case ItemType::DrawPath:
@@ -276,6 +275,7 @@
     case ItemType::ConcatenateCTM:
     case ItemType::DrawDotsForDocumentMarker:
     case ItemType::DrawEllipse:
+    case ItemType::DrawImageBuffer:
     case ItemType::DrawLine:
     case ItemType::DrawRect:
     case ItemType::EndTransparencyLayer:

Modified: trunk/Source/WebCore/platform/graphics/displaylists/DisplayListItems.cpp (269502 => 269503)


--- trunk/Source/WebCore/platform/graphics/displaylists/DisplayListItems.cpp	2020-11-06 04:18:57 UTC (rev 269502)
+++ trunk/Source/WebCore/platform/graphics/displaylists/DisplayListItems.cpp	2020-11-06 07:27:31 UTC (rev 269503)
@@ -28,6 +28,7 @@
 
 #include "DisplayListReplayer.h"
 #include "FontCascade.h"
+#include "ImageBuffer.h"
 #include "ImageData.h"
 #include "MediaPlayer.h"
 #include "SharedBuffer.h"
@@ -839,6 +840,7 @@
     , m_srcRect(srcRect)
     , m_options(options)
 {
+    ASSERT(m_renderingResourceIdentifier);
 }
 
 DrawImageBuffer::~DrawImageBuffer() = default;
@@ -845,10 +847,14 @@
 
 void DrawImageBuffer::apply(GraphicsContext&) const
 {
-    // Should be handled by the delegate.
     ASSERT_NOT_REACHED();
 }
 
+void DrawImageBuffer::apply(GraphicsContext& context, WebCore::ImageBuffer& imageBuffer) const
+{
+    context.drawImageBuffer(imageBuffer, m_destinationRect, m_srcRect, m_options);
+}
+
 static TextStream& operator<<(TextStream& ts, const DrawImageBuffer& item)
 {
     ts << static_cast<const DrawingItem&>(item);

Modified: trunk/Source/WebCore/platform/graphics/displaylists/DisplayListItems.h (269502 => 269503)


--- trunk/Source/WebCore/platform/graphics/displaylists/DisplayListItems.h	2020-11-06 04:18:57 UTC (rev 269502)
+++ trunk/Source/WebCore/platform/graphics/displaylists/DisplayListItems.h	2020-11-06 07:27:31 UTC (rev 269503)
@@ -1648,6 +1648,8 @@
     FloatRect destinationRect() const { return m_destinationRect; }
     ImagePaintingOptions options() const { return m_options; }
 
+    void apply(GraphicsContext&, WebCore::ImageBuffer&) const;
+
     template<class Encoder> void encode(Encoder&) const;
     template<class Decoder> static Optional<Ref<DrawImageBuffer>> decode(Decoder&);
 

Modified: trunk/Source/WebCore/platform/graphics/displaylists/DisplayListRecorder.cpp (269502 => 269503)


--- trunk/Source/WebCore/platform/graphics/displaylists/DisplayListRecorder.cpp	2020-11-06 04:18:57 UTC (rev 269502)
+++ trunk/Source/WebCore/platform/graphics/displaylists/DisplayListRecorder.cpp	2020-11-06 07:27:31 UTC (rev 269503)
@@ -185,13 +185,11 @@
     return ImageDrawResult::DidRecord;
 }
 
-bool Recorder::drawImageBuffer(WebCore::ImageBuffer& imageBuffer, const FloatRect& destRect, const FloatRect& srcRect, const ImagePaintingOptions& options)
+void Recorder::drawImageBuffer(WebCore::ImageBuffer& imageBuffer, const FloatRect& destRect, const FloatRect& srcRect, const ImagePaintingOptions& options)
 {
-    if (!m_delegate || !m_delegate->lockRemoteImageBuffer(imageBuffer))
-        return false;
-
+    imageBuffer.flushDrawingContext();
+    m_displayList.cacheImageBuffer(makeRef(imageBuffer));
     appendItemAndUpdateExtent(DrawImageBuffer::create(imageBuffer.renderingResourceIdentifier(), destRect, srcRect, options));
-    return true;
 }
 
 void Recorder::drawNativeImage(const NativeImagePtr& image, const FloatSize& imageSize, const FloatRect& destRect, const FloatRect& srcRect, const ImagePaintingOptions& options)

Modified: trunk/Source/WebCore/platform/graphics/displaylists/DisplayListRecorder.h (269502 => 269503)


--- trunk/Source/WebCore/platform/graphics/displaylists/DisplayListRecorder.h	2020-11-06 04:18:57 UTC (rev 269502)
+++ trunk/Source/WebCore/platform/graphics/displaylists/DisplayListRecorder.h	2020-11-06 07:27:31 UTC (rev 269503)
@@ -65,7 +65,6 @@
     class Delegate {
     public:
         virtual ~Delegate() { }
-        virtual bool lockRemoteImageBuffer(WebCore::ImageBuffer&) { return false; }
         virtual void willAppendItemOfType(ItemType) { }
         virtual void didAppendItemOfType(ItemType) { }
     };
@@ -107,7 +106,7 @@
     ImageDrawResult drawTiledImage(Image&, const FloatRect& destination, const FloatPoint& source, const FloatSize& tileSize, const FloatSize& spacing, const ImagePaintingOptions&) override;
     ImageDrawResult drawTiledImage(Image&, const FloatRect& destination, const FloatRect& source, const FloatSize& tileScaleFactor, Image::TileRule hRule, Image::TileRule vRule, const ImagePaintingOptions&) override;
 
-    bool drawImageBuffer(WebCore::ImageBuffer&, const FloatRect& destination, const FloatRect& source, const ImagePaintingOptions&) override;
+    void drawImageBuffer(WebCore::ImageBuffer&, const FloatRect& destination, const FloatRect& source, const ImagePaintingOptions&) override;
     void drawNativeImage(const NativeImagePtr&, const FloatSize& selfSize, const FloatRect& destRect, const FloatRect& srcRect, const ImagePaintingOptions&) override;
     void drawPattern(Image&, const FloatRect& destRect, const FloatRect& srcRect, const AffineTransform&, const FloatPoint& phase, const FloatSize& spacing, const ImagePaintingOptions&) override;
 

Modified: trunk/Source/WebCore/platform/graphics/displaylists/DisplayListReplayer.cpp (269502 => 269503)


--- trunk/Source/WebCore/platform/graphics/displaylists/DisplayListReplayer.cpp	2020-11-06 04:18:57 UTC (rev 269502)
+++ trunk/Source/WebCore/platform/graphics/displaylists/DisplayListReplayer.cpp	2020-11-06 07:27:31 UTC (rev 269503)
@@ -34,9 +34,10 @@
 namespace WebCore {
 namespace DisplayList {
 
-Replayer::Replayer(GraphicsContext& context, const DisplayList& displayList, Delegate* delegate)
-    : m_displayList(displayList)
-    , m_context(context)
+Replayer::Replayer(GraphicsContext& context, const DisplayList& displayList, const ImageBufferHashMap* imageBuffers, Delegate* delegate)
+    : m_context(context)
+    , m_displayList(displayList)
+    , m_imageBuffers(imageBuffers ? *imageBuffers : m_displayList.imageBuffers())
     , m_delegate(delegate)
 {
 }
@@ -43,6 +44,21 @@
 
 Replayer::~Replayer() = default;
 
+void Replayer::applyItem(Item& item)
+{
+    if (m_delegate && m_delegate->apply(item, m_context))
+        return;
+    
+    if (item.type() == ItemType::DrawImageBuffer) {
+        auto& drawItem = static_cast<DrawImageBuffer&>(item);
+        if (auto* imageBuffer = m_imageBuffers.get(drawItem.renderingResourceIdentifier()))
+            drawItem.apply(m_context, *imageBuffer);
+        return;
+    }
+    
+    item.apply(m_context);
+}
+
 std::unique_ptr<DisplayList> Replayer::replay(const FloatRect& initialClip, bool trackReplayList)
 {
     LOG_WITH_STREAM(DisplayLists, stream << "\nReplaying with clip " << initialClip);
@@ -65,8 +81,7 @@
         }
 
         LOG_WITH_STREAM(DisplayLists, stream << "applying " << i << " " << item);
-        if (!m_delegate || !m_delegate->apply(item, m_context))
-            item.apply(m_context);
+        applyItem(item);
 
         if (UNLIKELY(trackReplayList))
             replayList->appendItem(const_cast<Item&>(item));

Modified: trunk/Source/WebCore/platform/graphics/displaylists/DisplayListReplayer.h (269502 => 269503)


--- trunk/Source/WebCore/platform/graphics/displaylists/DisplayListReplayer.h	2020-11-06 04:18:57 UTC (rev 269502)
+++ trunk/Source/WebCore/platform/graphics/displaylists/DisplayListReplayer.h	2020-11-06 07:27:31 UTC (rev 269503)
@@ -42,7 +42,7 @@
     WTF_MAKE_NONCOPYABLE(Replayer);
 public:
     class Delegate;
-    WEBCORE_EXPORT Replayer(GraphicsContext&, const DisplayList&, Delegate* = nullptr);
+    WEBCORE_EXPORT Replayer(GraphicsContext&, const DisplayList&, const ImageBufferHashMap* = nullptr, Delegate* = nullptr);
     WEBCORE_EXPORT ~Replayer();
 
     WEBCORE_EXPORT std::unique_ptr<DisplayList> replay(const FloatRect& initialClip = { }, bool trackReplayList = false);
@@ -54,8 +54,11 @@
     };
     
 private:
+    void applyItem(Item&);
+    
+    GraphicsContext& m_context;
     const DisplayList& m_displayList;
-    GraphicsContext& m_context;
+    const ImageBufferHashMap& m_imageBuffers;
     Delegate* m_delegate;
 };
 

Modified: trunk/Source/WebCore/platform/graphics/nicosia/cairo/NicosiaCairoOperationRecorder.cpp (269502 => 269503)


--- trunk/Source/WebCore/platform/graphics/nicosia/cairo/NicosiaCairoOperationRecorder.cpp	2020-11-06 04:18:57 UTC (rev 269502)
+++ trunk/Source/WebCore/platform/graphics/nicosia/cairo/NicosiaCairoOperationRecorder.cpp	2020-11-06 07:27:31 UTC (rev 269503)
@@ -549,10 +549,9 @@
     return GraphicsContextImpl::drawTiledImageImpl(graphicsContext(), image, destination, source, tileScaleFactor, hRule, vRule, imagePaintingOptions);
 }
 
-bool CairoOperationRecorder::drawImageBuffer(ImageBuffer&, const FloatRect&, const FloatRect&, const ImagePaintingOptions&)
+void CairoOperationRecorder::drawImageBuffer(ImageBuffer&, const FloatRect&, const FloatRect&, const ImagePaintingOptions&)
 {
     // FIXME: Not implemented.
-    return false;
 }
 
 void CairoOperationRecorder::drawNativeImage(const NativeImagePtr& image, const FloatSize& imageSize, const FloatRect& destRect, const FloatRect& srcRect, const ImagePaintingOptions& options)

Modified: trunk/Source/WebCore/platform/graphics/nicosia/cairo/NicosiaCairoOperationRecorder.h (269502 => 269503)


--- trunk/Source/WebCore/platform/graphics/nicosia/cairo/NicosiaCairoOperationRecorder.h	2020-11-06 04:18:57 UTC (rev 269502)
+++ trunk/Source/WebCore/platform/graphics/nicosia/cairo/NicosiaCairoOperationRecorder.h	2020-11-06 07:27:31 UTC (rev 269503)
@@ -68,7 +68,7 @@
     WebCore::ImageDrawResult drawTiledImage(WebCore::Image&, const WebCore::FloatRect&, const WebCore::FloatPoint&, const WebCore::FloatSize&, const WebCore::FloatSize&, const WebCore::ImagePaintingOptions&) override;
     WebCore::ImageDrawResult drawTiledImage(WebCore::Image&, const WebCore::FloatRect&, const WebCore::FloatRect&, const WebCore::FloatSize&, WebCore::Image::TileRule, WebCore::Image::TileRule, const WebCore::ImagePaintingOptions&) override;
 
-    bool drawImageBuffer(WebCore::ImageBuffer&, const WebCore::FloatRect& destination, const WebCore::FloatRect& source, const WebCore::ImagePaintingOptions&) override;
+    void drawImageBuffer(WebCore::ImageBuffer&, const WebCore::FloatRect& destination, const WebCore::FloatRect& source, const WebCore::ImagePaintingOptions&) override;
     void drawNativeImage(const WebCore::NativeImagePtr&, const WebCore::FloatSize&, const WebCore::FloatRect&, const WebCore::FloatRect&, const WebCore::ImagePaintingOptions&) override;
     void drawPattern(WebCore::Image&, const WebCore::FloatRect&, const WebCore::FloatRect&, const WebCore::AffineTransform&, const WebCore::FloatPoint&, const WebCore::FloatSize&, const WebCore::ImagePaintingOptions&) override;
 

Modified: trunk/Source/WebKit/ChangeLog (269502 => 269503)


--- trunk/Source/WebKit/ChangeLog	2020-11-06 04:18:57 UTC (rev 269502)
+++ trunk/Source/WebKit/ChangeLog	2020-11-06 07:27:31 UTC (rev 269503)
@@ -1,3 +1,46 @@
+2020-11-05  Said Abou-Hallawa  <[email protected]>
+
+        [GPU Process] Use the Ref counting of ImageBuffer to control its life cycle in Web Process and GPU Process
+        https://bugs.webkit.org/show_bug.cgi?id=218529
+
+        Reviewed by Simon Fraser.
+
+        When a DrawImageBuffer item is appended to DisplayList, a Ref<ImageBuffer>
+        will be cached till the DisplayList items list is cleared. So no need to
+        lock the remote resource in RemoteResourceCacheProxy.
+
+        All we need to is to pass the ImageBufferHashMap which is maintained by
+        the DisplayList or by RemoteResourceCache to the DisplayList::Replayer.
+        It is going to be used to resolve the RenderingResourceIdentifer to an
+        ImageBuffer so the DrawImageBuffer can be applied.
+
+        No need to special-case DrawImageBuffer::apply() in the RemoteImageBuffer.
+
+        * GPUProcess/graphics/RemoteImageBuffer.h:
+        (WebKit::RemoteImageBuffer::RemoteImageBuffer):
+        * GPUProcess/graphics/RemoteRenderingBackend.cpp:
+        (WebKit::RemoteRenderingBackend::createImageBuffer):
+        (WebKit::RemoteRenderingBackend::applyResourceItem): Deleted.
+        * GPUProcess/graphics/RemoteRenderingBackend.h:
+        (WebKit::RemoteRenderingBackend::remoteResourceCache):
+        * GPUProcess/graphics/RemoteResourceCache.cpp:
+        (WebKit::RemoteResourceCache::cacheImageBuffer):
+        * GPUProcess/graphics/RemoteResourceCache.h:
+        (WebKit::RemoteResourceCache::imageBuffers const):
+        * WebProcess/GPU/graphics/RemoteImageBufferProxy.h:
+        (WebKit::RemoteImageBufferProxy::~RemoteImageBufferProxy):
+        * WebProcess/GPU/graphics/RemoteRenderingBackendProxy.cpp:
+        (WebKit::RemoteRenderingBackendProxy::releaseRemoteResource):
+        * WebProcess/GPU/graphics/RemoteRenderingBackendProxy.h:
+        * WebProcess/GPU/graphics/RemoteResourceCacheProxy.cpp:
+        (WebKit::RemoteResourceCacheProxy::releaseImageBuffer):
+        (WebKit::RemoteResourceCacheProxy::RemoteResourceCacheProxy): Deleted.
+        (WebKit::RemoteResourceCacheProxy::lockRemoteImageBufferForRemoteClient): Deleted.
+        (WebKit::RemoteResourceCacheProxy::lockRemoteResourceForRemoteClient): Deleted.
+        (WebKit::RemoteResourceCacheProxy::releaseRemoteResource): Deleted.
+        (WebKit::RemoteResourceCacheProxy::unlockRemoteResourcesForRemoteClient): Deleted.
+        * WebProcess/GPU/graphics/RemoteResourceCacheProxy.h:
+
 2020-11-05  Brent Fulgham  <[email protected]>
 
         [macOS] Remove mdnsresponder access from WebKit processes

Modified: trunk/Source/WebKit/GPUProcess/graphics/RemoteImageBuffer.h (269502 => 269503)


--- trunk/Source/WebKit/GPUProcess/graphics/RemoteImageBuffer.h	2020-11-06 04:18:57 UTC (rev 269502)
+++ trunk/Source/WebKit/GPUProcess/graphics/RemoteImageBuffer.h	2020-11-06 07:27:31 UTC (rev 269503)
@@ -47,7 +47,7 @@
     }
 
     RemoteImageBuffer(std::unique_ptr<BackendType>&& backend, RemoteRenderingBackend& remoteRenderingBackend, WebCore::RenderingResourceIdentifier renderingResourceIdentifier)
-        : BaseConcreteImageBuffer(WTFMove(backend))
+        : BaseConcreteImageBuffer(WTFMove(backend), renderingResourceIdentifier)
         , m_remoteRenderingBackend(remoteRenderingBackend)
     {
         m_remoteRenderingBackend.imageBufferBackendWasCreated(m_backend->logicalSize(), m_backend->backendSize(), m_backend->resolutionScale(), m_backend->colorSpace(), m_backend->createImageBufferBackendHandle(), renderingResourceIdentifier);
@@ -65,7 +65,8 @@
     void flushDisplayList(const WebCore::DisplayList::DisplayList& displayList) override
     {
         if (!displayList.isEmpty()) {
-            WebCore::DisplayList::Replayer replayer(BaseConcreteImageBuffer::context(), displayList, this);
+            const auto& imageBuffers = m_remoteRenderingBackend.remoteResourceCache().imageBuffers();
+            WebCore::DisplayList::Replayer replayer { BaseConcreteImageBuffer::context(), displayList, &imageBuffers, this };
             replayer.replay();
         }
     }
@@ -78,9 +79,6 @@
             return true;
         }
 
-        if (m_remoteRenderingBackend.applyResourceItem(item, context))
-            return true;
-
         return m_remoteRenderingBackend.applyMediaItem(item, context);
     }
 

Modified: trunk/Source/WebKit/GPUProcess/graphics/RemoteRenderingBackend.cpp (269502 => 269503)


--- trunk/Source/WebKit/GPUProcess/graphics/RemoteRenderingBackend.cpp	2020-11-06 04:18:57 UTC (rev 269502)
+++ trunk/Source/WebKit/GPUProcess/graphics/RemoteRenderingBackend.cpp	2020-11-06 07:27:31 UTC (rev 269503)
@@ -72,21 +72,6 @@
     return m_renderingBackendIdentifier.toUInt64();
 }
 
-bool RemoteRenderingBackend::applyResourceItem(const DisplayList::Item& item, GraphicsContext& context)
-{
-    if (item.type() == DisplayList::ItemType::DrawImageBuffer) {
-        auto& drawItem = static_cast<const DisplayList::DrawImageBuffer&>(item);
-        auto imageBuffer = m_remoteResourceCache.cachedImageBuffer(drawItem.renderingResourceIdentifier());
-        if (!imageBuffer)
-            return false;
-
-        imageBuffer->draw(context, drawItem.destinationRect(), drawItem.source(), drawItem.options());
-        return true;
-    }
-
-    return false;
-}
-
 bool RemoteRenderingBackend::applyMediaItem(const DisplayList::Item& item, GraphicsContext& context)
 {
     if (item.type() != WebCore::DisplayList::ItemType::PaintFrameForMedia)
@@ -124,20 +109,20 @@
 {
     ASSERT(renderingMode == RenderingMode::Accelerated || renderingMode == RenderingMode::Unaccelerated);
 
-    RefPtr<ImageBuffer> image;
+    RefPtr<ImageBuffer> imageBuffer;
 
     if (renderingMode == RenderingMode::Accelerated)
-        image = AcceleratedRemoteImageBuffer::create(logicalSize, resolutionScale, colorSpace, *this, renderingResourceIdentifier);
+        imageBuffer = AcceleratedRemoteImageBuffer::create(logicalSize, resolutionScale, colorSpace, *this, renderingResourceIdentifier);
 
-    if (!image)
-        image = UnacceleratedRemoteImageBuffer::create(logicalSize, resolutionScale, colorSpace, *this, renderingResourceIdentifier);
+    if (!imageBuffer)
+        imageBuffer = UnacceleratedRemoteImageBuffer::create(logicalSize, resolutionScale, colorSpace, *this, renderingResourceIdentifier);
 
-    if (image) {
-        m_remoteResourceCache.cacheImageBuffer(renderingResourceIdentifier, WTFMove(image));
+    if (!imageBuffer) {
+        ASSERT_NOT_REACHED();
         return;
     }
 
-    ASSERT_NOT_REACHED();
+    m_remoteResourceCache.cacheImageBuffer(makeRef(*imageBuffer));
 }
 
 void RemoteRenderingBackend::flushDisplayList(const DisplayList::DisplayList& displayList, RenderingResourceIdentifier renderingResourceIdentifier)

Modified: trunk/Source/WebKit/GPUProcess/graphics/RemoteRenderingBackend.h (269502 => 269503)


--- trunk/Source/WebKit/GPUProcess/graphics/RemoteRenderingBackend.h	2020-11-06 04:18:57 UTC (rev 269502)
+++ trunk/Source/WebKit/GPUProcess/graphics/RemoteRenderingBackend.h	2020-11-06 07:27:31 UTC (rev 269503)
@@ -61,9 +61,9 @@
     virtual ~RemoteRenderingBackend();
 
     GPUConnectionToWebProcess* gpuConnectionToWebProcess() const;
+    RemoteResourceCache& remoteResourceCache() { return m_remoteResourceCache; }
 
     // Rendering operations.
-    bool applyResourceItem(const WebCore::DisplayList::Item&, WebCore::GraphicsContext&);
     bool applyMediaItem(const WebCore::DisplayList::Item&, WebCore::GraphicsContext&);
 
     // Messages to be sent.

Modified: trunk/Source/WebKit/GPUProcess/graphics/RemoteResourceCache.cpp (269502 => 269503)


--- trunk/Source/WebKit/GPUProcess/graphics/RemoteResourceCache.cpp	2020-11-06 04:18:57 UTC (rev 269502)
+++ trunk/Source/WebKit/GPUProcess/graphics/RemoteResourceCache.cpp	2020-11-06 07:27:31 UTC (rev 269503)
@@ -31,9 +31,9 @@
 namespace WebKit {
 using namespace WebCore;
 
-void RemoteResourceCache::cacheImageBuffer(RenderingResourceIdentifier renderingResourceIdentifier, RefPtr<ImageBuffer>&& image)
+void RemoteResourceCache::cacheImageBuffer(Ref<ImageBuffer>&& imageBuffer)
 {
-    auto addResult = m_imageBuffers.add(renderingResourceIdentifier, WTFMove(image));
+    auto addResult = m_imageBuffers.add(imageBuffer->renderingResourceIdentifier(), WTFMove(imageBuffer));
     ASSERT_UNUSED(addResult, addResult.isNewEntry);
 }
 

Modified: trunk/Source/WebKit/GPUProcess/graphics/RemoteResourceCache.h (269502 => 269503)


--- trunk/Source/WebKit/GPUProcess/graphics/RemoteResourceCache.h	2020-11-06 04:18:57 UTC (rev 269502)
+++ trunk/Source/WebKit/GPUProcess/graphics/RemoteResourceCache.h	2020-11-06 07:27:31 UTC (rev 269503)
@@ -42,14 +42,14 @@
 public:
     RemoteResourceCache() = default;
 
-    void cacheImageBuffer(WebCore::RenderingResourceIdentifier, RefPtr<WebCore::ImageBuffer>&&);
+    void cacheImageBuffer(Ref<WebCore::ImageBuffer>&&);
     WebCore::ImageBuffer* cachedImageBuffer(WebCore::RenderingResourceIdentifier);
     void releaseRemoteResource(WebCore::RenderingResourceIdentifier);
+    
+    const WebCore::ImageBufferHashMap& imageBuffers() const { return m_imageBuffers; }
 
 private:
-    using RemoteImageBufferHashMap = HashMap<WebCore::RenderingResourceIdentifier, RefPtr<WebCore::ImageBuffer>>;
-
-    RemoteImageBufferHashMap m_imageBuffers;
+    WebCore::ImageBufferHashMap m_imageBuffers;
 };
 
 } // namespace WebKit

Modified: trunk/Source/WebKit/WebProcess/GPU/graphics/RemoteImageBufferProxy.h (269502 => 269503)


--- trunk/Source/WebKit/WebProcess/GPU/graphics/RemoteImageBufferProxy.h	2020-11-06 04:18:57 UTC (rev 269502)
+++ trunk/Source/WebKit/WebProcess/GPU/graphics/RemoteImageBufferProxy.h	2020-11-06 07:27:31 UTC (rev 269503)
@@ -40,6 +40,7 @@
     using BaseDisplayListImageBuffer = WebCore::DisplayList::ImageBuffer<BackendType>;
     using BaseDisplayListImageBuffer::m_backend;
     using BaseDisplayListImageBuffer::m_drawingContext;
+    using BaseDisplayListImageBuffer::m_renderingResourceIdentifier;
 
 public:
     static RefPtr<RemoteImageBufferProxy> create(const WebCore::FloatSize& size, float resolutionScale, RemoteRenderingBackendProxy& remoteRenderingBackendProxy)
@@ -55,11 +56,9 @@
         if (!m_remoteRenderingBackendProxy)
             return;
         flushDrawingContext();
-        m_remoteRenderingBackendProxy->remoteResourceCacheProxy().releaseImageBuffer(m_renderingResourceIdentifier);
+        m_remoteRenderingBackendProxy->releaseRemoteResource(m_renderingResourceIdentifier);
     }
 
-    WebCore::RenderingResourceIdentifier renderingResourceIdentifier() const override { return m_renderingResourceIdentifier; }
-
     void createBackend(const WebCore::FloatSize& logicalSize, const WebCore::IntSize& backendSize, float resolutionScale, WebCore::ColorSpace colorSpace, ImageBufferBackendHandle handle)
     {
         ASSERT(!m_backend);
@@ -149,7 +148,6 @@
 
         TraceScope tracingScope(FlushRemoteImageBufferStart, FlushRemoteImageBufferEnd, 1);
         m_sentFlushIdentifier = m_remoteRenderingBackendProxy->flushDisplayListAndCommit(displayList, m_renderingResourceIdentifier);
-        m_remoteRenderingBackendProxy->remoteResourceCacheProxy().unlockRemoteResourcesForRemoteClient(m_renderingResourceIdentifier);
         m_itemCountInCurrentDisplayList = 0;
         displayList.clear();
     }
@@ -161,19 +159,8 @@
 
         TraceScope tracingScope(FlushRemoteImageBufferStart, FlushRemoteImageBufferEnd);
         m_remoteRenderingBackendProxy->flushDisplayList(displayList, m_renderingResourceIdentifier);
-        m_remoteRenderingBackendProxy->remoteResourceCacheProxy().unlockRemoteResourcesForRemoteClient(m_renderingResourceIdentifier);
     }
 
-    bool lockRemoteImageBuffer(WebCore::ImageBuffer& imageBuffer) override
-    {
-        if (!m_remoteRenderingBackendProxy)
-            return false;
-        if (!m_remoteRenderingBackendProxy->remoteResourceCacheProxy().lockRemoteImageBufferForRemoteClient(imageBuffer, m_renderingResourceIdentifier))
-            return false;
-        imageBuffer.flushDrawingContext();
-        return true;
-    }
-
     void willAppendItemOfType(WebCore::DisplayList::ItemType) override
     {
         constexpr size_t DisplayListBatchSize = 512;
@@ -194,7 +181,6 @@
 
     DisplayListFlushIdentifier m_sentFlushIdentifier;
     DisplayListFlushIdentifier m_receivedFlushIdentifier;
-    WebCore::RenderingResourceIdentifier m_renderingResourceIdentifier { WebCore::RenderingResourceIdentifier::generate() };
     WeakPtr<RemoteRenderingBackendProxy> m_remoteRenderingBackendProxy;
     size_t m_itemCountInCurrentDisplayList { 0 };
 };

Modified: trunk/Source/WebKit/WebProcess/GPU/graphics/RemoteRenderingBackendProxy.cpp (269502 => 269503)


--- trunk/Source/WebKit/WebProcess/GPU/graphics/RemoteRenderingBackendProxy.cpp	2020-11-06 04:18:57 UTC (rev 269502)
+++ trunk/Source/WebKit/WebProcess/GPU/graphics/RemoteRenderingBackendProxy.cpp	2020-11-06 07:27:31 UTC (rev 269503)
@@ -127,6 +127,7 @@
 
 void RemoteRenderingBackendProxy::releaseRemoteResource(RenderingResourceIdentifier renderingResourceIdentifier)
 {
+    m_remoteResourceCacheProxy.releaseImageBuffer(renderingResourceIdentifier);
     send(Messages::RemoteRenderingBackend::ReleaseRemoteResource(renderingResourceIdentifier), m_renderingBackendIdentifier);
 }
 

Modified: trunk/Source/WebKit/WebProcess/GPU/graphics/RemoteRenderingBackendProxy.h (269502 => 269503)


--- trunk/Source/WebKit/WebProcess/GPU/graphics/RemoteRenderingBackendProxy.h	2020-11-06 04:18:57 UTC (rev 269502)
+++ trunk/Source/WebKit/WebProcess/GPU/graphics/RemoteRenderingBackendProxy.h	2020-11-06 07:27:31 UTC (rev 269503)
@@ -85,7 +85,7 @@
     void imageBufferBackendWasCreated(const WebCore::FloatSize& logicalSize, const WebCore::IntSize& backendSize, float resolutionScale, WebCore::ColorSpace, ImageBufferBackendHandle, WebCore::RenderingResourceIdentifier);
     void flushDisplayListWasCommitted(DisplayListFlushIdentifier, WebCore::RenderingResourceIdentifier);
 
-    RemoteResourceCacheProxy m_remoteResourceCacheProxy { *this };
+    RemoteResourceCacheProxy m_remoteResourceCacheProxy;
     RenderingBackendIdentifier m_renderingBackendIdentifier { RenderingBackendIdentifier::generate() };
 };
 

Modified: trunk/Source/WebKit/WebProcess/GPU/graphics/RemoteResourceCacheProxy.cpp (269502 => 269503)


--- trunk/Source/WebKit/WebProcess/GPU/graphics/RemoteResourceCacheProxy.cpp	2020-11-06 04:18:57 UTC (rev 269502)
+++ trunk/Source/WebKit/WebProcess/GPU/graphics/RemoteResourceCacheProxy.cpp	2020-11-06 07:27:31 UTC (rev 269503)
@@ -28,16 +28,9 @@
 
 #if ENABLE(GPU_PROCESS)
 
-#include "RemoteRenderingBackendProxy.h"
-
 namespace WebKit {
 using namespace WebCore;
 
-RemoteResourceCacheProxy::RemoteResourceCacheProxy(RemoteRenderingBackendProxy& remoteRenderingBackendProxy)
-    : m_remoteRenderingBackendProxy(remoteRenderingBackendProxy)
-{
-}
-
 void RemoteResourceCacheProxy::cacheImageBuffer(RenderingResourceIdentifier renderingResourceIdentifier, WebCore::ImageBuffer* imageBuffer)
 {
     auto addResult = m_imageBuffers.add(renderingResourceIdentifier, imageBuffer);
@@ -53,77 +46,8 @@
 {
     bool found = m_imageBuffers.remove(renderingResourceIdentifier);
     ASSERT_UNUSED(found, found);
-
-    // Tell the GPU process to remove this resource unless it's pending replaying back.
-    releaseRemoteResource(renderingResourceIdentifier);
 }
 
-bool RemoteResourceCacheProxy::lockRemoteImageBufferForRemoteClient(ImageBuffer& imageBuffer, RenderingResourceIdentifier remoteClientIdentifier)
-{
-    if (!imageBuffer.renderingResourceIdentifier())
-        return false;
-
-    if (cachedImageBuffer(imageBuffer.renderingResourceIdentifier()) != &imageBuffer) {
-        ASSERT_NOT_REACHED();
-        return false;
-    }
-
-    lockRemoteResourceForRemoteClient(imageBuffer.renderingResourceIdentifier(), remoteClientIdentifier);
-    return true;
-}
-
-void RemoteResourceCacheProxy::lockRemoteResourceForRemoteClient(RenderingResourceIdentifier renderingResourceIdentifier, RenderingResourceIdentifier remoteClientIdentifier)
-{
-    // Add the "resource -> client" dependency in m_lockedRemoteResourceForRemoteClients.
-    auto& clients = m_lockedRemoteResourceForRemoteClients.ensure(renderingResourceIdentifier, [&] {
-        return RemoteClientsHashSet();
-    }).iterator->value;
-
-    clients.add(remoteClientIdentifier);
-}
-
-void RemoteResourceCacheProxy::releaseRemoteResource(RenderingResourceIdentifier renderingResourceIdentifier)
-{
-    ASSERT(!m_pendingUnlockRemoteResourceForRemoteClients.contains(renderingResourceIdentifier));
-
-    // If we have recorded resource -> client dependency before in m_lockedRemoteResourceForRemoteClients, move this
-    // dependency to m_pendingUnlockRemoteResourceForRemoteClients. Otherwise remove the resource in the GPU Process.
-    if (m_lockedRemoteResourceForRemoteClients.contains(renderingResourceIdentifier))
-        m_pendingUnlockRemoteResourceForRemoteClients.add(renderingResourceIdentifier, m_lockedRemoteResourceForRemoteClients.take(renderingResourceIdentifier));
-    else
-        m_remoteRenderingBackendProxy.releaseRemoteResource(renderingResourceIdentifier);
-}
-
-void RemoteResourceCacheProxy::unlockRemoteResourcesForRemoteClient(RenderingResourceIdentifier remoteClientIdentifier)
-{
-    auto removeRemoteClient = [&](RemoteResourceClientsHashMap& remoteResourceForRemoteClients, RenderingResourceIdentifier remoteClientIdentifier) {
-        Vector<RenderingResourceIdentifier> remoteResourceClientsToBeRemoved;
-
-        // Remove all the resource -> client dependencies from remoteResourceClientsHashMap.
-        for (auto& pair : remoteResourceForRemoteClients) {
-            pair.value.remove(remoteClientIdentifier);
-            if (pair.value.isEmpty())
-                remoteResourceClientsToBeRemoved.append(pair.key);
-        }
-
-        // Return a list of the unreferenced resources.
-        return remoteResourceClientsToBeRemoved;
-    };
-
-    // Remove all the resource -> client dependencies from m_lockedRemoteResourceForRemoteClients.
-    for (auto renderingResourceIdentifier : removeRemoteClient(m_lockedRemoteResourceForRemoteClients, remoteClientIdentifier))
-        m_lockedRemoteResourceForRemoteClients.remove(renderingResourceIdentifier);
-
-    // Remove all the resource -> client dependencies from m_pendingUnlockRemoteResourceForRemoteClients.
-    for (auto renderingResourceIdentifier : removeRemoteClient(m_pendingUnlockRemoteResourceForRemoteClients, remoteClientIdentifier)) {
-        // Remove the unreferenced resources from m_remoteResourceClientsPendingReleaseHashMap.
-        m_pendingUnlockRemoteResourceForRemoteClients.remove(renderingResourceIdentifier);
-
-        // Tell the GPU process to remove this resource.
-        m_remoteRenderingBackendProxy.releaseRemoteResource(renderingResourceIdentifier);
-    }
-}
-
 } // namespace WebKit
 
 #endif // ENABLE(GPU_PROCESS)

Modified: trunk/Source/WebKit/WebProcess/GPU/graphics/RemoteResourceCacheProxy.h (269502 => 269503)


--- trunk/Source/WebKit/WebProcess/GPU/graphics/RemoteResourceCacheProxy.h	2020-11-06 04:18:57 UTC (rev 269502)
+++ trunk/Source/WebKit/WebProcess/GPU/graphics/RemoteResourceCacheProxy.h	2020-11-06 07:27:31 UTC (rev 269503)
@@ -36,31 +36,18 @@
 
 namespace WebKit {
 
-class RemoteRenderingBackendProxy;
-
 class RemoteResourceCacheProxy {
 public:
-    RemoteResourceCacheProxy(RemoteRenderingBackendProxy&);
+    RemoteResourceCacheProxy() = default;
 
     void cacheImageBuffer(WebCore::RenderingResourceIdentifier, WebCore::ImageBuffer*);
     WebCore::ImageBuffer* cachedImageBuffer(WebCore::RenderingResourceIdentifier);
     void releaseImageBuffer(WebCore::RenderingResourceIdentifier);
 
-    bool lockRemoteImageBufferForRemoteClient(WebCore::ImageBuffer&, WebCore::RenderingResourceIdentifier remoteClientIdentifier);
-    void unlockRemoteResourcesForRemoteClient(WebCore::RenderingResourceIdentifier remoteClientIdentifier);
-
 private:
-    using RemoteClientsHashSet = HashSet<WebCore::RenderingResourceIdentifier>;
-    using RemoteResourceClientsHashMap = HashMap<WebCore::RenderingResourceIdentifier, RemoteClientsHashSet>;
     using RemoteImageBufferProxyHashMap = HashMap<WebCore::RenderingResourceIdentifier, WebCore::ImageBuffer*>;
 
-    void lockRemoteResourceForRemoteClient(WebCore::RenderingResourceIdentifier, WebCore::RenderingResourceIdentifier remoteClientIdentifier);
-    void releaseRemoteResource(WebCore::RenderingResourceIdentifier);
-
     RemoteImageBufferProxyHashMap m_imageBuffers;
-    RemoteResourceClientsHashMap m_lockedRemoteResourceForRemoteClients;
-    RemoteResourceClientsHashMap m_pendingUnlockRemoteResourceForRemoteClients;
-    RemoteRenderingBackendProxy& m_remoteRenderingBackendProxy;
 };
 
 } // namespace WebKit
_______________________________________________
webkit-changes mailing list
[email protected]
https://lists.webkit.org/mailman/listinfo/webkit-changes

Reply via email to