⚠ Archived content — this site is no longer maintained.   Current WebKit documentation is at docs.webkit.org.

Changeset 269824 in webkit


Ignore:
Timestamp:
Nov 15, 2020, 1:30:54 AM (6 years ago)
Author:
timothy_horton@apple.com
Message:

Initial implementation of DOM rendering via the GPU process
​https://bugs.webkit.org/show_bug.cgi?id=218928

Reviewed by Simon Fraser.

Source/WebCore:

No new tests; will be covered by all existing DOM rendering tests in GPU process mode.

  • WebCore.xcodeproj/project.pbxproj:
  • platform/graphics/ConcreteImageBuffer.h:
  • platform/graphics/ImageBuffer.h:
  • platform/graphics/ImageBufferBackend.h:

(WebCore::ImageBufferBackend::isInUse const):
(WebCore::ImageBufferBackend::releaseGraphicsContext):
(WebCore::ImageBufferBackend::setVolatile):
(WebCore::ImageBufferBackend::releaseBufferToPool):
(WebCore::ImageBufferBackend::createFlusher):

  • platform/graphics/cg/IOSurfacePool.cpp:

(WebCore::IOSurfacePool::takeSurface):
(WebCore::IOSurfacePool::markOlderSurfacesPurgeable):

  • platform/graphics/cg/ImageBufferCGBackend.cpp:

(WebCore::ThreadSafeImageBufferFlusherCG::ThreadSafeImageBufferFlusherCG):
(WebCore::ImageBufferCGBackend::contextColorSpace):
(WebCore::ImageBufferCGBackend::setupContext const):
(WebCore::ImageBufferCGBackend::createFlusher):
(WebCore::ImageBufferCGBackend::setupContext): Deleted.

  • platform/graphics/cg/ImageBufferCGBackend.h:
  • platform/graphics/cg/ImageBufferIOSurfaceBackend.cpp:

(WebCore::ImageBufferIOSurfaceBackend::context const):
(WebCore::ImageBufferIOSurfaceBackend::isInUse const):
(WebCore::ImageBufferIOSurfaceBackend::releaseGraphicsContext):
(WebCore::ImageBufferIOSurfaceBackend::setVolatile):
(WebCore::ImageBufferIOSurfaceBackend::releaseBufferToPool):

  • platform/graphics/cg/ImageBufferIOSurfaceBackend.h:

Add isInUse, setVolatile, and releaseGraphicsContext to ImageBuffer,
to manage volatile surfaces; they're only implemented for in-process
IOSurface right now, in order to keep RemoteLayerBackingStore working
after transitioning it to ImageBuffer. A future patch will determine
how to implement this mechanism for remote IOSurfaces.

Add createFlusher to ImageBuffer, which returns an object that can
be tossed to a background queue, and has one method: flush(), which
blocks until the ImageBuffer's oustanding painting is flushed. This is
currently implemented for CG just by calling CGContextFlush. This
is used to abstract out RemoteLayerBackingStore's background-thread
flush of all surfaces.

  • platform/graphics/cocoa/IOSurface.h:
  • platform/graphics/cocoa/IOSurface.mm:

(WebCore::IOSurface::state const):
(WebCore::IOSurface::setVolatile):
(WebCore::operator<<):
(WebCore::IOSurface::setIsVolatile): Deleted.
Make use of VolatilityState instead of SurfaceState.

Source/WebKit:

  • Shared/RemoteLayerTree/RemoteLayerBackingStore.h:

(WebKit::RemoteLayerBackingStore::hasFrontBuffer const):
(WebKit::RemoteLayerBackingStore::Buffer::operator bool const):

  • Shared/RemoteLayerTree/RemoteLayerBackingStore.mm:

(WebKit::RemoteLayerBackingStore::encode const):
(WebKit::RemoteLayerBackingStore::decode):
(WebKit::RemoteLayerBackingStore::pixelFormat const):
(WebKit::RemoteLayerBackingStore::bytesPerPixel const):
(WebKit::RemoteLayerBackingStore::swapToValidFrontBuffer):
(WebKit::RemoteLayerBackingStore::display):
(WebKit::RemoteLayerBackingStore::applyBackingStoreToLayer):
(WebKit::RemoteLayerBackingStore::takePendingFlusher):
(WebKit::RemoteLayerBackingStore::setBufferVolatility):
(WebKit::RemoteLayerBackingStore::Buffer::discard):
(WebKit::RemoteLayerBackingStore::drawInContext): Deleted.
(WebKit::RemoteLayerBackingStore::takeFrontContextPendingFlush): Deleted.
(WebKit::RemoteLayerBackingStore::surfaceBufferFormat const): Deleted.
Reimplement RemoteLayerBackingStore in terms of ImageBuffer instead of
using ShareableBitmap + IOSurface explicitly.
We use ConcreteImageBuffer versions of the shareable backends in the WebContent process
in the non-GPU-process case, and normal DisplayList-backed RemoteImageBufferProxies
in the GPU process case.

  • UIProcess/ViewSnapshotStore.h:
  • UIProcess/mac/ViewSnapshotStoreMac.mm:

(WebKit::ViewSnapshot::setVolatile):
(WebKit::ViewSnapshot::asLayerContents):

  • WebProcess/GPU/graphics/ImageBufferBackendHandle.h:
  • WebProcess/GPU/graphics/RemoteImageBufferProxy.h:

(WebKit::ThreadSafeRemoteImageBufferFlusher::ThreadSafeRemoteImageBufferFlusher):
Add a hack to emulate ThreadSafeRemoteImageBufferFlusher; right now,
we'll synchronously flush on the main thread when creating the flusher;
a future patch will move this into the flush() method so that RemoteLayerBackingStore
can do it on a secondary queue.

(WebKit::RemoteImageBufferProxy::createImageBufferBackendHandle):

  • WebProcess/WebCoreSupport/WebChromeClient.cpp:

(WebKit::WebChromeClient::createImageBuffer const):
(WebKit::WebChromeClient::ensureRemoteRenderingBackendProxy const): Deleted.

  • WebProcess/WebCoreSupport/WebChromeClient.h:
  • WebProcess/WebPage/RemoteLayerTree/RemoteLayerTreeContext.h:
  • WebProcess/WebPage/RemoteLayerTree/RemoteLayerTreeContext.mm:

(WebKit::RemoteLayerTreeContext::ensureRemoteRenderingBackendProxy):

  • WebProcess/WebPage/RemoteLayerTree/RemoteLayerTreeDrawingArea.h:
  • WebProcess/WebPage/RemoteLayerTree/RemoteLayerTreeDrawingArea.mm:

(WebKit::RemoteLayerTreeDrawingArea::updateRendering):
(WebKit::RemoteLayerTreeDrawingArea::BackingStoreFlusher::create):
(WebKit::RemoteLayerTreeDrawingArea::BackingStoreFlusher::BackingStoreFlusher):
(WebKit::RemoteLayerTreeDrawingArea::BackingStoreFlusher::flush):
Reimplement BackingStoreFlusher in terms of the abstract ThreadSafeImageBufferFlusher.

  • WebProcess/WebPage/WebPage.cpp:

(WebKit::WebPage::ensureRemoteRenderingBackendProxy):

  • WebProcess/WebPage/WebPage.h:

Move RemoteRenderingBackendProxy from WebChromeClient to WebPage, so that
other non-WebCore clients can use it without having to think about WebChromeClient.

Location:
trunk/Source
Files:
27 edited

Legend:

