Changeset 268637 in webkit


Ignore:
Timestamp:
Oct 16, 2020 11:46:25 PM (3 years ago)
Author:
commit-queue@webkit.org
Message:

Source/WebCore:
[GPU Process] Introduce RemoteResourceCache to manage the resources in the GPU Process
https://bugs.webkit.org/show_bug.cgi?id=217554

Patch by Said Abou-Hallawa <sabouhallawa@apple.com> on 2020-10-16
Reviewed by Simon Fraser.

Add a new virtual method named ImageBuffer::flushDisplayList() which
applies a DisplayList to the ImageBuffer::context().

  • platform/graphics/ImageBuffer.h:

(WebCore::ImageBuffer::flushDisplayList):

Source/WebKit:
[GPU Process] Introduce RemoteResourceCacheProxy to manage the resources in the GPU Process
https://bugs.webkit.org/show_bug.cgi?id=217554

Patch by Said Abou-Hallawa <sabouhallawa@apple.com> on 2020-10-16
Reviewed by Simon Fraser.

RemoteResourceCache will be responsible for caching the remote resources.
RemoteRenderingBackend will delegate all the resource caching to its
RemoteResourceCache.

We can get rid of RemoteImageBufferMessageHandler because all it does is
is sending messages to WebProcess. Removing it will simplify the interface
of RemoteImageBuffer. Sending the messages will be moved to RemoteRenderingBackend.

Rename flushDrawingContext() to flushDisplayList() because the name is
confusing. This function flushes a DisplayList to the context. No
DrawingContext is involved here and there is another function with the
same name which does not take any argument.

Rename ImageBufferFlushIdentifier to DisplayListFlushIdentifier to make
more general name and be ready for GPU DOM rendering.

Rename the RemoteRenderingBackendProxy messages: CreateImageBufferBackend
and CommitImageBufferFlushContext to be ImageBufferBackendWasCreated and
FlushDisplayListWasCommitted. We need to include passive verbs in them to
reflect that the actions were taken place in the GPU Process. They are
sent only to inform the Web Process with the current state.

  • GPUProcess/graphics/RemoteImageBuffer.h:

(WebKit::RemoteImageBuffer::RemoteImageBuffer):
(WebKit::RemoteImageBuffer::apply):

  • GPUProcess/graphics/RemoteRenderingBackend.cpp:

(WebKit::RemoteRenderingBackend::gpuConnectionToWebProcess const):
(WebKit::RemoteRenderingBackend::imageBufferBackendWasCreated):
(WebKit::RemoteRenderingBackend::flushDisplayListWasCommitted):
(WebKit::RemoteRenderingBackend::createImageBuffer):
(WebKit::RemoteRenderingBackend::flushDisplayList):
(WebKit::RemoteRenderingBackend::flushDisplayListAndCommit):
(WebKit::RemoteRenderingBackend::getImageData):
We should call the completion handler even if the ImageBuffer was not found.

(WebKit::RemoteRenderingBackend::releaseRemoteResource):
(WebKit::RemoteRenderingBackend::flushImageBufferDrawingContext): Deleted.
(WebKit::RemoteRenderingBackend::flushImageBufferDrawingContextAndCommit): Deleted.

  • GPUProcess/graphics/RemoteRenderingBackend.h:

(WebKit::RemoteRenderingBackend::renderingBackendIdentifier const): Deleted.

  • GPUProcess/graphics/RemoteRenderingBackend.messages.in:
  • GPUProcess/graphics/RemoteResourceCache.cpp: Renamed from Source/WebKit/GPUProcess/graphics/RemoteImageBufferMessageHandler.cpp.

(WebKit::RemoteResourceCache::cacheImageBuffer):
(WebKit::RemoteResourceCache::cachedImageBuffer):
(WebKit::RemoteResourceCache::releaseRemoteResource):

  • GPUProcess/graphics/RemoteResourceCache.h: Renamed from Source/WebKit/GPUProcess/graphics/RemoteImageBufferMessageHandler.h.
  • Scripts/webkit/messages.py:
  • Sources.txt:
  • WebKit.xcodeproj/project.pbxproj:
  • WebProcess/GPU/graphics/DisplayListFlushIdentifier.h: Renamed from Source/WebKit/WebProcess/GPU/graphics/ImageBufferFlushIdentifier.h.
  • WebProcess/GPU/graphics/RemoteImageBufferMessageHandlerProxy.cpp:

(WebKit::RemoteImageBufferMessageHandlerProxy::waitForImageBufferBackendWasCreated):
(WebKit::RemoteImageBufferMessageHandlerProxy::waitForFlushDisplayListWasCommitted):
(WebKit::RemoteImageBufferMessageHandlerProxy::flushDisplayList):
(WebKit::RemoteImageBufferMessageHandlerProxy::flushDisplayListAndWaitCommit):
(WebKit::RemoteImageBufferMessageHandlerProxy::commitFlushContext):
(WebKit::RemoteImageBufferMessageHandlerProxy::waitForCreateImageBufferBackend): Deleted.
(WebKit::RemoteImageBufferMessageHandlerProxy::waitForCommitImageBufferFlushContext): Deleted.
(WebKit::RemoteImageBufferMessageHandlerProxy::flushDrawingContext): Deleted.
(WebKit::RemoteImageBufferMessageHandlerProxy::flushDrawingContextAndWaitCommit): Deleted.

  • WebProcess/GPU/graphics/RemoteImageBufferMessageHandlerProxy.h:
  • WebProcess/GPU/graphics/RemoteImageBufferProxy.h:
  • WebProcess/GPU/graphics/RemoteRenderingBackendProxy.cpp:

(WebKit::RemoteRenderingBackendProxy::waitForImageBufferBackendWasCreated):
(WebKit::RemoteRenderingBackendProxy::waitForFlushDisplayListWasCommitted):
(WebKit::RemoteRenderingBackendProxy::imageBufferBackendWasCreated):
(WebKit::RemoteRenderingBackendProxy::flushDisplayListWasCommitted):
(WebKit::RemoteRenderingBackendProxy::waitForCreateImageBufferBackend): Deleted.
(WebKit::RemoteRenderingBackendProxy::waitForCommitImageBufferFlushContext): Deleted.
(WebKit::RemoteRenderingBackendProxy::createImageBufferBackend): Deleted.
(WebKit::RemoteRenderingBackendProxy::commitImageBufferFlushContext): Deleted.

  • WebProcess/GPU/graphics/RemoteRenderingBackendProxy.h:
  • WebProcess/GPU/graphics/RemoteRenderingBackendProxy.messages.in:
Location:
trunk/Source
Files:
16 edited
3 moved

Legend:

Unmodified
Added
Removed
  • trunk/Source/WebCore/ChangeLog

    r268635 r268637  
     12020-10-16  Said Abou-Hallawa  <sabouhallawa@apple.com>
     2
     3        [GPU Process] Introduce RemoteResourceCache to manage the resources in the GPU Process
     4        https://bugs.webkit.org/show_bug.cgi?id=217554
     5
     6        Reviewed by Simon Fraser.
     7
     8        Add a new virtual method named ImageBuffer::flushDisplayList() which
     9        applies a DisplayList to the ImageBuffer::context().
     10
     11        * platform/graphics/ImageBuffer.h:
     12        (WebCore::ImageBuffer::flushDisplayList):
     13
    1142020-10-16  Devin Rousso  <drousso@apple.com>
    215
  • trunk/Source/WebCore/platform/graphics/ImageBuffer.h

    r267615 r268637  
    3434
    3535namespace DisplayList {
     36class DisplayList;
    3637class DrawingContext;
    3738}
     
    6566    virtual DisplayList::DrawingContext* drawingContext() { return nullptr; }
    6667    virtual void flushDrawingContext() { }
     68    virtual void flushDisplayList(const DisplayList::DisplayList&) { }
    6769
    6870    virtual AffineTransform baseTransform() const = 0;
  • trunk/Source/WebKit/ChangeLog

    r268636 r268637  
     12020-10-16  Said Abou-Hallawa  <sabouhallawa@apple.com>
     2
     3        [GPU Process] Introduce RemoteResourceCacheProxy to manage the resources in the GPU Process
     4        https://bugs.webkit.org/show_bug.cgi?id=217554
     5
     6        Reviewed by Simon Fraser.
     7
     8        RemoteResourceCache will be responsible for caching the remote resources.
     9        RemoteRenderingBackend will delegate all the resource caching to its
     10        RemoteResourceCache.
     11
     12        We can get rid of RemoteImageBufferMessageHandler because all it does is
     13        is sending messages to WebProcess. Removing it will simplify the interface
     14        of RemoteImageBuffer. Sending the messages will be moved to RemoteRenderingBackend.
     15
     16        Rename flushDrawingContext() to flushDisplayList() because the name is
     17        confusing. This function flushes a DisplayList to the context. No
     18        DrawingContext is involved here and there is another function with the
     19        same name which does not take any argument.
     20
     21        Rename ImageBufferFlushIdentifier to DisplayListFlushIdentifier to make
     22        more general name and be ready for GPU DOM rendering.
     23
     24        Rename the RemoteRenderingBackendProxy messages: CreateImageBufferBackend
     25        and CommitImageBufferFlushContext to be ImageBufferBackendWasCreated and
     26        FlushDisplayListWasCommitted. We need to include passive verbs in them to
     27        reflect that the actions were taken place in the GPU Process. They are
     28        sent only to inform the Web Process with the current state.
     29
     30        * GPUProcess/graphics/RemoteImageBuffer.h:
     31        (WebKit::RemoteImageBuffer::RemoteImageBuffer):
     32        (WebKit::RemoteImageBuffer::apply):
     33        * GPUProcess/graphics/RemoteRenderingBackend.cpp:
     34        (WebKit::RemoteRenderingBackend::gpuConnectionToWebProcess const):
     35        (WebKit::RemoteRenderingBackend::imageBufferBackendWasCreated):
     36        (WebKit::RemoteRenderingBackend::flushDisplayListWasCommitted):
     37        (WebKit::RemoteRenderingBackend::createImageBuffer):
     38        (WebKit::RemoteRenderingBackend::flushDisplayList):
     39        (WebKit::RemoteRenderingBackend::flushDisplayListAndCommit):
     40        (WebKit::RemoteRenderingBackend::getImageData):
     41        We should call the completion handler even if the ImageBuffer was not found.
     42
     43        (WebKit::RemoteRenderingBackend::releaseRemoteResource):
     44        (WebKit::RemoteRenderingBackend::flushImageBufferDrawingContext): Deleted.
     45        (WebKit::RemoteRenderingBackend::flushImageBufferDrawingContextAndCommit): Deleted.
     46        * GPUProcess/graphics/RemoteRenderingBackend.h:
     47        (WebKit::RemoteRenderingBackend::renderingBackendIdentifier const): Deleted.
     48        * GPUProcess/graphics/RemoteRenderingBackend.messages.in:
     49        * GPUProcess/graphics/RemoteResourceCache.cpp: Renamed from Source/WebKit/GPUProcess/graphics/RemoteImageBufferMessageHandler.cpp.
     50        (WebKit::RemoteResourceCache::cacheImageBuffer):
     51        (WebKit::RemoteResourceCache::cachedImageBuffer):
     52        (WebKit::RemoteResourceCache::releaseRemoteResource):
     53        * GPUProcess/graphics/RemoteResourceCache.h: Renamed from Source/WebKit/GPUProcess/graphics/RemoteImageBufferMessageHandler.h.
     54        * Scripts/webkit/messages.py:
     55        * Sources.txt:
     56        * WebKit.xcodeproj/project.pbxproj:
     57        * WebProcess/GPU/graphics/DisplayListFlushIdentifier.h: Renamed from Source/WebKit/WebProcess/GPU/graphics/ImageBufferFlushIdentifier.h.
     58        * WebProcess/GPU/graphics/RemoteImageBufferMessageHandlerProxy.cpp:
     59        (WebKit::RemoteImageBufferMessageHandlerProxy::waitForImageBufferBackendWasCreated):
     60        (WebKit::RemoteImageBufferMessageHandlerProxy::waitForFlushDisplayListWasCommitted):
     61        (WebKit::RemoteImageBufferMessageHandlerProxy::flushDisplayList):
     62        (WebKit::RemoteImageBufferMessageHandlerProxy::flushDisplayListAndWaitCommit):
     63        (WebKit::RemoteImageBufferMessageHandlerProxy::commitFlushContext):
     64        (WebKit::RemoteImageBufferMessageHandlerProxy::waitForCreateImageBufferBackend): Deleted.
     65        (WebKit::RemoteImageBufferMessageHandlerProxy::waitForCommitImageBufferFlushContext): Deleted.
     66        (WebKit::RemoteImageBufferMessageHandlerProxy::flushDrawingContext): Deleted.
     67        (WebKit::RemoteImageBufferMessageHandlerProxy::flushDrawingContextAndWaitCommit): Deleted.
     68        * WebProcess/GPU/graphics/RemoteImageBufferMessageHandlerProxy.h:
     69        * WebProcess/GPU/graphics/RemoteImageBufferProxy.h:
     70        * WebProcess/GPU/graphics/RemoteRenderingBackendProxy.cpp:
     71        (WebKit::RemoteRenderingBackendProxy::waitForImageBufferBackendWasCreated):
     72        (WebKit::RemoteRenderingBackendProxy::waitForFlushDisplayListWasCommitted):
     73        (WebKit::RemoteRenderingBackendProxy::imageBufferBackendWasCreated):
     74        (WebKit::RemoteRenderingBackendProxy::flushDisplayListWasCommitted):
     75        (WebKit::RemoteRenderingBackendProxy::waitForCreateImageBufferBackend): Deleted.
     76        (WebKit::RemoteRenderingBackendProxy::waitForCommitImageBufferFlushContext): Deleted.
     77        (WebKit::RemoteRenderingBackendProxy::createImageBufferBackend): Deleted.
     78        (WebKit::RemoteRenderingBackendProxy::commitImageBufferFlushContext): Deleted.
     79        * WebProcess/GPU/graphics/RemoteRenderingBackendProxy.h:
     80        * WebProcess/GPU/graphics/RemoteRenderingBackendProxy.messages.in:
     81
    1822020-10-16  Wenson Hsieh  <wenson_hsieh@apple.com>
    283
  • trunk/Source/WebKit/GPUProcess/graphics/RemoteImageBuffer.h

    r268612 r268637  
    2929
    3030#include "GPUConnectionToWebProcess.h"
    31 #include "RemoteImageBufferMessageHandlerProxy.h"
    3231#include <WebCore/ConcreteImageBuffer.h>
    3332#include <WebCore/DisplayListReplayer.h>
     
    3635
    3736template<typename BackendType>
    38 class RemoteImageBuffer : public WebCore::ConcreteImageBuffer<BackendType>, public RemoteImageBufferMessageHandler, public WebCore::DisplayList::Replayer::Delegate {
     37class RemoteImageBuffer : public WebCore::ConcreteImageBuffer<BackendType>, public WebCore::DisplayList::Replayer::Delegate {
    3938    using BaseConcreteImageBuffer = WebCore::ConcreteImageBuffer<BackendType>;
    4039    using BaseConcreteImageBuffer::context;
    4140    using BaseConcreteImageBuffer::m_backend;
     41    using BaseConcreteImageBuffer::putImageData;
    4242
    4343public:
     
    4949    RemoteImageBuffer(std::unique_ptr<BackendType>&& backend, RemoteRenderingBackend& remoteRenderingBackend, WebCore::RemoteResourceIdentifier remoteResourceIdentifier)
    5050        : BaseConcreteImageBuffer(WTFMove(backend))
    51         , RemoteImageBufferMessageHandler(remoteRenderingBackend, remoteResourceIdentifier)
     51        , m_remoteRenderingBackend(remoteRenderingBackend)
    5252    {
    53         createBackend(m_backend->logicalSize(), m_backend->backendSize(), m_backend->resolutionScale(), m_backend->colorSpace(), m_backend->createImageBufferBackendHandle());
     53        m_remoteRenderingBackend.imageBufferBackendWasCreated(m_backend->logicalSize(), m_backend->backendSize(), m_backend->resolutionScale(), m_backend->colorSpace(), m_backend->createImageBufferBackendHandle(), remoteResourceIdentifier);
    5454    }
    5555
     
    6363
    6464private:
    65     using BaseConcreteImageBuffer::flushDrawingContext;
    66     using BaseConcreteImageBuffer::putImageData;
    67 
    68     void flushDrawingContext(const WebCore::DisplayList::DisplayList& displayList) override
     65    void flushDisplayList(const WebCore::DisplayList::DisplayList& displayList) override
    6966    {
    7067        if (displayList.itemCount()) {
     
    7269            replayer.replay();
    7370        }
    74     }
    75 
    76     void flushDrawingContextAndCommit(const WebCore::DisplayList::DisplayList& displayList, ImageBufferFlushIdentifier flushIdentifier) override
    77     {
    78         flushDrawingContext(displayList);
    79         m_backend->flushContext();
    80         commitFlushContext(flushIdentifier);
    81     }
    82 
    83     RefPtr<WebCore::ImageData> getImageData(WebCore::AlphaPremultiplication outputFormat, const WebCore::IntRect& srcRect) const override
    84     {
    85         return BaseConcreteImageBuffer::getImageData(outputFormat, srcRect);
    8671    }
    8772
     
    10489    void apply(WebCore::DisplayList::PaintFrameForMedia& item, WebCore::GraphicsContext& context)
    10590    {
    106         auto process = backend().gpuConnectionToWebProcess();
     91        auto process = m_remoteRenderingBackend.gpuConnectionToWebProcess();
    10792        if (!process)
    10893            return;
     
    118103        context.paintFrameForMedia(*player, item.destination());
    119104    }
     105   
     106    RemoteRenderingBackend& m_remoteRenderingBackend;
    120107};
    121108
  • trunk/Source/WebKit/GPUProcess/graphics/RemoteRenderingBackend.cpp

    r268612 r268637  
    3232#include "PlatformRemoteImageBuffer.h"
    3333#include "RemoteRenderingBackendMessages.h"
     34#include "RemoteRenderingBackendProxyMessages.h"
    3435
    3536namespace WebKit {
     
    5556}
    5657
     58GPUConnectionToWebProcess* RemoteRenderingBackend::gpuConnectionToWebProcess() const
     59{
     60    return m_gpuConnectionToWebProcess.get();
     61}
     62
    5763IPC::Connection* RemoteRenderingBackend::messageSenderConnection() const
    5864{
     
    6773}
    6874
     75void RemoteRenderingBackend::imageBufferBackendWasCreated(const FloatSize& logicalSize, const IntSize& backendSize, float resolutionScale, ColorSpace colorSpace, ImageBufferBackendHandle handle, RemoteResourceIdentifier remoteResourceIdentifier)
     76{
     77    send(Messages::RemoteRenderingBackendProxy::ImageBufferBackendWasCreated(logicalSize, backendSize, resolutionScale, colorSpace, WTFMove(handle), remoteResourceIdentifier), m_renderingBackendIdentifier);
     78}
     79
     80void RemoteRenderingBackend::flushDisplayListWasCommitted(DisplayListFlushIdentifier flushIdentifier, RemoteResourceIdentifier remoteResourceIdentifier)
     81{
     82    send(Messages::RemoteRenderingBackendProxy::FlushDisplayListWasCommitted(flushIdentifier, remoteResourceIdentifier), m_renderingBackendIdentifier);
     83}
     84
    6985void RemoteRenderingBackend::createImageBuffer(const FloatSize& logicalSize, RenderingMode renderingMode, float resolutionScale, ColorSpace colorSpace, WebCore::RemoteResourceIdentifier remoteResourceIdentifier)
    7086{
    71     auto* gpuConnectionToWebProcess = m_gpuConnectionToWebProcess.get();
    72     if (!gpuConnectionToWebProcess)
     87    ASSERT(renderingMode == RenderingMode::RemoteAccelerated || renderingMode == RenderingMode::RemoteUnaccelerated);
     88
     89    std::unique_ptr<WebCore::ImageBuffer> image;
     90
     91    if (renderingMode == RenderingMode::RemoteAccelerated)
     92        image = AcceleratedRemoteImageBuffer::create(logicalSize, resolutionScale, colorSpace, *this, remoteResourceIdentifier);
     93
     94    if (!image)
     95        image = UnacceleratedRemoteImageBuffer::create(logicalSize, resolutionScale, colorSpace, *this, remoteResourceIdentifier);
     96
     97    if (image) {
     98        m_remoteResourceCache.cacheImageBuffer(remoteResourceIdentifier, WTFMove(image));
    7399        return;
    74 
    75     if (m_imageBufferMessageHandlerMap.contains(remoteResourceIdentifier)) {
    76         ASSERT_NOT_REACHED();
    77         return;
    78     }
    79 
    80     if (renderingMode == RenderingMode::RemoteAccelerated) {
    81         if (auto imageBuffer = AcceleratedRemoteImageBuffer::create(logicalSize, resolutionScale, colorSpace, *this, remoteResourceIdentifier)) {
    82             m_imageBufferMessageHandlerMap.add(remoteResourceIdentifier, WTFMove(imageBuffer));
    83             return;
    84         }
    85     }
    86 
    87     if (renderingMode == RenderingMode::RemoteAccelerated || renderingMode == RenderingMode::RemoteUnaccelerated) {
    88         if (auto imageBuffer = UnacceleratedRemoteImageBuffer::create(logicalSize, resolutionScale, colorSpace, *this, remoteResourceIdentifier)) {
    89             m_imageBufferMessageHandlerMap.add(remoteResourceIdentifier, WTFMove(imageBuffer));
    90             return;
    91         }
    92100    }
    93101
     
    95103}
    96104
    97 void RemoteRenderingBackend::releaseRemoteResource(RemoteResourceIdentifier remoteResourceIdentifier)
     105void RemoteRenderingBackend::flushDisplayList(const WebCore::DisplayList::DisplayList& displayList, RemoteResourceIdentifier remoteResourceIdentifier)
    98106{
    99     // CreateImageBuffer message should have been received before this one.
    100     bool found = m_imageBufferMessageHandlerMap.remove(remoteResourceIdentifier);
    101     ASSERT_UNUSED(found, found);
     107    if (auto imageBuffer = m_remoteResourceCache.cachedImageBuffer(remoteResourceIdentifier))
     108        imageBuffer->flushDisplayList(displayList);
     109}
     110
     111void RemoteRenderingBackend::flushDisplayListAndCommit(const WebCore::DisplayList::DisplayList& displayList, DisplayListFlushIdentifier flushIdentifier, RemoteResourceIdentifier remoteResourceIdentifier)
     112{
     113    if (auto imageBuffer = m_remoteResourceCache.cachedImageBuffer(remoteResourceIdentifier)) {
     114        imageBuffer->flushDisplayList(displayList);
     115        imageBuffer->flushContext();
     116        flushDisplayListWasCommitted(flushIdentifier, remoteResourceIdentifier);
     117    }
    102118}
    103119
    104120void RemoteRenderingBackend::getImageData(WebCore::AlphaPremultiplication outputFormat, WebCore::IntRect srcRect, RemoteResourceIdentifier remoteResourceIdentifier, CompletionHandler<void(IPC::ImageDataReference&&)>&& completionHandler)
    105121{
    106     if (auto imageBuffer = m_imageBufferMessageHandlerMap.get(remoteResourceIdentifier)) {
    107         auto imageData = imageBuffer->getImageData(outputFormat, srcRect);
    108         completionHandler(IPC::ImageDataReference(WTFMove(imageData)));
    109     }
     122    RefPtr<ImageData> imageData;
     123    if (auto imageBuffer = m_remoteResourceCache.cachedImageBuffer(remoteResourceIdentifier))
     124        imageData = imageBuffer->getImageData(outputFormat, srcRect);
     125    completionHandler(IPC::ImageDataReference(WTFMove(imageData)));
    110126}
    111127
    112 void RemoteRenderingBackend::flushImageBufferDrawingContext(const WebCore::DisplayList::DisplayList& displayList, RemoteResourceIdentifier remoteResourceIdentifier)
     128void RemoteRenderingBackend::releaseRemoteResource(RemoteResourceIdentifier remoteResourceIdentifier)
    113129{
    114     if (auto imageBuffer = m_imageBufferMessageHandlerMap.get(remoteResourceIdentifier))
    115         imageBuffer->flushDrawingContext(displayList);
    116 }
    117 
    118 void RemoteRenderingBackend::flushImageBufferDrawingContextAndCommit(const WebCore::DisplayList::DisplayList& displayList, ImageBufferFlushIdentifier flushIdentifier, RemoteResourceIdentifier remoteResourceIdentifier)
    119 {
    120     if (auto imageBuffer = m_imageBufferMessageHandlerMap.get(remoteResourceIdentifier))
    121         imageBuffer->flushDrawingContextAndCommit(displayList, flushIdentifier);
    122 }
    123 
    124 GPUConnectionToWebProcess* RemoteRenderingBackend::gpuConnectionToWebProcess() const
    125 {
    126     return m_gpuConnectionToWebProcess.get();
     130    m_remoteResourceCache.releaseRemoteResource(remoteResourceIdentifier);
    127131}
    128132
  • trunk/Source/WebKit/GPUProcess/graphics/RemoteRenderingBackend.h

    r268612 r268637  
    2929
    3030#include "Connection.h"
    31 #include "ImageBufferFlushIdentifier.h"
     31#include "DisplayListFlushIdentifier.h"
     32#include "ImageBufferBackendHandle.h"
    3233#include "ImageDataReference.h"
    3334#include "MessageReceiver.h"
    3435#include "MessageSender.h"
    35 #include "RemoteImageBufferMessageHandler.h"
     36#include "RemoteResourceCache.h"
    3637#include "RenderingBackendIdentifier.h"
    3738#include <WebCore/ColorSpace.h>
    3839#include <WebCore/DisplayListItems.h>
    39 #include <WebCore/FloatSize.h>
    40 #include <WebCore/RemoteResourceIdentifier.h>
    41 #include <WebCore/RenderingMode.h>
    42 #include <wtf/HashMap.h>
    4340#include <wtf/WeakPtr.h>
    4441
     
    4744class DisplayList;
    4845}
     46class FloatSize;
     47enum class ColorSpace : uint8_t;
     48enum class RenderingMode : uint8_t;
    4949}
    5050
     
    6060    virtual ~RemoteRenderingBackend();
    6161
    62     RenderingBackendIdentifier renderingBackendIdentifier() const { return m_renderingBackendIdentifier; }
    6362    GPUConnectionToWebProcess* gpuConnectionToWebProcess() const;
     63
     64    // Messages to be sent.
     65    void imageBufferBackendWasCreated(const WebCore::FloatSize& logicalSize, const WebCore::IntSize& backendSize, float resolutionScale, WebCore::ColorSpace, ImageBufferBackendHandle, WebCore::RemoteResourceIdentifier);
     66    void flushDisplayListWasCommitted(DisplayListFlushIdentifier, WebCore::RemoteResourceIdentifier);
    6467
    6568private:
     
    7679    // Messages to be received.
    7780    void createImageBuffer(const WebCore::FloatSize& logicalSize, WebCore::RenderingMode, float resolutionScale, WebCore::ColorSpace, WebCore::RemoteResourceIdentifier);
     81    void flushDisplayList(const WebCore::DisplayList::DisplayList&, WebCore::RemoteResourceIdentifier);
     82    void flushDisplayListAndCommit(const WebCore::DisplayList::DisplayList&, DisplayListFlushIdentifier, WebCore::RemoteResourceIdentifier);
     83    void getImageData(WebCore::AlphaPremultiplication outputFormat, WebCore::IntRect srcRect, WebCore::RemoteResourceIdentifier, CompletionHandler<void(IPC::ImageDataReference&&)>&&);
    7884    void releaseRemoteResource(WebCore::RemoteResourceIdentifier);
    79     void flushImageBufferDrawingContext(const WebCore::DisplayList::DisplayList&, WebCore::RemoteResourceIdentifier);
    80     void flushImageBufferDrawingContextAndCommit(const WebCore::DisplayList::DisplayList&, ImageBufferFlushIdentifier, WebCore::RemoteResourceIdentifier);
    81     void getImageData(WebCore::AlphaPremultiplication outputFormat, WebCore::IntRect srcRect, WebCore::RemoteResourceIdentifier, CompletionHandler<void(IPC::ImageDataReference&&)>&&);
    8285
    83     using ImageBufferMessageHandlerMap = HashMap<WebCore::RemoteResourceIdentifier, std::unique_ptr<RemoteImageBufferMessageHandler>>;
    84     ImageBufferMessageHandlerMap m_imageBufferMessageHandlerMap;
     86    RemoteResourceCache m_remoteResourceCache;
    8587    WeakPtr<GPUConnectionToWebProcess> m_gpuConnectionToWebProcess;
    8688    RenderingBackendIdentifier m_renderingBackendIdentifier;
  • trunk/Source/WebKit/GPUProcess/graphics/RemoteRenderingBackend.messages.in

    r268612 r268637  
    2525messages -> RemoteRenderingBackend NotRefCounted {
    2626    void CreateImageBuffer(WebCore::FloatSize logicalSize, WebCore::RenderingMode renderingMode, float resolutionScale, WebCore::ColorSpace colorSpace, WebCore::RemoteResourceIdentifier remoteResourceIdentifier)
    27     void FlushImageBufferDrawingContext(WebCore::DisplayList::DisplayList displayList, WebCore::RemoteResourceIdentifier remoteResourceIdentifier)
    28     void FlushImageBufferDrawingContextAndCommit(WebCore::DisplayList::DisplayList displayList, WebKit::ImageBufferFlushIdentifier flushIdentifier, WebCore::RemoteResourceIdentifier remoteResourceIdentifier)
     27    void FlushDisplayList(WebCore::DisplayList::DisplayList displayList, WebCore::RemoteResourceIdentifier remoteResourceIdentifier)
     28    void FlushDisplayListAndCommit(WebCore::DisplayList::DisplayList displayList, WebKit::DisplayListFlushIdentifier flushIdentifier, WebCore::RemoteResourceIdentifier remoteResourceIdentifier)
    2929    GetImageData(enum:uint8_t WebCore::AlphaPremultiplication outputFormat, WebCore::IntRect srcRect, WebCore::RemoteResourceIdentifier remoteResourceIdentifier) -> (IPC::ImageDataReference imageData) Synchronous
    3030    void ReleaseRemoteResource(WebCore::RemoteResourceIdentifier remoteResourceIdentifier)
  • trunk/Source/WebKit/GPUProcess/graphics/RemoteResourceCache.cpp

    r268636 r268637  
    2525
    2626#include "config.h"
    27 #include "RemoteImageBufferMessageHandler.h"
     27#include "RemoteResourceCache.h"
    2828
    2929#if ENABLE(GPU_PROCESS)
    30 
    31 #include "RemoteRenderingBackend.h"
    32 #include "RemoteRenderingBackendProxyMessages.h"
    3330
    3431namespace WebKit {
    3532using namespace WebCore;
    3633
    37 RemoteImageBufferMessageHandler::RemoteImageBufferMessageHandler(RemoteRenderingBackend& remoteRenderingBackend, WebCore::RemoteResourceIdentifier remoteResourceIdentifier)
    38     : m_remoteRenderingBackend(remoteRenderingBackend)
    39     , m_remoteResourceIdentifier(remoteResourceIdentifier)
     34void RemoteResourceCache::cacheImageBuffer(RemoteResourceIdentifier remoteResourceIdentifier, std::unique_ptr<ImageBuffer>&& image)
    4035{
     36    auto addResult = m_imageBuffers.add(remoteResourceIdentifier, WTFMove(image));
     37    ASSERT_UNUSED(addResult, addResult.isNewEntry);
    4138}
    4239
    43 void RemoteImageBufferMessageHandler::createBackend(const FloatSize& logicalSize, const IntSize& backendSize, float resolutionScale, ColorSpace colorSpace, ImageBufferBackendHandle handle)
     40WebCore::ImageBuffer* RemoteResourceCache::cachedImageBuffer(RemoteResourceIdentifier remoteResourceIdentifier)
    4441{
    45     m_remoteRenderingBackend.send(Messages::RemoteRenderingBackendProxy::CreateImageBufferBackend(logicalSize, backendSize, resolutionScale, colorSpace, WTFMove(handle), m_remoteResourceIdentifier), m_remoteRenderingBackend.renderingBackendIdentifier());
     42    return m_imageBuffers.get(remoteResourceIdentifier);
    4643}
    4744
    48 void RemoteImageBufferMessageHandler::commitFlushContext(ImageBufferFlushIdentifier flushIdentifier)
     45void RemoteResourceCache::releaseRemoteResource(RemoteResourceIdentifier remoteResourceIdentifier)
    4946{
    50     m_remoteRenderingBackend.send(Messages::RemoteRenderingBackendProxy::CommitImageBufferFlushContext(flushIdentifier, m_remoteResourceIdentifier), m_remoteRenderingBackend.renderingBackendIdentifier());
     47    if (m_imageBuffers.remove(remoteResourceIdentifier))
     48        return;
     49    // Caching the remote resource should have happened before releasing it.
     50    ASSERT_NOT_REACHED();
    5151}
    5252
  • trunk/Source/WebKit/GPUProcess/graphics/RemoteResourceCache.h

    r268636 r268637  
    2828#if ENABLE(GPU_PROCESS)
    2929
    30 #include "ImageBufferBackendHandle.h"
    31 #include "ImageBufferFlushIdentifier.h"
    32 #include <WebCore/ColorSpace.h>
    33 #include <WebCore/DisplayList.h>
    34 #include <WebCore/FloatSize.h>
    3530#include <WebCore/RemoteResourceIdentifier.h>
     31#include <wtf/HashMap.h>
    3632
    3733namespace WebCore {
    38 enum class AlphaPremultiplication : uint8_t;
    39 class ImageData;
     34class ImageBuffer;
    4035}
    4136
     
    4439class RemoteRenderingBackend;
    4540
    46 class RemoteImageBufferMessageHandler {
     41class RemoteResourceCache {
    4742public:
    48     virtual ~RemoteImageBufferMessageHandler() = default;
     43    RemoteResourceCache() = default;
    4944
    50     // Messages to be received. See RemoteRenderingBackend.messages.in.
    51     virtual void flushDrawingContext(const WebCore::DisplayList::DisplayList&) = 0;
    52     virtual void flushDrawingContextAndCommit(const WebCore::DisplayList::DisplayList&, ImageBufferFlushIdentifier) = 0;
    53     virtual RefPtr<WebCore::ImageData> getImageData(WebCore::AlphaPremultiplication outputFormat, const WebCore::IntRect& srcRect) const = 0;
    54 
    55 protected:
    56     RemoteImageBufferMessageHandler(RemoteRenderingBackend&, WebCore::RemoteResourceIdentifier);
    57 
    58     // Messages to be sent. See RemoteRenderingBackend.messages.in.
    59     void createBackend(const WebCore::FloatSize& logicalSize, const WebCore::IntSize& backendSize, float resolutionScale, WebCore::ColorSpace, ImageBufferBackendHandle);
    60     void commitFlushContext(ImageBufferFlushIdentifier);
    61 
    62     RemoteRenderingBackend& backend() { return m_remoteRenderingBackend; }
     45    void cacheImageBuffer(WebCore::RemoteResourceIdentifier, std::unique_ptr<WebCore::ImageBuffer>&&);
     46    WebCore::ImageBuffer* cachedImageBuffer(WebCore::RemoteResourceIdentifier);
     47    void releaseRemoteResource(WebCore::RemoteResourceIdentifier);
    6348
    6449private:
    65     RemoteRenderingBackend& m_remoteRenderingBackend;
    66     WebCore::RemoteResourceIdentifier m_remoteResourceIdentifier;
     50    using RemoteImageBufferHashMap = HashMap<WebCore::RemoteResourceIdentifier, std::unique_ptr<WebCore::ImageBuffer>>;
     51
     52    RemoteImageBufferHashMap m_imageBuffers;
    6753};
    6854
  • trunk/Source/WebKit/Scripts/webkit/messages.py

    r268635 r268637  
    238238        'WebKit::ContentWorldIdentifier',
    239239        'WebKit::DisplayLinkObserverID',
     240        'WebKit::DisplayListFlushIdentifier',
    240241        'WebKit::DownloadID',
    241242        'WebKit::GeolocationIdentifier',
    242243        'WebKit::ImageBufferBackendHandle',
    243         'WebKit::ImageBufferFlushIdentifier',
    244244        'WebKit::LayerHostingContextID',
    245245        'WebKit::LegacyCustomProtocolID',
  • trunk/Source/WebKit/Sources.txt

    r268612 r268637  
    2525GPUProcess/GPUConnectionToWebProcess.cpp
    2626GPUProcess/GPUProcessCreationParameters.cpp
    27 GPUProcess/graphics/RemoteImageBufferMessageHandler.cpp
    2827GPUProcess/graphics/RemoteRenderingBackend.cpp
     28GPUProcess/graphics/RemoteResourceCache.cpp
    2929GPUProcess/media/RemoteAudioSessionProxy.cpp
    3030GPUProcess/media/RemoteAudioSessionProxyManager.cpp
  • trunk/Source/WebKit/WebKit.xcodeproj/project.pbxproj

    r268632 r268637  
    10971097                570DAAC623037F7F00E8FC04 /* WKNFReaderSessionDelegate.h in Headers */ = {isa = PBXBuildFile; fileRef = 570DAAC423037F7E00E8FC04 /* WKNFReaderSessionDelegate.h */; };
    10981098                570DAACA230385FD00E8FC04 /* CtapNfcDriver.h in Headers */ = {isa = PBXBuildFile; fileRef = 570DAAC8230385FD00E8FC04 /* CtapNfcDriver.h */; };
    1099                 572EBBDA2538F6B4000552B3 /* AppAttestInternalSoftLink.mm in Sources */ = {isa = PBXBuildFile; fileRef = 572EBBD82538F6A1000552B3 /* AppAttestInternalSoftLink.mm */; };
    1100                 572EBBDB2538F6B6000552B3 /* AppAttestInternalSoftLink.h in Headers */ = {isa = PBXBuildFile; fileRef = 572EBBD92538F6A1000552B3 /* AppAttestInternalSoftLink.h */; };
    1101                 572EBBDD25392181000552B3 /* AppAttestSPI.h in Headers */ = {isa = PBXBuildFile; fileRef = 572EBBDC25392181000552B3 /* AppAttestSPI.h */; };
    11021099                572EBBBF2536A60A000552B3 /* WebAuthnConnectionToWebProcessMessageReceiver.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 572EBBBB2536A60A000552B3 /* WebAuthnConnectionToWebProcessMessageReceiver.cpp */; };
    11031100                572EBBC02536A60A000552B3 /* WebAuthnConnectionToWebProcessMessages.h in Headers */ = {isa = PBXBuildFile; fileRef = 572EBBBC2536A60A000552B3 /* WebAuthnConnectionToWebProcessMessages.h */; };
     
    11111108                572EBBD52536C885000552B3 /* WebAuthnProcessConnection.h in Headers */ = {isa = PBXBuildFile; fileRef = 572EBBD22536C885000552B3 /* WebAuthnProcessConnection.h */; };
    11121109                572EBBD72537EBAE000552B3 /* ExtraPrivateSymbolsForTAPI.h in Headers */ = {isa = PBXBuildFile; fileRef = ECA680D31E6904B500731D20 /* ExtraPrivateSymbolsForTAPI.h */; };
     1110                572EBBDA2538F6B4000552B3 /* AppAttestInternalSoftLink.mm in Sources */ = {isa = PBXBuildFile; fileRef = 572EBBD82538F6A1000552B3 /* AppAttestInternalSoftLink.mm */; };
     1111                572EBBDB2538F6B6000552B3 /* AppAttestInternalSoftLink.h in Headers */ = {isa = PBXBuildFile; fileRef = 572EBBD92538F6A1000552B3 /* AppAttestInternalSoftLink.h */; };
     1112                572EBBDD25392181000552B3 /* AppAttestSPI.h in Headers */ = {isa = PBXBuildFile; fileRef = 572EBBDC25392181000552B3 /* AppAttestSPI.h */; };
    11131113                572FD44322265CE200A1ECC3 /* WebViewDidMoveToWindowObserver.h in Headers */ = {isa = PBXBuildFile; fileRef = 572FD44122265CE200A1ECC3 /* WebViewDidMoveToWindowObserver.h */; };
    11141114                574217922400E286002B303D /* LocalAuthenticationSPI.h in Headers */ = {isa = PBXBuildFile; fileRef = 574217912400E098002B303D /* LocalAuthenticationSPI.h */; };
     
    39143914                55AD09422408A02E00DE4D2F /* RemoteImageBuffer.h */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.c.h; path = RemoteImageBuffer.h; sourceTree = "<group>"; };
    39153915                55AD09432408A0E600DE4D2F /* PlatformRemoteImageBuffer.h */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.c.h; path = PlatformRemoteImageBuffer.h; sourceTree = "<group>"; };
    3916                 55AD09442408ABB300DE4D2F /* ImageBufferFlushIdentifier.h */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.c.h; path = ImageBufferFlushIdentifier.h; sourceTree = "<group>"; };
     3916                55AD09442408ABB300DE4D2F /* DisplayListFlushIdentifier.h */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.c.h; path = DisplayListFlushIdentifier.h; sourceTree = "<group>"; };
    39173917                570AB8F220AE3BD700B8BE87 /* SecKeyProxyStore.h */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.c.h; path = SecKeyProxyStore.h; sourceTree = "<group>"; };
    39183918                570AB90020B2517400B8BE87 /* AuthenticationChallengeProxyCocoa.mm */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.cpp.objcpp; path = AuthenticationChallengeProxyCocoa.mm; sourceTree = "<group>"; };
     
    39283928                570DAAC8230385FD00E8FC04 /* CtapNfcDriver.h */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.c.h; path = CtapNfcDriver.h; sourceTree = "<group>"; };
    39293929                570DAAC9230385FD00E8FC04 /* CtapNfcDriver.cpp */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.cpp.cpp; path = CtapNfcDriver.cpp; sourceTree = "<group>"; };
    3930                 572EBBD82538F6A1000552B3 /* AppAttestInternalSoftLink.mm */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.cpp.objcpp; path = AppAttestInternalSoftLink.mm; sourceTree = "<group>"; };
    3931                 572EBBD92538F6A1000552B3 /* AppAttestInternalSoftLink.h */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.c.h; path = AppAttestInternalSoftLink.h; sourceTree = "<group>"; };
    3932                 572EBBDC25392181000552B3 /* AppAttestSPI.h */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.c.h; path = AppAttestSPI.h; sourceTree = "<group>"; };
    39333930                572EBBB92536A06E000552B3 /* Info-iOS.plist */ = {isa = PBXFileReference; lastKnownFileType = text.plist; name = "Info-iOS.plist"; path = "WebAuthnProcess/EntryPoint/Cocoa/XPCService/WebAuthnService/Info-iOS.plist"; sourceTree = SOURCE_ROOT; };
    39343931                572EBBBA2536A06E000552B3 /* Info-OSX.plist */ = {isa = PBXFileReference; lastKnownFileType = text.plist; name = "Info-OSX.plist"; path = "WebAuthnProcess/EntryPoint/Cocoa/XPCService/WebAuthnService/Info-OSX.plist"; sourceTree = SOURCE_ROOT; };
     
    39473944                572EBBD22536C885000552B3 /* WebAuthnProcessConnection.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = WebAuthnProcessConnection.h; sourceTree = "<group>"; };
    39483945                572EBBD32536C885000552B3 /* WebAuthnProcessConnection.messages.in */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text; path = WebAuthnProcessConnection.messages.in; sourceTree = "<group>"; };
     3946                572EBBD82538F6A1000552B3 /* AppAttestInternalSoftLink.mm */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.cpp.objcpp; path = AppAttestInternalSoftLink.mm; sourceTree = "<group>"; };
     3947                572EBBD92538F6A1000552B3 /* AppAttestInternalSoftLink.h */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.c.h; path = AppAttestInternalSoftLink.h; sourceTree = "<group>"; };
     3948                572EBBDC25392181000552B3 /* AppAttestSPI.h */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.c.h; path = AppAttestSPI.h; sourceTree = "<group>"; };
    39493949                572FD44122265CE200A1ECC3 /* WebViewDidMoveToWindowObserver.h */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.c.h; path = WebViewDidMoveToWindowObserver.h; sourceTree = "<group>"; };
    39503950                574217912400E098002B303D /* LocalAuthenticationSPI.h */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.c.h; path = LocalAuthenticationSPI.h; sourceTree = "<group>"; };
     
    42274227                7227800C24097A02007D376B /* RemoteImageBufferMessageHandlerProxy.cpp */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.cpp.cpp; path = RemoteImageBufferMessageHandlerProxy.cpp; sourceTree = "<group>"; };
    42284228                7227800D24097A02007D376B /* RemoteImageBufferMessageHandlerProxy.h */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.c.h; path = RemoteImageBufferMessageHandlerProxy.h; sourceTree = "<group>"; };
    4229                 722780112409906E007D376B /* RemoteImageBufferMessageHandler.cpp */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.cpp.cpp; path = RemoteImageBufferMessageHandler.cpp; sourceTree = "<group>"; };
    4230                 722780122409906E007D376B /* RemoteImageBufferMessageHandler.h */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.c.h; path = RemoteImageBufferMessageHandler.h; sourceTree = "<group>"; };
     4229                726D56DD253A64810002EF90 /* RemoteResourceCache.cpp */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.cpp.cpp; path = RemoteResourceCache.cpp; sourceTree = "<group>"; };
     4230                726D56DE253A64810002EF90 /* RemoteResourceCache.h */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.c.h; path = RemoteResourceCache.h; sourceTree = "<group>"; };
    42314231                727A7F342407857D004D2931 /* ImageBufferShareableIOSurfaceBackend.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = ImageBufferShareableIOSurfaceBackend.cpp; sourceTree = "<group>"; };
    42324232                727A7F352407857F004D2931 /* ImageBufferShareableIOSurfaceBackend.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = ImageBufferShareableIOSurfaceBackend.h; sourceTree = "<group>"; };
     
    81338133                        children = (
    81348134                                727A7F3324078527004D2931 /* cocoa */,
     8135                                55AD09442408ABB300DE4D2F /* DisplayListFlushIdentifier.h */,
    81358136                                727A7F39240788F1004D2931 /* ImageBufferBackendHandle.h */,
    8136                                 55AD09442408ABB300DE4D2F /* ImageBufferFlushIdentifier.h */,
    81378137                                727A7F37240788F0004D2931 /* ImageBufferShareableBitmapBackend.cpp */,
    81388138                                727A7F36240788F0004D2931 /* ImageBufferShareableBitmapBackend.h */,
     
    81558155                                55AD09432408A0E600DE4D2F /* PlatformRemoteImageBuffer.h */,
    81568156                                55AD09422408A02E00DE4D2F /* RemoteImageBuffer.h */,
    8157                                 722780112409906E007D376B /* RemoteImageBufferMessageHandler.cpp */,
    8158                                 722780122409906E007D376B /* RemoteImageBufferMessageHandler.h */,
    81598157                                550640A224071A6100AAE045 /* RemoteRenderingBackend.cpp */,
    81608158                                550640A324071A6100AAE045 /* RemoteRenderingBackend.h */,
    81618159                                550640A424071C2100AAE045 /* RemoteRenderingBackend.messages.in */,
     8160                                726D56DD253A64810002EF90 /* RemoteResourceCache.cpp */,
     8161                                726D56DE253A64810002EF90 /* RemoteResourceCache.h */,
    81628162                        );
    81638163                        path = graphics;
  • trunk/Source/WebKit/WebProcess/GPU/graphics/DisplayListFlushIdentifier.h

    r268636 r268637  
    3232namespace WebKit {
    3333
    34 enum ImageBufferFlushIdentifierType { };
    35 using ImageBufferFlushIdentifier = ObjectIdentifier<ImageBufferFlushIdentifierType>;
     34enum DisplayListFlushIdentifierType { };
     35using DisplayListFlushIdentifier = ObjectIdentifier<DisplayListFlushIdentifierType>;
    3636
    3737} // namespace WebKit
  • trunk/Source/WebKit/WebProcess/GPU/graphics/RemoteImageBufferMessageHandlerProxy.cpp

    r268636 r268637  
    6060}
    6161
    62 void RemoteImageBufferMessageHandlerProxy::waitForCreateImageBufferBackend()
     62void RemoteImageBufferMessageHandlerProxy::waitForImageBufferBackendWasCreated()
    6363{
    6464    if (m_remoteRenderingBackendProxy && !isBackendCreated())
    65         m_remoteRenderingBackendProxy->waitForCreateImageBufferBackend();
     65        m_remoteRenderingBackendProxy->waitForImageBufferBackendWasCreated();
    6666}
    6767
    68 void RemoteImageBufferMessageHandlerProxy::waitForCommitImageBufferFlushContext()
     68void RemoteImageBufferMessageHandlerProxy::waitForFlushDisplayListWasCommitted()
    6969{
    7070    if (m_remoteRenderingBackendProxy && isPendingFlush())
    71         m_remoteRenderingBackendProxy->waitForCommitImageBufferFlushContext();
     71        m_remoteRenderingBackendProxy->waitForFlushDisplayListWasCommitted();
    7272}
    7373
    74 void RemoteImageBufferMessageHandlerProxy::flushDrawingContext(WebCore::DisplayList::DisplayList& displayList)
     74void RemoteImageBufferMessageHandlerProxy::flushDisplayList(WebCore::DisplayList::DisplayList& displayList)
    7575{
    7676    if (!m_remoteRenderingBackendProxy)
     
    7878   
    7979    TraceScope tracingScope(FlushRemoteImageBufferStart, FlushRemoteImageBufferEnd);
    80     m_remoteRenderingBackendProxy->send(Messages::RemoteRenderingBackend::FlushImageBufferDrawingContext(displayList, m_remoteResourceIdentifier), m_remoteRenderingBackendProxy->renderingBackendIdentifier());
     80    m_remoteRenderingBackendProxy->send(Messages::RemoteRenderingBackend::FlushDisplayList(displayList, m_remoteResourceIdentifier), m_remoteRenderingBackendProxy->renderingBackendIdentifier());
    8181    displayList.clear();
    8282}
    8383
    84 void RemoteImageBufferMessageHandlerProxy::flushDrawingContextAndWaitCommit(WebCore::DisplayList::DisplayList& displayList)
     84void RemoteImageBufferMessageHandlerProxy::flushDisplayListAndWaitCommit(WebCore::DisplayList::DisplayList& displayList)
    8585{
    8686    if (!m_remoteRenderingBackendProxy)
     
    8888
    8989    TraceScope tracingScope(FlushRemoteImageBufferStart, FlushRemoteImageBufferEnd, 1);
    90     m_sentFlushIdentifier = ImageBufferFlushIdentifier::generate();
    91     m_remoteRenderingBackendProxy->send(Messages::RemoteRenderingBackend::FlushImageBufferDrawingContextAndCommit(displayList, m_sentFlushIdentifier, m_remoteResourceIdentifier), m_remoteRenderingBackendProxy->renderingBackendIdentifier());
     90    m_sentFlushIdentifier = DisplayListFlushIdentifier::generate();
     91    m_remoteRenderingBackendProxy->send(Messages::RemoteRenderingBackend::FlushDisplayListAndCommit(displayList, m_sentFlushIdentifier, m_remoteResourceIdentifier), m_remoteRenderingBackendProxy->renderingBackendIdentifier());
    9292    displayList.clear();
    93     waitForCommitImageBufferFlushContext();
     93    waitForFlushDisplayListWasCommitted();
    9494}
    9595
    96 void RemoteImageBufferMessageHandlerProxy::commitFlushContext(ImageBufferFlushIdentifier flushIdentifier)
     96void RemoteImageBufferMessageHandlerProxy::commitFlushContext(DisplayListFlushIdentifier flushIdentifier)
    9797{
    9898    m_receivedFlushIdentifier = flushIdentifier;
  • trunk/Source/WebKit/WebProcess/GPU/graphics/RemoteImageBufferMessageHandlerProxy.h

    r268612 r268637  
    2828#if ENABLE(GPU_PROCESS)
    2929
     30#include "DisplayListFlushIdentifier.h"
    3031#include "ImageBufferBackendHandle.h"
    31 #include "ImageBufferFlushIdentifier.h"
    3232#include <WebCore/ColorSpace.h>
    3333#include <WebCore/DisplayList.h>
     
    5454    virtual void createBackend(const WebCore::FloatSize& logicalSize, const WebCore::IntSize& backendSize, float resolutionScale, WebCore::ColorSpace, ImageBufferBackendHandle) = 0;
    5555
    56     void commitFlushContext(ImageBufferFlushIdentifier);
     56    void commitFlushContext(DisplayListFlushIdentifier);
    5757
    5858protected:
     
    6464    RefPtr<WebCore::ImageData> getImageData(WebCore::AlphaPremultiplication outputFormat, const WebCore::IntRect& srcRect) const;
    6565
    66     void waitForCreateImageBufferBackend();
    67     void waitForCommitImageBufferFlushContext();
     66    void waitForImageBufferBackendWasCreated();
     67    void waitForFlushDisplayListWasCommitted();
    6868
    6969    // Messages to be sent. See RemoteRenderingBackendProxy.messages.in.
    70     void flushDrawingContext(WebCore::DisplayList::DisplayList&);
    71     void flushDrawingContextAndWaitCommit(WebCore::DisplayList::DisplayList&);
     70    void flushDisplayList(WebCore::DisplayList::DisplayList&);
     71    void flushDisplayListAndWaitCommit(WebCore::DisplayList::DisplayList&);
    7272
    7373private:
     
    7575    WebCore::RemoteResourceIdentifier m_remoteResourceIdentifier { WebCore::RemoteResourceIdentifier::generate() };
    7676
    77     ImageBufferFlushIdentifier m_sentFlushIdentifier;
    78     ImageBufferFlushIdentifier m_receivedFlushIdentifier;
     77    DisplayListFlushIdentifier m_sentFlushIdentifier;
     78    DisplayListFlushIdentifier m_receivedFlushIdentifier;
    7979};
    8080
  • trunk/Source/WebKit/WebProcess/GPU/graphics/RemoteImageBufferProxy.h

    r268612 r268637  
    7575    {
    7676        if (!m_backend)
    77             const_cast<RemoteImageBufferProxy&>(*this).RemoteImageBufferMessageHandlerProxy::waitForCreateImageBufferBackend();
     77            const_cast<RemoteImageBufferProxy&>(*this).RemoteImageBufferMessageHandlerProxy::waitForImageBufferBackendWasCreated();
    7878        return m_backend.get();
    7979    }
     
    8282    {
    8383        auto& displayList = const_cast<RemoteImageBufferProxy*>(this)->m_drawingContext.displayList();
    84         const_cast<RemoteImageBufferProxy*>(this)->RemoteImageBufferMessageHandlerProxy::flushDrawingContext(displayList);
     84        const_cast<RemoteImageBufferProxy*>(this)->RemoteImageBufferMessageHandlerProxy::flushDisplayList(displayList);
    8585        auto result = const_cast<RemoteImageBufferProxy*>(this)->RemoteImageBufferMessageHandlerProxy::getImageData(outputFormat, srcRect);
    8686        // getImageData is synchronous, which means we've already received the CommitImageBufferFlushContext message.
     
    106106        auto& displayList = m_drawingContext.displayList();
    107107        if (displayList.itemCount())
    108             RemoteImageBufferMessageHandlerProxy::flushDrawingContextAndWaitCommit(displayList);
     108            RemoteImageBufferMessageHandlerProxy::flushDisplayListAndWaitCommit(displayList);
    109109    }
    110110   
     
    114114        auto& displayList = m_drawingContext.displayList();
    115115        if (displayList.itemCount() >= DisplayListBatchSize)
    116             RemoteImageBufferMessageHandlerProxy::flushDrawingContext(displayList);
     116            RemoteImageBufferMessageHandlerProxy::flushDisplayList(displayList);
    117117    }
    118118};
  • trunk/Source/WebKit/WebProcess/GPU/graphics/RemoteRenderingBackendProxy.cpp

    r268612 r268637  
    7575}
    7676
    77 bool RemoteRenderingBackendProxy::waitForCreateImageBufferBackend()
     77bool RemoteRenderingBackendProxy::waitForImageBufferBackendWasCreated()
    7878{
    7979    Ref<IPC::Connection> connection = WebProcess::singleton().ensureGPUProcessConnection().connection();
    80     return connection->waitForAndDispatchImmediately<Messages::RemoteRenderingBackendProxy::CreateImageBufferBackend>(m_renderingBackendIdentifier, 1_s, IPC::WaitForOption::InterruptWaitingIfSyncMessageArrives);
     80    return connection->waitForAndDispatchImmediately<Messages::RemoteRenderingBackendProxy::ImageBufferBackendWasCreated>(m_renderingBackendIdentifier, 1_s, IPC::WaitForOption::InterruptWaitingIfSyncMessageArrives);
    8181}
    8282
    83 bool RemoteRenderingBackendProxy::waitForCommitImageBufferFlushContext()
     83bool RemoteRenderingBackendProxy::waitForFlushDisplayListWasCommitted()
    8484{
    8585    Ref<IPC::Connection> connection = WebProcess::singleton().ensureGPUProcessConnection().connection();
    86     return connection->waitForAndDispatchImmediately<Messages::RemoteRenderingBackendProxy::CommitImageBufferFlushContext>(m_renderingBackendIdentifier, 1_s, IPC::WaitForOption::InterruptWaitingIfSyncMessageArrives);
     86    return connection->waitForAndDispatchImmediately<Messages::RemoteRenderingBackendProxy::FlushDisplayListWasCommitted>(m_renderingBackendIdentifier, 1_s, IPC::WaitForOption::InterruptWaitingIfSyncMessageArrives);
    8787}
    8888
     
    111111}
    112112
    113 void RemoteRenderingBackendProxy::createImageBufferBackend(const FloatSize& logicalSize, const IntSize& backendSize, float resolutionScale, ColorSpace colorSpace, ImageBufferBackendHandle handle, RemoteResourceIdentifier remoteResourceIdentifier)
     113void RemoteRenderingBackendProxy::imageBufferBackendWasCreated(const FloatSize& logicalSize, const IntSize& backendSize, float resolutionScale, ColorSpace colorSpace, ImageBufferBackendHandle handle, RemoteResourceIdentifier remoteResourceIdentifier)
    114114{
    115115    if (auto imageBuffer = m_imageBufferMessageHandlerMap.get(remoteResourceIdentifier))
     
    117117}
    118118
    119 void RemoteRenderingBackendProxy::commitImageBufferFlushContext(ImageBufferFlushIdentifier flushIdentifier, RemoteResourceIdentifier remoteResourceIdentifier)
     119void RemoteRenderingBackendProxy::flushDisplayListWasCommitted(DisplayListFlushIdentifier flushIdentifier, RemoteResourceIdentifier remoteResourceIdentifier)
    120120{
    121121    if (auto imageBuffer = m_imageBufferMessageHandlerMap.get(remoteResourceIdentifier))
  • trunk/Source/WebKit/WebProcess/GPU/graphics/RemoteRenderingBackendProxy.h

    r268612 r268637  
    2828#if ENABLE(GPU_PROCESS)
    2929
     30#include "DisplayListFlushIdentifier.h"
    3031#include "ImageBufferBackendHandle.h"
    31 #include "ImageBufferFlushIdentifier.h"
    3232#include "MessageReceiver.h"
    3333#include "MessageSender.h"
     
    6565    void releaseRemoteResource(WebCore::RemoteResourceIdentifier);
    6666
    67     bool waitForCreateImageBufferBackend();
    68     bool waitForCommitImageBufferFlushContext();
     67    bool waitForImageBufferBackendWasCreated();
     68    bool waitForFlushDisplayListWasCommitted();
    6969
    7070private:
     
    7272
    7373    // Messages to be received.
    74     void createImageBufferBackend(const WebCore::FloatSize& logicalSize, const WebCore::IntSize& backendSize, float resolutionScale, WebCore::ColorSpace, ImageBufferBackendHandle, WebCore::RemoteResourceIdentifier);
    75     void commitImageBufferFlushContext(ImageBufferFlushIdentifier, WebCore::RemoteResourceIdentifier);
     74    void imageBufferBackendWasCreated(const WebCore::FloatSize& logicalSize, const WebCore::IntSize& backendSize, float resolutionScale, WebCore::ColorSpace, ImageBufferBackendHandle, WebCore::RemoteResourceIdentifier);
     75    void flushDisplayListWasCommitted(DisplayListFlushIdentifier, WebCore::RemoteResourceIdentifier);
    7676
    7777    using ImageBufferMessageHandlerMap = HashMap<WebCore::RemoteResourceIdentifier, RemoteImageBufferMessageHandlerProxy*>;
  • trunk/Source/WebKit/WebProcess/GPU/graphics/RemoteRenderingBackendProxy.messages.in

    r268612 r268637  
    2424
    2525messages -> RemoteRenderingBackendProxy NotRefCounted {
    26     void CreateImageBufferBackend(WebCore::FloatSize logicalSize, WebCore::IntSize backendSize, float resolutionScale, WebCore::ColorSpace colorSpace, WebKit::ImageBufferBackendHandle handle, WebCore::RemoteResourceIdentifier remoteResourceIdentifier)
    27     void CommitImageBufferFlushContext(WebKit::ImageBufferFlushIdentifier flushIdentifier, WebCore::RemoteResourceIdentifier remoteResourceIdentifier)
     26    void ImageBufferBackendWasCreated(WebCore::FloatSize logicalSize, WebCore::IntSize backendSize, float resolutionScale, WebCore::ColorSpace colorSpace, WebKit::ImageBufferBackendHandle handle, WebCore::RemoteResourceIdentifier remoteResourceIdentifier)
     27    void FlushDisplayListWasCommitted(WebKit::DisplayListFlushIdentifier flushIdentifier, WebCore::RemoteResourceIdentifier remoteResourceIdentifier)
    2828}
    2929
Note: See TracChangeset for help on using the changeset viewer.