Unmodified
Added
Removed

  • trunk/Source/WebCore/ChangeLog

    r269823 r269824  
     12020-11-15  Tim Horton  <timothy_horton@apple.com>
     2
     3        Initial implementation of DOM rendering via the GPU process
     4        https://bugs.webkit.org/show_bug.cgi?id=218928
     5
     6        Reviewed by Simon Fraser.
     7
     8        No new tests; will be covered by all existing DOM rendering tests in GPU process mode.
     9
     10        * WebCore.xcodeproj/project.pbxproj:
     11        * platform/graphics/ConcreteImageBuffer.h:
     12        * platform/graphics/ImageBuffer.h:
     13        * platform/graphics/ImageBufferBackend.h:
     14        (WebCore::ImageBufferBackend::isInUse const):
     15        (WebCore::ImageBufferBackend::releaseGraphicsContext):
     16        (WebCore::ImageBufferBackend::setVolatile):
     17        (WebCore::ImageBufferBackend::releaseBufferToPool):
     18        (WebCore::ImageBufferBackend::createFlusher):
     19        * platform/graphics/cg/IOSurfacePool.cpp:
     20        (WebCore::IOSurfacePool::takeSurface):
     21        (WebCore::IOSurfacePool::markOlderSurfacesPurgeable):
     22        * platform/graphics/cg/ImageBufferCGBackend.cpp:
     23        (WebCore::ThreadSafeImageBufferFlusherCG::ThreadSafeImageBufferFlusherCG):
     24        (WebCore::ImageBufferCGBackend::contextColorSpace):
     25        (WebCore::ImageBufferCGBackend::setupContext const):
     26        (WebCore::ImageBufferCGBackend::createFlusher):
     27        (WebCore::ImageBufferCGBackend::setupContext): Deleted.
     28        * platform/graphics/cg/ImageBufferCGBackend.h:
     29        * platform/graphics/cg/ImageBufferIOSurfaceBackend.cpp:
     30        (WebCore::ImageBufferIOSurfaceBackend::context const):
     31        (WebCore::ImageBufferIOSurfaceBackend::isInUse const):
     32        (WebCore::ImageBufferIOSurfaceBackend::releaseGraphicsContext):
     33        (WebCore::ImageBufferIOSurfaceBackend::setVolatile):
     34        (WebCore::ImageBufferIOSurfaceBackend::releaseBufferToPool):
     35        * platform/graphics/cg/ImageBufferIOSurfaceBackend.h:
     36        Add isInUse, setVolatile, and releaseGraphicsContext to ImageBuffer,
     37        to manage volatile surfaces; they're only implemented for in-process
     38        IOSurface right now, in order to keep RemoteLayerBackingStore working
     39        after transitioning it to ImageBuffer. A future patch will determine
     40        how to implement this mechanism for remote IOSurfaces.
     41
     42        Add createFlusher to ImageBuffer, which returns an object that can
     43        be tossed to a background queue, and has one method: flush(), which
     44        blocks until the ImageBuffer's oustanding painting is flushed. This is
     45        currently implemented for CG just by calling CGContextFlush. This
     46        is used to abstract out RemoteLayerBackingStore's background-thread
     47        flush of all surfaces.
     48
     49        * platform/graphics/cocoa/IOSurface.h:
     50        * platform/graphics/cocoa/IOSurface.mm:
     51        (WebCore::IOSurface::state const):
     52        (WebCore::IOSurface::setVolatile):
     53        (WebCore::operator<<):
     54        (WebCore::IOSurface::setIsVolatile): Deleted.
     55        Make use of VolatilityState instead of SurfaceState.
     56
     57
    1582020-11-15  Julian Gonzalez  <julian_a_gonzalez@apple.com>
    259

  • trunk/Source/WebCore/WebCore.xcodeproj/project.pbxproj

    r269812 r269824  
    754754                2D70BA1318074DDF0001908A /* PlatformCALayerCocoa.h in Headers */ = {isa = PBXBuildFile; fileRef = 2D70BA1218074DDF0001908A /* PlatformCALayerCocoa.h */; settings = {ATTRIBUTES = (Private, ); }; };
    755755                2D76BB821945632400CFD29A /* RunLoopObserver.h in Headers */ = {isa = PBXBuildFile; fileRef = 2D76BB801945632400CFD29A /* RunLoopObserver.h */; settings = {ATTRIBUTES = (Private, ); }; };
     756                2D7705C7255276CD001D0C94 /* PlatformImageBuffer.h in Headers */ = {isa = PBXBuildFile; fileRef = 72BAC3A623E17328008D741C /* PlatformImageBuffer.h */; settings = {ATTRIBUTES = (Private, ); }; };
     757                2D7705C925528D34001D0C94 /* ImageBufferCGBitmapBackend.h in Headers */ = {isa = PBXBuildFile; fileRef = 72BAC3AA23E1E544008D741C /* ImageBufferCGBitmapBackend.h */; settings = {ATTRIBUTES = (Private, ); }; };
    756758                2D7DA0F22435EB1900F048D1 /* WebViewVisualIdentificationOverlay.h in Headers */ = {isa = PBXBuildFile; fileRef = 2D7DA0EF2435EB1700F048D1 /* WebViewVisualIdentificationOverlay.h */; settings = {ATTRIBUTES = (Private, ); }; };
    757759                2D7ED0AB1BAE99170043B3E5 /* TimerEventBasedMock.h in Headers */ = {isa = PBXBuildFile; fileRef = 2D7ED0A91BAE99170043B3E5 /* TimerEventBasedMock.h */; };
    … …  
    3218232184                                72BAC3AE23E1F0B0008D741C /* ImageBufferBackend.h in Headers */,
    3218332185                                550640B02407587E00AAE045 /* ImageBufferCGBackend.h in Headers */,
     32186                                2D7705C925528D34001D0C94 /* ImageBufferCGBitmapBackend.h in Headers */,
    3218432187                                727A7F3A24078B84004D2931 /* ImageBufferIOSurfaceBackend.h in Headers */,
    3218532188                                B2A10D910B3818BD00099AA4 /* ImageBufferPipe.h in Headers */,
    … …  
    3371533718                                515BE1951D54F5FB00DD7C68 /* PlatformGamepad.h in Headers */,
    3371633719                                726D56E2253AE28D0002EF90 /* PlatformImage.h in Headers */,
     33720                                2D7705C7255276CD001D0C94 /* PlatformImageBuffer.h in Headers */,
    3371733721                                550640AF2407582D00AAE045 /* PlatformImageBufferBackend.h in Headers */,
    3371833722                                935C476809AC4D4300A6AAB4 /* PlatformKeyboardEvent.h in Headers */,

  • trunk/Source/WebCore/platform/graphics/ConcreteImageBuffer.h

    r269724 r269824  
    259259    }
    260260
     261    bool isInUse() const override
     262    {
     263        if (auto* backend = ensureBackendCreated())
     264            return backend->isInUse();
     265        return false;
     266    }
     267
     268    void releaseGraphicsContext() override
     269    {
     270        if (auto* backend = ensureBackendCreated())
     271            return backend->releaseGraphicsContext();
     272    }
     273
     274    VolatilityState setVolatile(bool isVolatile) override
     275    {
     276        if (auto* backend = ensureBackendCreated())
     277            return backend->setVolatile(isVolatile);
     278        return VolatilityState::Valid;
     279    }
     280
     281    std::unique_ptr<ThreadSafeImageBufferFlusher> createFlusher() override
     282    {
     283        if (auto* backend = ensureBackendCreated())
     284            return backend->createFlusher();
     285        return nullptr;
     286    }
     287
     288    void releaseBufferToPool() override
     289    {
     290        if (auto* backend = ensureBackendCreated())
     291            backend->releaseBufferToPool();
     292    }
     293
    261294    std::unique_ptr<BackendType> m_backend;
    262295    RenderingResourceIdentifier m_renderingResourceIdentifier;

  • trunk/Source/WebCore/platform/graphics/ImageBuffer.h

    r269724 r269824  
    8484    virtual size_t externalMemoryCost() const = 0;
    8585
     86    virtual bool isInUse() const = 0;
     87    virtual void releaseGraphicsContext() = 0;
     88    virtual VolatilityState setVolatile(bool) = 0;
     89    virtual void releaseBufferToPool() = 0;
     90
     91    virtual std::unique_ptr<ThreadSafeImageBufferFlusher> createFlusher() = 0;
     92
    8693    virtual RefPtr<NativeImage> copyNativeImage(BackingStoreCopy = CopyBackingStore) const = 0;
    8794    virtual RefPtr<Image> copyImage(BackingStoreCopy = CopyBackingStore, PreserveResolution = PreserveResolution::No) const = 0;

  • trunk/Source/WebCore/platform/graphics/ImageBufferBackend.h

    r269724 r269824  
    6262};
    6363
     64enum class VolatilityState : uint8_t {
     65    Valid,
     66    Empty
     67};
     68
     69class ThreadSafeImageBufferFlusher {
     70    WTF_MAKE_FAST_ALLOCATED;
     71    WTF_MAKE_NONCOPYABLE(ThreadSafeImageBufferFlusher);
     72public:
     73    ThreadSafeImageBufferFlusher() = default;
     74    virtual ~ThreadSafeImageBufferFlusher() = default;
     75    virtual void flush() = 0;
     76};
     77
    6478class ImageBufferBackend {
    6579public:
    … …  
    105119    virtual PlatformLayer* platformLayer() const { return nullptr; }
    106120    virtual bool copyToPlatformTexture(GraphicsContextGLOpenGL&, GCGLenum, PlatformGLObject, GCGLenum, bool, bool) const { return false; }
     121
     122    virtual bool isInUse() const { return false; }
     123    virtual void releaseGraphicsContext() { ASSERT_NOT_REACHED(); }
     124    virtual VolatilityState setVolatile(bool) { return VolatilityState::Valid; }
     125    virtual void releaseBufferToPool() { }
     126
     127    virtual std::unique_ptr<ThreadSafeImageBufferFlusher> createFlusher() { return nullptr; }
    107128   
    108129    static constexpr bool isOriginAtUpperLeftCorner = false;

  • trunk/Source/WebCore/platform/graphics/cg/IOSurfacePool.cpp

    r228853 r269824  
    132132        didRemoveSurface(*surface, false);
    133133
    134         surface->setIsVolatile(false);
     134        surface->setVolatile(false);
    135135
    136136        DUMP_POOL_STATISTICS("takeSurface - taking");
    … …  
    149149        didRemoveSurface(*surface, true);
    150150
    151         surface->setIsVolatile(false);
     151        surface->setVolatile(false);
    152152
    153153        DUMP_POOL_STATISTICS("takeSurface - taking in-use");
    … …  
    299299        }
    300300
    301         surfaceAndDetails.key->setIsVolatile(true);
     301        surfaceAndDetails.key->setVolatile(true);
    302302        surfaceAndDetails.value.hasMarkedPurgeable = true;
    303303    }

  • trunk/Source/WebCore/platform/graphics/cg/ImageBufferCGBackend.cpp

    r269724 r269824  
    4444namespace WebCore {
    4545
     46class ThreadSafeImageBufferFlusherCG : public ThreadSafeImageBufferFlusher {
     47    WTF_MAKE_FAST_ALLOCATED;
     48public:
     49    ThreadSafeImageBufferFlusherCG(CGContextRef context)
     50        : m_context(context)
     51    {
     52    }
     53
     54    void flush() override
     55    {
     56        CGContextFlush(m_context.get());
     57    }
     58
     59private:
     60    RetainPtr<CGContextRef> m_context;
     61};
     62
    4663RetainPtr<CGColorSpaceRef> ImageBufferCGBackend::contextColorSpace(const GraphicsContext& context)
    4764{
    … …  
    5875#endif
    5976}
    60 #
    61 
    62 void ImageBufferCGBackend::setupContext()
     77
     78void ImageBufferCGBackend::setupContext() const
    6379{
    6480    // The initial CTM matches DisplayList::Recorder::clipToDrawingCommands()'s initial CTM.
    … …  
    208224}
    209225
     226std::unique_ptr<ThreadSafeImageBufferFlusher> ImageBufferCGBackend::createFlusher()
     227{
     228    return WTF::makeUnique<ThreadSafeImageBufferFlusherCG>(context().platformContext());
     229}
     230
    210231#if USE(ACCELERATE)
    211232static inline vImage_Buffer makeVImageBuffer(unsigned bytesPerRow, uint8_t* rows, const IntSize& size)

  • trunk/Source/WebCore/platform/graphics/cg/ImageBufferCGBackend.h

    r269724 r269824  
    4747    Vector<uint8_t> toData(const String& mimeType, Optional<double> quality) const override;
    4848
     49    std::unique_ptr<ThreadSafeImageBufferFlusher> createFlusher() override;
     50
    4951protected:
    5052    using ImageBufferBackend::ImageBufferBackend;
    5153
    5254    static RetainPtr<CGColorSpaceRef> contextColorSpace(const GraphicsContext&);
    53     void setupContext();
     55    void setupContext() const;
    5456    virtual RetainPtr<CFDataRef> toCFData(const String& mimeType, Optional<double> quality, PreserveResolution) const;
    5557

  • trunk/Source/WebCore/platform/graphics/cg/ImageBufferIOSurfaceBackend.cpp

    r269710 r269824  
    107107GraphicsContext& ImageBufferIOSurfaceBackend::context() const
    108108{
    109     return m_surface->ensureGraphicsContext();
     109
     110    GraphicsContext& context = m_surface->ensureGraphicsContext();
     111    if (m_needsSetupContext) {
     112        m_needsSetupContext = false;
     113        setupContext();
     114    }
     115    return context;
    110116}
    111117
    … …  
    185191}
    186192
     193bool ImageBufferIOSurfaceBackend::isInUse() const
     194{
     195    return m_surface->isInUse();
     196}
     197
     198void ImageBufferIOSurfaceBackend::releaseGraphicsContext()
     199{
     200    m_needsSetupContext = true;
     201    return m_surface->releaseGraphicsContext();
     202}
     203
     204VolatilityState ImageBufferIOSurfaceBackend::setVolatile(bool isVolatile)
     205{
     206    return m_surface->setVolatile(isVolatile);
     207}
     208
     209void ImageBufferIOSurfaceBackend::releaseBufferToPool()
     210{
     211    IOSurface::moveToPool(WTFMove(m_surface));
     212}
     213
    187214} // namespace WebCore
    188215

  • trunk/Source/WebCore/platform/graphics/cg/ImageBufferIOSurfaceBackend.h

    r269710 r269824  
    6464    IOSurface* surface();
    6565
     66    bool isInUse() const override;
     67    void releaseGraphicsContext() override;
     68    VolatilityState setVolatile(bool) override;
     69    void releaseBufferToPool() override;
     70
    6671    static constexpr bool isOriginAtUpperLeftCorner = true;
    6772    static constexpr bool isAccelerated = true;
    … …  
    7378    std::unique_ptr<IOSurface> m_surface;
    7479    mutable bool m_requiresDrawAfterPutImageData { false };
     80
     81    mutable bool m_needsSetupContext { false };
    7582};
    7683

  • trunk/Source/WebCore/platform/graphics/cocoa/IOSurface.h

    r269710 r269824  
    5151
    5252enum class PixelFormat : uint8_t;
     53enum class VolatilityState : uint8_t;
    5354
    5455class IOSurface final {
    … …  
    129130    WEBCORE_EXPORT CGContextRef ensurePlatformContext(const HostWindow* = nullptr);
    130131
    131     enum class SurfaceState {
    132         Valid,
    133         Empty
    134     };
    135 
    136132    // Querying volatility can be expensive, so in cases where the surface is
    137     // going to be used immediately, use the return value of setIsVolatile to
     133    // going to be used immediately, use the return value of setVolatile to
    138134    // determine whether the data was purged, instead of first calling state() or isVolatile().
    139     SurfaceState state() const;
     135    VolatilityState state() const;
    140136    bool isVolatile() const;
    141137
    142     // setIsVolatile only has an effect on iOS and OS 10.9 and above.
    143     WEBCORE_EXPORT SurfaceState setIsVolatile(bool);
     138    WEBCORE_EXPORT VolatilityState setVolatile(bool);
    144139
    145140    IntSize size() const { return m_size; }

  • trunk/Source/WebCore/platform/graphics/cocoa/IOSurface.mm

    r269710 r269824  
    325325}
    326326
    327 IOSurface::SurfaceState IOSurface::state() const
     327VolatilityState IOSurface::state() const
    328328{
    329329    uint32_t previousState = 0;
    330330    IOReturn ret = IOSurfaceSetPurgeable(m_surface.get(), kIOSurfacePurgeableKeepCurrent, &previousState);
    331331    ASSERT_UNUSED(ret, ret == kIOReturnSuccess);
    332     return previousState == kIOSurfacePurgeableEmpty ? IOSurface::SurfaceState::Empty : IOSurface::SurfaceState::Valid;
     332    return previousState == kIOSurfacePurgeableEmpty ? VolatilityState::Empty : VolatilityState::Valid;
    333333}
    334334
    … …  
    341341}
    342342
    343 IOSurface::SurfaceState IOSurface::setIsVolatile(bool isVolatile)
     343VolatilityState IOSurface::setVolatile(bool isVolatile)
    344344{
    345345    uint32_t previousState = 0;
    … …  
    348348
    349349    if (previousState == kIOSurfacePurgeableEmpty)
    350         return IOSurface::SurfaceState::Empty;
    351 
    352     return IOSurface::SurfaceState::Valid;
     350        return VolatilityState::Empty;
     351
     352    return VolatilityState::Valid;
    353353}
    354354
    … …  
    506506}
    507507
    508 static TextStream& operator<<(TextStream& ts, IOSurface::SurfaceState state)
     508static TextStream& operator<<(TextStream& ts, VolatilityState state)
    509509{
    510510    switch (state) {
    511     case IOSurface::SurfaceState::Valid:
     511    case VolatilityState::Valid:
    512512        ts << "valid";
    513513        break;
    514     case IOSurface::SurfaceState::Empty:
     514    case VolatilityState::Empty:
    515515        ts << "empty";
    516516        break;

  • trunk/Source/WebKit/ChangeLog

    r269815 r269824  
     12020-11-15  Tim Horton  <timothy_horton@apple.com>
     2
     3        Initial implementation of DOM rendering via the GPU process
     4        https://bugs.webkit.org/show_bug.cgi?id=218928
     5
     6        Reviewed by Simon Fraser.
     7
     8        * Shared/RemoteLayerTree/RemoteLayerBackingStore.h:
     9        (WebKit::RemoteLayerBackingStore::hasFrontBuffer const):
     10        (WebKit::RemoteLayerBackingStore::Buffer::operator bool const):
     11        * Shared/RemoteLayerTree/RemoteLayerBackingStore.mm:
     12        (WebKit::RemoteLayerBackingStore::encode const):
     13        (WebKit::RemoteLayerBackingStore::decode):
     14        (WebKit::RemoteLayerBackingStore::pixelFormat const):
     15        (WebKit::RemoteLayerBackingStore::bytesPerPixel const):
     16        (WebKit::RemoteLayerBackingStore::swapToValidFrontBuffer):
     17        (WebKit::RemoteLayerBackingStore::display):
     18        (WebKit::RemoteLayerBackingStore::applyBackingStoreToLayer):
     19        (WebKit::RemoteLayerBackingStore::takePendingFlusher):
     20        (WebKit::RemoteLayerBackingStore::setBufferVolatility):
     21        (WebKit::RemoteLayerBackingStore::Buffer::discard):
     22        (WebKit::RemoteLayerBackingStore::drawInContext): Deleted.
     23        (WebKit::RemoteLayerBackingStore::takeFrontContextPendingFlush): Deleted.
     24        (WebKit::RemoteLayerBackingStore::surfaceBufferFormat const): Deleted.
     25        Reimplement RemoteLayerBackingStore in terms of ImageBuffer instead of
     26        using ShareableBitmap + IOSurface explicitly.
     27        We use ConcreteImageBuffer versions of the shareable backends in the WebContent process
     28        in the non-GPU-process case, and normal DisplayList-backed RemoteImageBufferProxies
     29        in the GPU process case.
     30
     31        * UIProcess/ViewSnapshotStore.h:
     32        * UIProcess/mac/ViewSnapshotStoreMac.mm:
     33        (WebKit::ViewSnapshot::setVolatile):
     34        (WebKit::ViewSnapshot::asLayerContents):
     35        * WebProcess/GPU/graphics/ImageBufferBackendHandle.h:
     36        * WebProcess/GPU/graphics/RemoteImageBufferProxy.h:
     37        (WebKit::ThreadSafeRemoteImageBufferFlusher::ThreadSafeRemoteImageBufferFlusher):
     38        Add a hack to emulate ThreadSafeRemoteImageBufferFlusher; right now,
     39        we'll synchronously flush on the main thread when creating the flusher;
     40        a future patch will move this into the flush() method so that RemoteLayerBackingStore
     41        can do it on a secondary queue.
     42
     43        (WebKit::RemoteImageBufferProxy::createImageBufferBackendHandle):
     44        * WebProcess/WebCoreSupport/WebChromeClient.cpp:
     45        (WebKit::WebChromeClient::createImageBuffer const):
     46        (WebKit::WebChromeClient::ensureRemoteRenderingBackendProxy const): Deleted.
     47        * WebProcess/WebCoreSupport/WebChromeClient.h:
     48        * WebProcess/WebPage/RemoteLayerTree/RemoteLayerTreeContext.h:
     49        * WebProcess/WebPage/RemoteLayerTree/RemoteLayerTreeContext.mm:
     50        (WebKit::RemoteLayerTreeContext::ensureRemoteRenderingBackendProxy):
     51        * WebProcess/WebPage/RemoteLayerTree/RemoteLayerTreeDrawingArea.h:
     52        * WebProcess/WebPage/RemoteLayerTree/RemoteLayerTreeDrawingArea.mm:
     53        (WebKit::RemoteLayerTreeDrawingArea::updateRendering):
     54        (WebKit::RemoteLayerTreeDrawingArea::BackingStoreFlusher::create):
     55        (WebKit::RemoteLayerTreeDrawingArea::BackingStoreFlusher::BackingStoreFlusher):
     56        (WebKit::RemoteLayerTreeDrawingArea::BackingStoreFlusher::flush):
     57        Reimplement BackingStoreFlusher in terms of the abstract ThreadSafeImageBufferFlusher.
     58
     59        * WebProcess/WebPage/WebPage.cpp:
     60        (WebKit::WebPage::ensureRemoteRenderingBackendProxy):
     61        * WebProcess/WebPage/WebPage.h:
     62        Move RemoteRenderingBackendProxy from WebChromeClient to WebPage, so that
     63        other non-WebCore clients can use it without having to think about WebChromeClient.
     64
    1652020-11-14  Zan Dobersek  <zdobersek@igalia.com>
    266

  • trunk/Source/WebKit/Shared/RemoteLayerTree/RemoteLayerBackingStore.h

    r269664 r269824  
    2626#pragma once
    2727
    28 #include "ShareableBitmap.h"
     28#include "ImageBufferBackendHandle.h"
    2929#include <WebCore/FloatRect.h>
    3030#include <WebCore/IOSurface.h>
    … …  
    3838namespace WebCore {
    3939class NativeImage;
     40class ThreadSafeImageBufferFlusher;
    4041typedef Vector<WebCore::FloatRect, 5> RepaintRectList;
    4142}
    … …  
    7778    bool hasFrontBuffer() const
    7879    {
    79 #if HAVE(IOSURFACE)
    80         if (m_acceleratesDrawing)
    81             return !!m_frontBuffer.surface;
    82 #endif
    83         return !!m_frontBuffer.bitmap;
     80        return !!m_frontBuffer.imageBuffer;
    8481    }
    8582
    86     RetainPtr<CGContextRef> takeFrontContextPendingFlush();
     83    std::unique_ptr<WebCore::ThreadSafeImageBufferFlusher> takePendingFlusher();
    8784
    8885    enum class BufferType {
    … …  
    9895
    9996private:
    100     void drawInContext(WebCore::GraphicsContext&, RefPtr<WebCore::NativeImage>&& backImage);
     97    void drawInContext(WebCore::GraphicsContext&);
    10198    void clearBackingStore();
    10299    void swapToValidFrontBuffer();
    103100
    104 #if HAVE(IOSURFACE)
    105     WebCore::IOSurface::Format surfaceBufferFormat() const;
    106 #endif
    107 
     101    WebCore::PixelFormat pixelFormat() const;
    108102    WebCore::IntSize backingStoreSize() const;
    109103
    … …  
    117111
    118112    struct Buffer {
    119         RefPtr<ShareableBitmap> bitmap;
    120 #if HAVE(IOSURFACE)
    121         std::unique_ptr<WebCore::IOSurface> surface;
     113        RefPtr<WebCore::ImageBuffer> imageBuffer;
    122114        bool isVolatile = false;
    123 #endif
    124115
    125116        explicit operator bool() const
    126117        {
    127 #if HAVE(IOSURFACE)
    128             if (surface)
    129                 return true;
    130 #endif
    131             if (bitmap)
    132                 return true;
    133 
    134             return false;
     118            return !!imageBuffer;
    135119        }
    136120
    … …  
    140124    Buffer m_frontBuffer;
    141125    Buffer m_backBuffer;
    142 #if HAVE(IOSURFACE)
    143126    Buffer m_secondaryBackBuffer;
    144     WTF::MachSendRight m_frontBufferSendRight;
    145 #endif
     127    Optional<ImageBufferBackendHandle> m_bufferHandle;
    146128
    147     RetainPtr<CGContextRef> m_frontContextPendingFlush;
     129    std::unique_ptr<WebCore::ThreadSafeImageBufferFlusher> m_frontBufferFlusher;
    148130
    149131    bool m_acceleratesDrawing { false };

  • trunk/Source/WebKit/Shared/RemoteLayerTree/RemoteLayerBackingStore.mm

    r269710 r269824  
    3030#import "MachPort.h"
    3131#import "PlatformCALayerRemote.h"
     32#import "PlatformRemoteImageBufferProxy.h"
    3233#import "RemoteLayerBackingStoreCollection.h"
    3334#import "RemoteLayerTreeContext.h"
    3435#import "ShareableBitmap.h"
    3536#import "WebCoreArgumentCoders.h"
     37#import "WebProcess.h"
    3638#import <QuartzCore/QuartzCore.h>
    3739#import <WebCore/GraphicsContextCG.h>
    3840#import <WebCore/IOSurface.h>
     41#import <WebCore/ImageBuffer.h>
    3942#import <WebCore/PlatformCALayerClient.h>
    4043#import <WebCore/WebLayer.h>
    … …  
    100103    encoder << m_isOpaque;
    101104
    102     if (m_acceleratesDrawing) {
    103         if (m_frontBuffer.surface)
    104             encoder << m_frontBuffer.surface->createSendRight();
     105    Optional<ImageBufferBackendHandle> handle;
     106    if (m_frontBuffer.imageBuffer) {
     107        // FIXME: We need to flatten the class hierarchy so we can avoid this bifurcation.
     108        if (m_acceleratesDrawing)
     109            handle = static_cast<AcceleratedRemoteImageBufferProxy *>(m_frontBuffer.imageBuffer.get())->createImageBufferBackendHandle();
    105110        else
    106             encoder << WTF::MachSendRight();
    107         return;
    108     }
    109 
    110     ASSERT(!m_acceleratesDrawing);
    111 
    112     ShareableBitmap::Handle handle;
    113     m_frontBuffer.bitmap->createHandle(handle);
     111            handle = static_cast<UnacceleratedRemoteImageBufferProxy *>(m_frontBuffer.imageBuffer.get())->createImageBufferBackendHandle();
     112    }
     113
    114114    encoder << handle;
    115115}
    … …  
    129129        return false;
    130130
    131     if (result.m_acceleratesDrawing) {
    132         MachSendRight sendRight;
    133         if (!decoder.decode(sendRight))
    134             return false;
    135         result.m_frontBufferSendRight = WTFMove(sendRight);
    136         return true;
    137     }
    138 
    139     ASSERT(!result.m_acceleratesDrawing);
    140 
    141     ShareableBitmap::Handle handle;
    142     if (!decoder.decode(handle))
    143         return false;
    144     result.m_frontBuffer.bitmap = ShareableBitmap::create(handle);
     131    if (!decoder.decode(result.m_bufferHandle))
     132        return false;
    145133
    146134    return true;
    … …  
    164152}
    165153
     154WebCore::PixelFormat RemoteLayerBackingStore::pixelFormat() const
     155{
     156#if HAVE(IOSURFACE_RGB10)
     157    if (m_acceleratesDrawing && m_deepColor)
     158        return m_isOpaque ? WebCore::PixelFormat::RGB10 : WebCore::PixelFormat::RGB10A8;
     159#endif
     160
     161    return WebCore::PixelFormat::BGRA8;
     162}
     163
    166164unsigned RemoteLayerBackingStore::bytesPerPixel() const
    167165{
    168     switch (surfaceBufferFormat()) {
    169     case WebCore::IOSurface::Format::BGRA: return 4;
    170     case WebCore::IOSurface::Format::YUV422: return 2;
    171 #if HAVE(IOSURFACE_RGB10)
    172     case WebCore::IOSurface::Format::RGB10: return 4;
    173     case WebCore::IOSurface::Format::RGB10A8: return 5;
    174 #endif
     166    switch (pixelFormat()) {
     167    case WebCore::PixelFormat::RGBA8: return 4;
     168    case WebCore::PixelFormat::BGRA8: return 4;
     169    case WebCore::PixelFormat::RGB10: return 4;
     170    case WebCore::PixelFormat::RGB10A8: return 5;
    175171    }
    176172    return 4;
    … …  
    179175void RemoteLayerBackingStore::swapToValidFrontBuffer()
    180176{
    181     WebCore::IntSize expandedScaledSize = backingStoreSize();
    182 
    183     if (m_acceleratesDrawing) {
    184         if (!m_backBuffer.surface || m_backBuffer.surface->isInUse()) {
    185             std::swap(m_backBuffer, m_secondaryBackBuffer);
    186             if (m_backBuffer.surface && m_backBuffer.surface->isInUse())
    187                 m_backBuffer.discard();
    188         }
    189 
    190         std::swap(m_frontBuffer, m_backBuffer);
    191 
    192         if (!m_frontBuffer.surface)
    193             m_frontBuffer.surface = WebCore::IOSurface::create(expandedScaledSize, WebCore::sRGBColorSpaceRef(), surfaceBufferFormat());
    194 
    195         setBufferVolatility(BufferType::Front, false);
    196         return;
    197     }
    198 
    199     ASSERT(!m_acceleratesDrawing);
    200177    std::swap(m_frontBuffer, m_backBuffer);
    201178
    202     if (!m_frontBuffer.bitmap) {
    203         ShareableBitmap::Configuration bitmapConfiguration;
    204         bitmapConfiguration.isOpaque = m_isOpaque;
    205         m_frontBuffer.bitmap = ShareableBitmap::createShareable(expandedScaledSize, bitmapConfiguration);
    206     }
     179    if (m_frontBuffer.imageBuffer)
     180        return;
     181
     182    if (WebProcess::singleton().shouldUseRemoteRenderingFor(WebCore::RenderingPurpose::DOM)) {
     183        m_frontBuffer.imageBuffer = m_layer->context()->ensureRemoteRenderingBackendProxy().createImageBuffer(backingStoreSize(), m_acceleratesDrawing ? WebCore::RenderingMode::Accelerated : WebCore::RenderingMode::Unaccelerated, 1, WebCore::ColorSpace::SRGB, pixelFormat());
     184        return;
     185    }
     186
     187    if (m_acceleratesDrawing)
     188        m_frontBuffer.imageBuffer = WebCore::ConcreteImageBuffer<AcceleratedImageBufferShareableBackend>::create(backingStoreSize(), 1, WebCore::ColorSpace::SRGB, pixelFormat(), nullptr);
     189    else
     190        m_frontBuffer.imageBuffer = WebCore::ConcreteImageBuffer<UnacceleratedImageBufferShareableBackend>::create(backingStoreSize(), 1, WebCore::ColorSpace::SRGB, pixelFormat(), nullptr);
    207191}
    208192
    209193bool RemoteLayerBackingStore::display()
    210194{
    211     ASSERT(!m_frontContextPendingFlush);
     195    ASSERT(!m_frontBufferFlusher);
    212196
    213197    m_lastDisplayTime = MonotonicTime::now();
    … …  
    235219
    236220    WebCore::IntRect expandedScaledLayerBounds(WebCore::IntPoint(), expandedScaledSize);
    237     bool willPaintEntireBackingStore = m_dirtyRegion.contains(layerBounds);
    238221
    239222    swapToValidFrontBuffer();
    240223
    241     if (m_acceleratesDrawing) {
    242         RefPtr<WebCore::NativeImage> backImage;
    243         if (m_backBuffer.surface && !willPaintEntireBackingStore)
    244             backImage = WebCore::NativeImage::create(m_backBuffer.surface->createImage().get());
    245 
    246         if (m_frontBuffer.surface) {
    247             WebCore::GraphicsContext& context = m_frontBuffer.surface->ensureGraphicsContext();
    248 
    249             context.scale(WebCore::FloatSize(1, -1));
    250             context.translate(0, -expandedScaledSize.height());
    251             drawInContext(context, WTFMove(backImage));
    252 
    253             m_frontBuffer.surface->releaseGraphicsContext();
    254         }
    255     } else {
    256         ASSERT(!m_acceleratesDrawing);
    257         std::unique_ptr<WebCore::GraphicsContext> context = m_frontBuffer.bitmap->createGraphicsContext();
    258 
    259         RefPtr<WebCore::NativeImage> backImage;
    260         if (m_backBuffer.bitmap && !willPaintEntireBackingStore)
    261             backImage = WebCore::NativeImage::create(m_backBuffer.bitmap->makeCGImage().get());
    262 
    263         if (context)
    264             drawInContext(*context, WTFMove(backImage));
    265     }
    266    
    267     m_layer->owner()->platformCALayerLayerDidDisplay(m_layer);
    268    
    269     return true;
    270 }
    271 
    272 void RemoteLayerBackingStore::drawInContext(WebCore::GraphicsContext& context, RefPtr<WebCore::NativeImage>&& backImage)
    273 {
     224    WebCore::GraphicsContext& context = m_frontBuffer.imageBuffer->context();
     225
     226    WebCore::GraphicsContextStateSaver stateSaver(context);
     227
    274228    WebCore::FloatSize scaledSize = m_size;
    275229    scaledSize.scale(m_scale);
    … …  
    296250    }
    297251
    298     if (backImage)
    299         context.drawNativeImage(*backImage, scaledLayerBounds.size(), scaledLayerBounds, scaledLayerBounds, { WebCore::CompositeOperator::Copy });
     252    if (!m_dirtyRegion.contains(layerBounds)) {
     253        ASSERT(m_backBuffer.imageBuffer);
     254        context.drawImageBuffer(*m_backBuffer.imageBuffer, { 0, 0 });
     255    }
    300256
    301257    if (m_paintingRects.size() == 1) {
    … …  
    358314    m_paintingRects.clear();
    359315
    360     m_frontContextPendingFlush = context.platformContext();
     316    m_frontBufferFlusher = m_frontBuffer.imageBuffer->createFlusher();
     317
     318    m_layer->owner()->platformCALayerLayerDidDisplay(m_layer);
     319
     320    // FIXME: This method has a weird name. This is "submit work".
     321    m_frontBuffer.imageBuffer->flushDrawingContextAndCommit();
     322
     323    return true;
    361324}
    362325
    … …  
    378341void RemoteLayerBackingStore::applyBackingStoreToLayer(CALayer *layer, LayerContentsType contentsType)
    379342{
     343    ASSERT(m_bufferHandle);
    380344    layer.contentsOpaque = m_isOpaque;
    381345
    382346    if (acceleratesDrawing()) {
    383347        switch (contentsType) {
    384         case LayerContentsType::IOSurface:
    385             if (!m_frontBuffer.surface) {
    386                 ASSERT(m_frontBufferSendRight);
    387                 m_frontBuffer.surface = WebCore::IOSurface::createFromSendRight(WTFMove(m_frontBufferSendRight), WebCore::sRGBColorSpaceRef());
    388             }
    389             layer.contents = m_frontBuffer.surface ? m_frontBuffer.surface->asLayerContents() : nil;
    390             break;
    391         case LayerContentsType::CAMachPort:
    392             ASSERT(m_frontBufferSendRight);
    393             layer.contents = (__bridge id)adoptCF(CAMachPortCreate(m_frontBufferSendRight.leakSendRight())).get();
     348        case LayerContentsType::IOSurface: {
     349            auto surface = WebCore::IOSurface::createFromSendRight(WTFMove(WTF::get<MachSendRight>(*m_bufferHandle)), WebCore::sRGBColorSpaceRef());
     350            layer.contents = surface ? surface->asLayerContents() : nil;
    394351            break;
    395352        }
     353        case LayerContentsType::CAMachPort:
     354            layer.contents = (__bridge id)adoptCF(CAMachPortCreate(WTF::get<MachSendRight>(*m_bufferHandle).leakSendRight())).get();
     355            break;
     356        }
    396357        return;
    397358    }
    398359
    399360    ASSERT(!acceleratesDrawing());
    400     layer.contents = (__bridge id)m_frontBuffer.bitmap->makeCGImageCopy().get();
    401 }
    402 
    403 RetainPtr<CGContextRef> RemoteLayerBackingStore::takeFrontContextPendingFlush()
    404 {
    405     return WTFMove(m_frontContextPendingFlush);
     361    auto bitmap = ShareableBitmap::create(WTF::get<ShareableBitmap::Handle>(*m_bufferHandle));
     362    layer.contents = (__bridge id)bitmap->makeCGImageCopy().get();
     363}
     364
     365std::unique_ptr<WebCore::ThreadSafeImageBufferFlusher> RemoteLayerBackingStore::takePendingFlusher()
     366{
     367    return std::exchange(m_frontBufferFlusher, nullptr);
    406368}
    407369
    408370bool RemoteLayerBackingStore::setBufferVolatility(BufferType type, bool isVolatile)
    409371{
     372    if (!acceleratesDrawing())
     373        return true;
     374
    410375    // Return value is true if we succeeded in making volatile.
    411376    auto makeVolatile = [] (Buffer& buffer) -> bool {
    412         if (!buffer.surface || buffer.isVolatile)
     377        if (!buffer.imageBuffer || buffer.isVolatile)
    413378            return true;
    414379
    415         buffer.surface->releaseGraphicsContext();
    416 
    417         if (!buffer.surface->isInUse()) {
    418             buffer.surface->setIsVolatile(true);
     380        buffer.imageBuffer->releaseGraphicsContext();
     381
     382        if (!buffer.imageBuffer->isInUse()) {
     383            buffer.imageBuffer->setVolatile(true);
    419384            buffer.isVolatile = true;
    420385            return true;
    … …  
    426391    // Return value is true if we need to repaint.
    427392    auto makeNonVolatile = [] (Buffer& buffer) -> bool {
    428         if (!buffer.surface || !buffer.isVolatile)
     393        if (!buffer.imageBuffer || !buffer.isVolatile)
    429394            return false;
    430395
    431         auto previousState = buffer.surface->setIsVolatile(false);
     396        auto previousState = buffer.imageBuffer->setVolatile(false);
    432397        buffer.isVolatile = false;
    433398
    434         return previousState == WebCore::IOSurface::SurfaceState::Empty;
     399        return previousState == WebCore::VolatilityState::Empty;
    435400    };
    436401
    … …  
    462427void RemoteLayerBackingStore::Buffer::discard()
    463428{
    464     if (surface)
    465         WebCore::IOSurface::moveToPool(WTFMove(surface));
    466429    isVolatile = false;
    467     bitmap = nullptr;
    468 }
    469 
    470 WebCore::IOSurface::Format RemoteLayerBackingStore::surfaceBufferFormat() const
    471 {
    472 #if HAVE(IOSURFACE_RGB10)
    473     if (m_deepColor)
    474         return m_isOpaque ? WebCore::IOSurface::Format::RGB10 : WebCore::IOSurface::Format::RGB10A8;
    475 #endif
    476 
    477     return WebCore::IOSurface::Format::BGRA;
     430    if (imageBuffer)
     431        imageBuffer->releaseBufferToPool();
     432    imageBuffer = nullptr;
    478433}
    479434

  • trunk/Source/WebKit/UIProcess/ViewSnapshotStore.h

    r259575 r269824  
    8484    void setSurface(std::unique_ptr<WebCore::IOSurface>);
    8585
    86     WebCore::IOSurface::SurfaceState setVolatile(bool);
     86    WebCore::VolatilityState setVolatile(bool);
    8787#endif
    8888

  • trunk/Source/WebKit/UIProcess/mac/ViewSnapshotStoreMac.mm

    r259575 r269824  
    2929#import <CoreGraphics/CoreGraphics.h>
    3030#import <WebCore/IOSurface.h>
     31#import <WebCore/ImageBuffer.h>
    3132
    3233#if PLATFORM(IOS_FAMILY)
    … …  
    7576}
    7677
    77 WebCore::IOSurface::SurfaceState ViewSnapshot::setVolatile(bool becomeVolatile)
     78WebCore::VolatilityState ViewSnapshot::setVolatile(bool becomeVolatile)
    7879{
    7980    if (ViewSnapshotStore::singleton().disableSnapshotVolatilityForTesting())
    80         return WebCore::IOSurface::SurfaceState::Valid;
     81        return WebCore::VolatilityState::Valid;
    8182
    8283    if (!m_surface)
    83         return WebCore::IOSurface::SurfaceState::Empty;
     84        return WebCore::VolatilityState::Empty;
    8485
    85     return m_surface->setIsVolatile(becomeVolatile);
     86    return m_surface->setVolatile(becomeVolatile);
    8687}
    8788
    … …  
    9192        return nullptr;
    9293
    93     if (setVolatile(false) != WebCore::IOSurface::SurfaceState::Valid) {
     94    if (setVolatile(false) != WebCore::VolatilityState::Valid) {
    9495        clearImage();
    9596        return nullptr;

  • trunk/Source/WebKit/WebProcess/GPU/graphics/ImageBufferBackendHandle.h

    r257606 r269824  
    3535
    3636using ImageBufferBackendHandle = Variant<
    37 #if PLATFORM(COCOA)
     37#if PLATFORM(COCOA) // FIXME: This is really about IOSurface.
    3838    MachSendRight,
    3939#endif

  • trunk/Source/WebKit/WebProcess/GPU/graphics/RemoteImageBufferProxy.h

    r269809 r269824  
    4141class RemoteRenderingBackend;
    4242
     43class ThreadSafeRemoteImageBufferFlusher : public WebCore::ThreadSafeImageBufferFlusher {
     44    WTF_MAKE_FAST_ALLOCATED;
     45public:
     46    ThreadSafeRemoteImageBufferFlusher(WebCore::ImageBuffer& imageBuffer)
     47    {
     48        // FIXME: We shouldn't synchronously wait on the flush until flush() is called, but have to invent
     49        // a thread-safe way to wait on the incoming message.
     50        imageBuffer.flushDrawingContext();
     51    }
     52
     53    void flush() override
     54    {
     55    }
     56
     57private:
     58};
     59
    4360template<typename BackendType>
    4461class RemoteImageBufferProxy : public WebCore::DisplayList::ImageBuffer<BackendType>, public WebCore::DisplayList::Recorder::Delegate, public WebCore::DisplayList::ItemBufferWritingClient {
    … …  
    84101    WebCore::ColorSpace colorSpace() const { return m_colorSpace; }
    85102    WebCore::PixelFormat pixelFormat() const { return m_pixelFormat; }
     103
     104    ImageBufferBackendHandle createImageBufferBackendHandle()
     105    {
     106        ensureBackendCreated();
     107        return m_backend->createImageBufferBackendHandle();
     108    }
    86109
    87110protected:
    … …  
    313336    }
    314337
     338    std::unique_ptr<WebCore::ThreadSafeImageBufferFlusher> createFlusher() override
     339    {
     340        return WTF::makeUnique<ThreadSafeRemoteImageBufferFlusher>(*this);
     341    }
     342
    315343    WebCore::DisplayList::FlushIdentifier m_sentFlushIdentifier;
    316344    WebCore::DisplayList::FlushIdentifier m_receivedFlushIdentifier;

  • trunk/Source/WebKit/WebProcess/WebCoreSupport/WebChromeClient.cpp

    r269712 r269824  
    904904#if ENABLE(GPU_PROCESS)
    905905
    906 RemoteRenderingBackendProxy& WebChromeClient::ensureRemoteRenderingBackendProxy() const
    907 {
    908     if (!m_remoteRenderingBackendProxy)
    909         m_remoteRenderingBackendProxy = RemoteRenderingBackendProxy::create();
    910     return *m_remoteRenderingBackendProxy;
    911 }
    912906
    913907RefPtr<ImageBuffer> WebChromeClient::createImageBuffer(const FloatSize& size, RenderingMode renderingMode, RenderingPurpose purpose, float resolutionScale, ColorSpace colorSpace, PixelFormat pixelFormat) const
    … …  
    916910        return nullptr;
    917911
    918     return ensureRemoteRenderingBackendProxy().createImageBuffer(size, renderingMode, resolutionScale, colorSpace, pixelFormat);
     912    return m_page.ensureRemoteRenderingBackendProxy().createImageBuffer(size, renderingMode, resolutionScale, colorSpace, pixelFormat);
    919913}
    920914

  • trunk/Source/WebKit/WebProcess/WebCoreSupport/WebChromeClient.h

    r269710 r269824  
    3838namespace WebKit {
    3939
    40 class RemoteRenderingBackendProxy;
    4140class WebFrame;
    4241class WebPage;
    … …  
    244243
    245244#if ENABLE(GPU_PROCESS)
    246     RemoteRenderingBackendProxy& ensureRemoteRenderingBackendProxy() const;
    247245    RefPtr<WebCore::ImageBuffer> createImageBuffer(const WebCore::FloatSize&, WebCore::RenderingMode, WebCore::RenderingPurpose, float resolutionScale, WebCore::ColorSpace, WebCore::PixelFormat) const final;
    248246#endif
    … …  
    406404    mutable bool m_cachedMainFrameHasHorizontalScrollbar { false };
    407405    mutable bool m_cachedMainFrameHasVerticalScrollbar { false };
    408 #if ENABLE(GPU_PROCESS)
    409     mutable std::unique_ptr<RemoteRenderingBackendProxy> m_remoteRenderingBackendProxy;
    410 #endif
    411406    WebPage& m_page;
    412407};

  • trunk/Source/WebKit/WebProcess/WebPage/RemoteLayerTree/RemoteLayerTreeContext.h

    r256834 r269824  
    3838class GraphicsLayerCARemote;
    3939class PlatformCALayerRemote;
     40class RemoteRenderingBackendProxy;
    4041class WebPage;
    4142
    … …  
    7879
    7980    void adoptLayersFromContext(RemoteLayerTreeContext&);
     81
     82    RemoteRenderingBackendProxy& ensureRemoteRenderingBackendProxy();
    8083   
    8184#if PLATFORM(IOS_FAMILY)

  • trunk/Source/WebKit/WebProcess/WebPage/RemoteLayerTree/RemoteLayerTreeContext.mm

    r266342 r269824  
    189189}
    190190
     191RemoteRenderingBackendProxy& RemoteLayerTreeContext::ensureRemoteRenderingBackendProxy()
     192{
     193    return m_webPage.ensureRemoteRenderingBackendProxy();
     194}
     195
    191196} // namespace WebKit

  • trunk/Source/WebKit/WebProcess/WebPage/RemoteLayerTree/RemoteLayerTreeDrawingArea.h

    r268014 r269824  
    4040namespace WebCore {
    4141class PlatformCALayer;
     42class ThreadSafeImageBufferFlusher;
    4243}
    4344
    … …  
    126127    class BackingStoreFlusher : public ThreadSafeRefCounted<BackingStoreFlusher> {
    127128    public:
    128         static Ref<BackingStoreFlusher> create(IPC::Connection*, std::unique_ptr<IPC::Encoder>, Vector<RetainPtr<CGContextRef>>);
     129        static Ref<BackingStoreFlusher> create(IPC::Connection*, std::unique_ptr<IPC::Encoder>, Vector<std::unique_ptr<WebCore::ThreadSafeImageBufferFlusher>>);
    129130
    130131        void flush();
    … …  
    132133
    133134    private:
    134         BackingStoreFlusher(IPC::Connection*, std::unique_ptr<IPC::Encoder>, Vector<RetainPtr<CGContextRef>>);
     135        BackingStoreFlusher(IPC::Connection*, std::unique_ptr<IPC::Encoder>, Vector<std::unique_ptr<WebCore::ThreadSafeImageBufferFlusher>>);
    135136
    136137        RefPtr<IPC::Connection> m_connection;
    137138        std::unique_ptr<IPC::Encoder> m_commitEncoder;
    138         Vector<RetainPtr<CGContextRef>> m_contextsToFlush;
     139        Vector<std::unique_ptr<WebCore::ThreadSafeImageBufferFlusher>> m_flushers;
    139140
    140141        std::atomic<bool> m_hasFlushed;

  • trunk/Source/WebKit/WebProcess/WebPage/RemoteLayerTree/RemoteLayerTreeDrawingArea.mm

    r268014 r269824  
    385385    // FIXME: Move all backing store flushing management to RemoteLayerBackingStoreCollection.
    386386    bool hadAnyChangedBackingStore = false;
    387     Vector<RetainPtr<CGContextRef>> contextsToFlush;
     387    Vector<std::unique_ptr<WebCore::ThreadSafeImageBufferFlusher>> flushers;
    388388    for (auto& layer : layerTransaction.changedLayers()) {
    389389        if (layer->properties().changedProperties & RemoteLayerTreeTransaction::BackingStoreChanged) {
    390390            hadAnyChangedBackingStore = true;
    391391            if (layer->properties().backingStore) {
    392                 if (auto contextPendingFlush = layer->properties().backingStore->takeFrontContextPendingFlush())
    393                     contextsToFlush.append(contextPendingFlush);
     392                if (auto pendingFlusher = layer->properties().backingStore->takePendingFlusher())
     393                    flushers.append(WTFMove(pendingFlusher));
    394394            }
    395395        }
    … …  
    403403        backingStoreCollection.scheduleVolatilityTimer();
    404404
    405     RefPtr<BackingStoreFlusher> backingStoreFlusher = BackingStoreFlusher::create(WebProcess::singleton().parentProcessConnection(), WTFMove(commitEncoder), WTFMove(contextsToFlush));
     405    RefPtr<BackingStoreFlusher> backingStoreFlusher = BackingStoreFlusher::create(WebProcess::singleton().parentProcessConnection(), WTFMove(commitEncoder), WTFMove(flushers));
    406406    m_pendingBackingStoreFlusher = backingStoreFlusher;
    407407
    … …  
    452452}
    453453
    454 Ref<RemoteLayerTreeDrawingArea::BackingStoreFlusher> RemoteLayerTreeDrawingArea::BackingStoreFlusher::create(IPC::Connection* connection, std::unique_ptr<IPC::Encoder> encoder, Vector<RetainPtr<CGContextRef>> contextsToFlush)
    455 {
    456     return adoptRef(*new RemoteLayerTreeDrawingArea::BackingStoreFlusher(connection, WTFMove(encoder), WTFMove(contextsToFlush)));
    457 }
    458 
    459 RemoteLayerTreeDrawingArea::BackingStoreFlusher::BackingStoreFlusher(IPC::Connection* connection, std::unique_ptr<IPC::Encoder> encoder, Vector<RetainPtr<CGContextRef>> contextsToFlush)
     454Ref<RemoteLayerTreeDrawingArea::BackingStoreFlusher> RemoteLayerTreeDrawingArea::BackingStoreFlusher::create(IPC::Connection* connection, std::unique_ptr<IPC::Encoder> encoder, Vector<std::unique_ptr<WebCore::ThreadSafeImageBufferFlusher>> flushers)
     455{
     456    return adoptRef(*new RemoteLayerTreeDrawingArea::BackingStoreFlusher(connection, WTFMove(encoder), WTFMove(flushers)));
     457}
     458
     459RemoteLayerTreeDrawingArea::BackingStoreFlusher::BackingStoreFlusher(IPC::Connection* connection, std::unique_ptr<IPC::Encoder> encoder, Vector<std::unique_ptr<WebCore::ThreadSafeImageBufferFlusher>> flushers)
    460460    : m_connection(connection)
    461461    , m_commitEncoder(WTFMove(encoder))
    462     , m_contextsToFlush(WTFMove(contextsToFlush))
     462    , m_flushers(WTFMove(flushers))
    463463    , m_hasFlushed(false)
    464464{
    … …  
    471471    TraceScope tracingScope(BackingStoreFlushStart, BackingStoreFlushEnd);
    472472   
    473     for (auto& context : m_contextsToFlush)
    474         CGContextFlush(context.get());
     473    for (auto& flusher : m_flushers)
     474        flusher->flush();
    475475    m_hasFlushed = true;
    476476

  • trunk/Source/WebKit/WebProcess/WebPage/WebPage.cpp

    r269805 r269824  
    5858#include "PluginView.h"
    5959#include "PrintInfo.h"
     60#include "RemoteRenderingBackendProxy.h"
    6061#include "RemoteWebInspectorUI.h"
    6162#include "RemoteWebInspectorUIMessages.h"
    … …  
    70427043#endif
    70437044
     7045#if ENABLE(GPU_PROCESS)
     7046RemoteRenderingBackendProxy& WebPage::ensureRemoteRenderingBackendProxy()
     7047{
     7048    if (!m_remoteRenderingBackendProxy)
     7049        m_remoteRenderingBackendProxy = RemoteRenderingBackendProxy::create();
     7050    return *m_remoteRenderingBackendProxy;
     7051}
     7052#endif
     7053
    70447054} // namespace WebKit
    70457055

  • trunk/Source/WebKit/WebProcess/WebPage/WebPage.h

    r269805 r269824  
    246246class PageBanner;
    247247class PluginView;
     248class RemoteRenderingBackendProxy;
    248249class RemoteWebInspectorUI;
    249250class TextCheckingControllerProxy;
    … …  
    13621363    void synchronizeCORSDisablingPatternsWithNetworkProcess();
    13631364
     1365#if ENABLE(GPU_PROCESS)
     1366    RemoteRenderingBackendProxy& ensureRemoteRenderingBackendProxy();
     1367#endif
     1368
    13641369private:
    13651370    WebPage(WebCore::PageIdentifier, WebPageCreationParameters&&);
    … …  
    21642169    uint64_t m_visitedLinkTableID;
    21652170#endif
     2171
     2172#if ENABLE(GPU_PROCESS)
     2173    std::unique_ptr<RemoteRenderingBackendProxy> m_remoteRenderingBackendProxy;
     2174#endif
    21662175};
    21672176
Note: See TracChangeset for help on using the changeset viewer.