Diff
Modified: trunk/Source/WebKit/ChangeLog (284078 => 284079)
--- trunk/Source/WebKit/ChangeLog 2021-10-13 05:44:42 UTC (rev 284078)
+++ trunk/Source/WebKit/ChangeLog 2021-10-13 05:50:33 UTC (rev 284079)
@@ -1,3 +1,180 @@
+2021-10-12 Wenson Hsieh <[email protected]>
+
+ [GPU Process] Use IPC streaming for concurrent display list processing
+ https://bugs.webkit.org/show_bug.cgi?id=230860
+ rdar://83438038
+
+ Reviewed by Tim Horton.
+
+ This patch rebuilds the concurrent display list architecture in the web and GPU processes on top of the
+ streamable IPC connections currently used by WebGL in the GPU process. See below for more details.
+
+ There should be no change in behavior.
+
+ * GPUProcess/GPUConnectionToWebProcess.cpp:
+ (WebKit::GPUConnectionToWebProcess::createRenderingBackend):
+
+ Pass a StreamConnectionBuffer from the web process to the GPU process when constructing
+ RemoteRenderingBackend; this serves as the pool of shared memory used to store streaming IPC messages sent from
+ the web process to the GPU process. I've (somewhat arbitrarily) chosen the size of this StreamConnectionBuffer
+ to match WebGL's connection buffer, though this can be tuned as needed. In a future patch, we may also want to
+ implement a mechanism for starting out with a small connection buffer, and growing it by successively larger
+ segments as needed.
+
+ * GPUProcess/GPUConnectionToWebProcess.h:
+ * GPUProcess/GPUConnectionToWebProcess.messages.in:
+ * GPUProcess/cocoa/GPUProcessCocoa.mm:
+ (WebKit::GPUProcess::additionalStateForDiagnosticReport const):
+
+ Add a FIXME for re-introducing diagnostic state logging when using streamable IPC.
+
+ * GPUProcess/graphics/RemoteDisplayListRecorder.cpp:
+ (WebKit::RemoteDisplayListRecorder::RemoteDisplayListRecorder):
+ (WebKit::RemoteDisplayListRecorder::startListeningForIPC):
+ (WebKit::RemoteDisplayListRecorder::stopListeningForIPC):
+
+ Add and remove the remote display list as a destination on the RemoteRenderingBackend's stream connection. Note
+ that the synchronous dispatch to the main thread here is necessary to maintain the ordering of out-of-stream IPC
+ messages that may have been received on the IPC thread.
+
+ * GPUProcess/graphics/RemoteDisplayListRecorder.h:
+ (WebKit::RemoteDisplayListRecorder::create):
+ (WebKit::RemoteDisplayListRecorder::handleItem):
+ * GPUProcess/graphics/RemoteImageBuffer.h:
+ (WebKit::RemoteImageBuffer::RemoteImageBuffer):
+ (WebKit::RemoteImageBuffer::apply): Deleted.
+
+ Introduce `m_remoteDisplayList` to RemoteImageBuffer, and remove some logic for applying display list items that
+ is no longer necessary.
+
+ * GPUProcess/graphics/RemoteRenderingBackend.cpp:
+ (WebKit::RemoteRenderingBackend::create):
+ (WebKit::RemoteRenderingBackend::RemoteRenderingBackend):
+
+ Set up the IPC stream connection and stream connection work queue, and immediately send a wakeup semaphore back
+ to the web process.
+
+ (WebKit::RemoteRenderingBackend::startListeningForIPC):
+ (WebKit::RemoteRenderingBackend::~RemoteRenderingBackend):
+ (WebKit::RemoteRenderingBackend::stopListeningForIPC):
+
+ Add a mechanism to immediately tell all `m_remoteDisplayLists` to stop listening for streaming IPC messages when
+ the owning RemoteRenderingBackend stops listening.
+
+ (WebKit::RemoteRenderingBackend::dispatch):
+ (WebKit::RemoteRenderingBackend::didCreateImageBufferBackend):
+ (WebKit::RemoteRenderingBackend::createImageBufferWithQualifiedIdentifier):
+ (WebKit::RemoteRenderingBackend::cacheNativeImageWithQualifiedIdentifier):
+ (WebKit::RemoteRenderingBackend::cacheFontWithQualifiedIdentifier):
+ (WebKit::RemoteRenderingBackend::finalizeRenderingUpdate):
+ (WebKit::RemoteRenderingBackend::applyMediaItem): Deleted.
+ (WebKit::RemoteRenderingBackend::ReplayerDelegate::ReplayerDelegate): Deleted.
+ (WebKit::RemoteRenderingBackend::ReplayerDelegate::apply): Deleted.
+ (WebKit::RemoteRenderingBackend::ReplayerDelegate::didCreateMaskImageBuffer): Deleted.
+ (WebKit::RemoteRenderingBackend::ReplayerDelegate::didResetMaskImageBuffer): Deleted.
+ (WebKit::RemoteRenderingBackend::ReplayerDelegate::recordResourceUse): Deleted.
+ (WebKit::RemoteRenderingBackend::submit): Deleted.
+ (WebKit::RemoteRenderingBackend::nextDestinationImageBufferAfterApplyingDisplayLists): Deleted.
+ (WebKit::RemoteRenderingBackend::wakeUpAndApplyDisplayList): Deleted.
+ (WebKit::RemoteRenderingBackend::wakeUpAndApplyDisplayListWithQualifiedIdentifier): Deleted.
+ (WebKit::RemoteRenderingBackend::setNextItemBufferToRead): Deleted.
+ (WebKit::RemoteRenderingBackend::didCreateSharedDisplayListHandle): Deleted.
+ (WebKit::RemoteRenderingBackend::didCreateSharedDisplayListHandleWithQualifiedIdentifier): Deleted.
+ (WebKit::RemoteRenderingBackend::resumeFromPendingWakeupInformation): Deleted.
+ (WebKit::RemoteRenderingBackend::didCreateMaskImageBuffer): Deleted.
+ (WebKit::RemoteRenderingBackend::didResetMaskImageBuffer): Deleted.
+ (WebKit::RemoteRenderingBackend::decodeItem): Deleted.
+ (WebKit::RemoteRenderingBackend::lastKnownState const): Deleted.
+ (WebKit::RemoteRenderingBackend::updateLastKnownState): Deleted.
+
+ Remove logic for coordinating wakeups and shared display list item buffers in the GPU process.
+
+ * GPUProcess/graphics/RemoteRenderingBackend.h:
+
+ Subclass IPC::StreamMessageReceiver. In this new concurrent display list model, RemoteRenderingBackend serves
+ as a streaming IPC destination alongside each RemoteDisplayListRecorder in the GPU process; all messages
+ previously sent to the RemoteRenderingBackend as normal IPC are now sent through the connection stream (though
+ some must be marked as non-stream-encodable).
+
+ (WebKit::RemoteRenderingBackend::streamConnection const):
+ (WebKit::RemoteRenderingBackend::decodeAndCreate): Deleted.
+ (): Deleted.
+ (WebKit::RemoteRenderingBackend::PendingWakeupInformation::shouldPerformWakeup const): Deleted.
+
+ Delete more logic related to concurrent display lists.
+
+ * GPUProcess/graphics/RemoteRenderingBackend.messages.in:
+
+ Make RemoteRenderingBackend a stream message receiver.
+
+ * GPUProcess/graphics/RemoteRenderingBackendCreationParameters.h:
+ (WebKit::RemoteRenderingBackendCreationParameters::encode const):
+ (WebKit::RemoteRenderingBackendCreationParameters::decode):
+
+ Remove the IPC::Semaphore here, that was previously used for quick GPU process wakeups. This semaphore is no
+ longer needed because we always use IPC::Semaphore for waking the GPU process when using streaming IPC.
+
+ * GPUProcess/graphics/RemoteResourceCache.h:
+ * WebProcess/GPU/graphics/RemoteImageBufferProxy.h:
+
+ Make the RemoteImageBufferProxy template class directly subclass ConcreteImageBuffer instead of
+ DisplayList::ImageBuffer; additionally, introduce a `RemoteDisplayListRecorderProxy m_remoteDisplayList` here,
+ which we use as our drawing graphics context.
+
+ (WebKit::RemoteImageBufferProxy::~RemoteImageBufferProxy):
+ (WebKit::RemoteImageBufferProxy::RemoteImageBufferProxy):
+ (WebKit::RemoteImageBufferProxy::recordNativeImageUse):
+ (WebKit::RemoteImageBufferProxy::recordFontUse):
+ (WebKit::RemoteImageBufferProxy::recordImageBufferUse):
+ (WebKit::RemoteImageBufferProxy::clearDisplayList): Deleted.
+ * WebProcess/GPU/graphics/RemoteRenderingBackendProxy.cpp:
+ (WebKit::RemoteRenderingBackendProxy::RemoteRenderingBackendProxy):
+ (WebKit::RemoteRenderingBackendProxy::ensureGPUProcessConnection):
+ (WebKit::RemoteRenderingBackendProxy::gpuProcessConnectionDidClose):
+ (WebKit::RemoteRenderingBackendProxy::createRemoteImageBuffer):
+ (WebKit::RemoteRenderingBackendProxy::sharedMemoryForGetPixelBuffer):
+ (WebKit::RemoteRenderingBackendProxy::destroyGetPixelBufferSharedMemory):
+ (WebKit::RemoteRenderingBackendProxy::getDataURLForImageBuffer):
+ (WebKit::RemoteRenderingBackendProxy::getDataForImageBuffer):
+ (WebKit::RemoteRenderingBackendProxy::getShareableBitmap):
+
+ Send all IPC messages to RemoteRenderingBackend in the GPU process through the stream connection, instead of
+ using standard IPC messages. This guarantees ordering when receiving cached resources.
+
+ (WebKit::RemoteRenderingBackendProxy::cacheNativeImage):
+ (WebKit::RemoteRenderingBackendProxy::cacheFont):
+ (WebKit::RemoteRenderingBackendProxy::deleteAllFonts):
+ (WebKit::RemoteRenderingBackendProxy::releaseRemoteResource):
+ (WebKit::RemoteRenderingBackendProxy::finalizeRenderingUpdate):
+ (WebKit::RemoteRenderingBackendProxy::renderingBackendIdentifier const):
+ (WebKit::RemoteRenderingBackendProxy::ensureBackendCreated):
+ (WebKit::RemoteRenderingBackendProxy::streamConnection):
+
+ Add a mechanism to ensure that we have the IPC stream wakeup semaphore before grabbing the stream connection.
+
+ (WebKit::RemoteRenderingBackendProxy::didCreateWakeUpSemaphoreForDisplayListStream):
+ (WebKit::RemoteRenderingBackendProxy::willAppendItem): Deleted.
+ (WebKit::RemoteRenderingBackendProxy::sendWakeupMessage): Deleted.
+ (WebKit::RemoteRenderingBackendProxy::sendDeferredWakeupMessageIfNeeded): Deleted.
+ (WebKit::RemoteRenderingBackendProxy::didAppendData): Deleted.
+ (WebKit::RemoteRenderingBackendProxy::mostRecentlyUsedDisplayListHandle): Deleted.
+ (WebKit::RemoteRenderingBackendProxy::findReusableDisplayListHandle): Deleted.
+ (WebKit::RemoteRenderingBackendProxy::createItemBuffer): Deleted.
+
+ Remove all logic previously used to coordinate concurrent display list processing on the remote rendering
+ backend.
+
+ * WebProcess/GPU/graphics/RemoteRenderingBackendProxy.h:
+ (WebKit::RemoteRenderingBackendProxy::remoteResourceCacheProxy):
+ (WebKit::RemoteRenderingBackendProxy::sendToStream):
+ (WebKit::RemoteRenderingBackendProxy::sendSyncToStream):
+
+ Add helper methods to send IPC messages to the remote rendering backend through the connection stream.
+
+ * WebProcess/GPU/graphics/RemoteRenderingBackendProxy.messages.in:
+ * WebProcess/WebPage/IPCTestingAPI.cpp:
+ (WebKit::IPCTestingAPI::encodeRemoteRenderingBackendCreationParameters):
+
2021-10-12 Ross Kirsling <[email protected]>
Non-unified build fixes, October 2021 edition.
Modified: trunk/Source/WebKit/GPUProcess/GPUConnectionToWebProcess.cpp (284078 => 284079)
--- trunk/Source/WebKit/GPUProcess/GPUConnectionToWebProcess.cpp 2021-10-13 05:44:42 UTC (rev 284078)
+++ trunk/Source/WebKit/GPUProcess/GPUConnectionToWebProcess.cpp 2021-10-13 05:50:33 UTC (rev 284079)
@@ -474,10 +474,10 @@
}
#endif
-void GPUConnectionToWebProcess::createRenderingBackend(RemoteRenderingBackendCreationParameters&& creationParameters)
+void GPUConnectionToWebProcess::createRenderingBackend(RemoteRenderingBackendCreationParameters&& creationParameters, IPC::StreamConnectionBuffer&& streamBuffer)
{
auto addResult = m_remoteRenderingBackendMap.ensure(creationParameters.identifier, [&]() {
- return IPC::ScopedActiveMessageReceiveQueue { RemoteRenderingBackend::create(*this, WTFMove(creationParameters)) };
+ return IPC::ScopedActiveMessageReceiveQueue { RemoteRenderingBackend::create(*this, WTFMove(creationParameters), WTFMove(streamBuffer)) };
});
ASSERT_UNUSED(addResult, addResult.isNewEntry);
}
Modified: trunk/Source/WebKit/GPUProcess/GPUConnectionToWebProcess.h (284078 => 284079)
--- trunk/Source/WebKit/GPUProcess/GPUConnectionToWebProcess.h 2021-10-13 05:44:42 UTC (rev 284078)
+++ trunk/Source/WebKit/GPUProcess/GPUConnectionToWebProcess.h 2021-10-13 05:50:33 UTC (rev 284079)
@@ -178,7 +178,7 @@
RemoteMediaRecorderManager& mediaRecorderManager();
#endif
- void createRenderingBackend(RemoteRenderingBackendCreationParameters&&);
+ void createRenderingBackend(RemoteRenderingBackendCreationParameters&&, IPC::StreamConnectionBuffer&&);
void releaseRenderingBackend(RenderingBackendIdentifier);
#if ENABLE(WEBGL)
Modified: trunk/Source/WebKit/GPUProcess/GPUConnectionToWebProcess.messages.in (284078 => 284079)
--- trunk/Source/WebKit/GPUProcess/GPUConnectionToWebProcess.messages.in 2021-10-13 05:44:42 UTC (rev 284078)
+++ trunk/Source/WebKit/GPUProcess/GPUConnectionToWebProcess.messages.in 2021-10-13 05:50:33 UTC (rev 284079)
@@ -23,7 +23,7 @@
#if ENABLE(GPU_PROCESS)
messages -> GPUConnectionToWebProcess WantsDispatchMessage {
- void CreateRenderingBackend(struct WebKit::RemoteRenderingBackendCreationParameters creationParameters)
+ void CreateRenderingBackend(struct WebKit::RemoteRenderingBackendCreationParameters creationParameters, IPC::StreamConnectionBuffer streamBuffer)
void ReleaseRenderingBackend(WebKit::RenderingBackendIdentifier renderingBackendIdentifier)
#if ENABLE(WEBGL)
void CreateGraphicsContextGL(struct WebCore::GraphicsContextGLAttributes attributes, WebKit::GraphicsContextGLIdentifier graphicsContextGLIdentifier, WebKit::RenderingBackendIdentifier renderingBackendIdentifier, IPC::StreamConnectionBuffer stream)
Modified: trunk/Source/WebKit/GPUProcess/cocoa/GPUProcessCocoa.mm (284078 => 284079)
--- trunk/Source/WebKit/GPUProcess/cocoa/GPUProcessCocoa.mm 2021-10-13 05:44:42 UTC (rev 284078)
+++ trunk/Source/WebKit/GPUProcess/cocoa/GPUProcessCocoa.mm 2021-10-13 05:50:33 UTC (rev 284079)
@@ -51,10 +51,7 @@
continue;
auto stateInfo = adoptNS([[NSMutableDictionary alloc] initWithCapacity:backendMap.size()]);
- for (auto& identifierAndBackend : backendMap) {
- auto& [backendIdentifier, backend] = identifierAndBackend;
- [stateInfo setObject:@(name(backend->lastKnownState())) forKey:backendIdentifier.loggingString()];
- }
+ // FIXME: Log some additional diagnostic state on RemoteRenderingBackend.
[webProcessConnectionInfo setObject:stateInfo.get() forKey:webProcessIdentifier.loggingString()];
}
Modified: trunk/Source/WebKit/GPUProcess/graphics/RemoteDisplayListRecorder.cpp (284078 => 284079)
--- trunk/Source/WebKit/GPUProcess/graphics/RemoteDisplayListRecorder.cpp 2021-10-13 05:44:42 UTC (rev 284078)
+++ trunk/Source/WebKit/GPUProcess/graphics/RemoteDisplayListRecorder.cpp 2021-10-13 05:50:33 UTC (rev 284079)
@@ -55,7 +55,10 @@
{
ASSERT(!m_isListeningForIPC);
m_isListeningForIPC = true;
- // FIXME: Not implemented yet.
+ // FIXME: Can we avoid synchronous dispatch here by adjusting the assertion in `Connection::enqueueMatchingMessagesToMessageReceiveQueue`?
+ callOnMainRunLoopAndWait([&] {
+ m_renderingBackend->streamConnection().startReceivingMessages(*this, Messages::RemoteDisplayListRecorder::messageReceiverName(), m_imageBufferIdentifier.object().toUInt64());
+ });
}
void RemoteDisplayListRecorder::stopListeningForIPC()
@@ -63,7 +66,7 @@
if (!m_isListeningForIPC)
return;
- // FIXME: Not implemented yet.
+ m_renderingBackend->streamConnection().stopReceivingMessages(Messages::RemoteDisplayListRecorder::messageReceiverName(), m_imageBufferIdentifier.object().toUInt64());
m_isListeningForIPC = false;
}
Modified: trunk/Source/WebKit/GPUProcess/graphics/RemoteImageBuffer.h (284078 => 284079)
--- trunk/Source/WebKit/GPUProcess/graphics/RemoteImageBuffer.h 2021-10-13 05:44:42 UTC (rev 284078)
+++ trunk/Source/WebKit/GPUProcess/graphics/RemoteImageBuffer.h 2021-10-13 05:50:33 UTC (rev 284079)
@@ -30,6 +30,8 @@
#include "Decoder.h"
#include "GPUConnectionToWebProcess.h"
#include "Logging.h"
+#include "RemoteDisplayListRecorder.h"
+#include "ScopedActiveMessageReceiveQueue.h"
#include <WebCore/ConcreteImageBuffer.h>
#include <WebCore/DisplayList.h>
#include <WebCore/DisplayListItems.h>
@@ -54,8 +56,9 @@
: BaseConcreteImageBuffer(parameters, WTFMove(backend), renderingResourceIdentifier.object())
, m_remoteRenderingBackend(remoteRenderingBackend)
, m_renderingResourceIdentifier(renderingResourceIdentifier)
+ , m_remoteDisplayList({ RemoteDisplayListRecorder::create(*this, renderingResourceIdentifier, renderingResourceIdentifier.processIdentifier(), remoteRenderingBackend) })
{
- m_remoteRenderingBackend.didCreateImageBufferBackend(m_backend->createImageBufferBackendHandle(), renderingResourceIdentifier);
+ m_remoteRenderingBackend.didCreateImageBufferBackend(m_backend->createImageBufferBackendHandle(), renderingResourceIdentifier, *m_remoteDisplayList.get());
}
~RemoteImageBuffer()
@@ -77,41 +80,9 @@
private:
friend class RemoteRenderingBackend;
- bool apply(WebCore::DisplayList::ItemHandle item, WebCore::GraphicsContext& context)
- {
- if (item.is<WebCore::DisplayList::GetPixelBuffer>()) {
- auto& getPixelBufferItem = item.get<WebCore::DisplayList::GetPixelBuffer>();
- auto pixelBuffer = BaseConcreteImageBuffer::getPixelBuffer(getPixelBufferItem.outputFormat(), getPixelBufferItem.srcRect());
- m_remoteRenderingBackend.populateGetPixelBufferSharedMemory(WTFMove(pixelBuffer));
- return true;
- }
-
- if (item.is<WebCore::DisplayList::PutPixelBuffer>()) {
- auto& putPixelBufferItem = item.get<WebCore::DisplayList::PutPixelBuffer>();
- putPixelBuffer(putPixelBufferItem.pixelBuffer(), putPixelBufferItem.srcRect(), putPixelBufferItem.destPoint(), putPixelBufferItem.destFormat());
- return true;
- }
-
- if (item.is<WebCore::DisplayList::FlushContext>()) {
- BaseConcreteImageBuffer::flushContext();
- auto identifier = item.get<WebCore::DisplayList::FlushContext>().identifier();
- LOG_WITH_STREAM(SharedDisplayLists, stream << "Acknowledging Flush{" << identifier << "} in Image(" << m_renderingResourceIdentifier << ")");
- m_remoteRenderingBackend.didFlush(identifier, m_renderingResourceIdentifier);
- return true;
- }
-
- if (item.is<WebCore::DisplayList::MetaCommandChangeItemBuffer>()) {
- auto nextBufferIdentifier = item.get<WebCore::DisplayList::MetaCommandChangeItemBuffer>().identifier();
- LOG_WITH_STREAM(SharedDisplayLists, stream << "Switching to Items[" << nextBufferIdentifier << "]");
- m_remoteRenderingBackend.setNextItemBufferToRead(nextBufferIdentifier, m_renderingResourceIdentifier);
- return true;
- }
-
- return m_remoteRenderingBackend.applyMediaItem(item, context);
- }
-
RemoteRenderingBackend& m_remoteRenderingBackend;
QualifiedRenderingResourceIdentifier m_renderingResourceIdentifier;
+ IPC::ScopedActiveMessageReceiveQueue<RemoteDisplayListRecorder> m_remoteDisplayList;
};
} // namespace WebKit
Modified: trunk/Source/WebKit/GPUProcess/graphics/RemoteRenderingBackend.cpp (284078 => 284079)
--- trunk/Source/WebKit/GPUProcess/graphics/RemoteRenderingBackend.cpp 2021-10-13 05:44:42 UTC (rev 284078)
+++ trunk/Source/WebKit/GPUProcess/graphics/RemoteRenderingBackend.cpp 2021-10-13 05:50:33 UTC (rev 284079)
@@ -28,7 +28,6 @@
#if ENABLE(GPU_PROCESS)
-#include "DisplayListReaderHandle.h"
#include "GPUConnectionToWebProcess.h"
#include "Logging.h"
#include "PlatformRemoteImageBuffer.h"
@@ -73,26 +72,27 @@
namespace WebKit {
using namespace WebCore;
-Ref<RemoteRenderingBackend> RemoteRenderingBackend::create(GPUConnectionToWebProcess& gpuConnectionToWebProcess, RemoteRenderingBackendCreationParameters&& creationParameters)
+Ref<RemoteRenderingBackend> RemoteRenderingBackend::create(GPUConnectionToWebProcess& gpuConnectionToWebProcess, RemoteRenderingBackendCreationParameters&& creationParameters, IPC::StreamConnectionBuffer&& streamBuffer)
{
- auto instance = adoptRef(*new RemoteRenderingBackend(gpuConnectionToWebProcess, WTFMove(creationParameters)));
+ auto instance = adoptRef(*new RemoteRenderingBackend(gpuConnectionToWebProcess, WTFMove(creationParameters), WTFMove(streamBuffer)));
instance->startListeningForIPC();
return instance;
}
-RemoteRenderingBackend::RemoteRenderingBackend(GPUConnectionToWebProcess& gpuConnectionToWebProcess, RemoteRenderingBackendCreationParameters&& creationParameters)
- : m_workQueue(WorkQueue::create("RemoteRenderingBackend work queue", WorkQueue::Type::Serial, WorkQueue::QOS::UserInteractive))
+RemoteRenderingBackend::RemoteRenderingBackend(GPUConnectionToWebProcess& gpuConnectionToWebProcess, RemoteRenderingBackendCreationParameters&& creationParameters, IPC::StreamConnectionBuffer&& streamBuffer)
+ : m_workQueue("RemoteRenderingBackend work queue")
+ , m_streamConnection(IPC::StreamServerConnection::create(gpuConnectionToWebProcess.connection(), WTFMove(streamBuffer), m_workQueue))
, m_remoteResourceCache(gpuConnectionToWebProcess.webProcessIdentifier())
, m_gpuConnectionToWebProcess(gpuConnectionToWebProcess)
, m_renderingBackendIdentifier(creationParameters.identifier)
- , m_resumeDisplayListSemaphore(WTFMove(creationParameters.resumeDisplayListSemaphore))
{
ASSERT(RunLoop::isMain());
+ send(Messages::RemoteRenderingBackendProxy::DidCreateWakeUpSemaphoreForDisplayListStream(m_workQueue.wakeUpSemaphore()), m_renderingBackendIdentifier);
}
void RemoteRenderingBackend::startListeningForIPC()
{
- m_gpuConnectionToWebProcess->connection().addWorkQueueMessageReceiver(Messages::RemoteRenderingBackend::messageReceiverName(), m_workQueue, this, m_renderingBackendIdentifier.toUInt64());
+ m_streamConnection->startReceivingMessages(*this, Messages::RemoteRenderingBackend::messageReceiverName(), m_renderingBackendIdentifier.toUInt64());
}
RemoteRenderingBackend::~RemoteRenderingBackend()
@@ -99,21 +99,20 @@
{
// Make sure we destroy the ResourceCache on the WorkQueue since it gets populated on the WorkQueue.
// Make sure rendering resource request is released after destroying the cache.
- m_workQueue->dispatch([renderingResourcesRequest = WTFMove(m_renderingResourcesRequest), remoteResourceCache = WTFMove(m_remoteResourceCache)] { });
+ m_workQueue.dispatch([renderingResourcesRequest = WTFMove(m_renderingResourcesRequest), remoteResourceCache = WTFMove(m_remoteResourceCache)] { });
}
void RemoteRenderingBackend::stopListeningForIPC()
{
ASSERT(RunLoop::isMain());
-
- // The RemoteRenderingBackend destructor won't be called until disconnect() is called and we unregister ourselves as a WorkQueueMessageReceiver because
- // the IPC::Connection refs its WorkQueueMessageReceivers.
- m_gpuConnectionToWebProcess->connection().removeWorkQueueMessageReceiver(Messages::RemoteRenderingBackend::messageReceiverName(), m_renderingBackendIdentifier.toUInt64());
+ m_streamConnection->stopReceivingMessages(Messages::RemoteRenderingBackend::messageReceiverName(), m_renderingBackendIdentifier.toUInt64());
+ for (auto& remoteContext : std::exchange(m_remoteDisplayLists, { }))
+ remoteContext.stopListeningForIPC();
}
void RemoteRenderingBackend::dispatch(Function<void()>&& task)
{
- m_workQueue->dispatch(WTFMove(task));
+ m_workQueue.dispatch(WTFMove(task));
}
IPC::Connection* RemoteRenderingBackend::messageSenderConnection() const
@@ -126,26 +125,9 @@
return m_renderingBackendIdentifier.toUInt64();
}
-bool RemoteRenderingBackend::applyMediaItem(DisplayList::ItemHandle item, GraphicsContext& context)
+void RemoteRenderingBackend::didCreateImageBufferBackend(ImageBufferBackendHandle handle, QualifiedRenderingResourceIdentifier renderingResourceIdentifier, RemoteDisplayListRecorder& remoteDisplayList)
{
- ASSERT(!RunLoop::isMain());
-
- if (!item.is<DisplayList::PaintFrameForMedia>())
- return false;
-
- auto& mediaItem = item.get<DisplayList::PaintFrameForMedia>();
- callOnMainRunLoopAndWait([&, gpuConnectionToWebProcess = m_gpuConnectionToWebProcess, mediaPlayerIdentifier = mediaItem.identifier()] {
- auto player = gpuConnectionToWebProcess->remoteMediaPlayerManagerProxy().mediaPlayer(mediaPlayerIdentifier);
- if (!player)
- return;
- // It is currently not safe to call paintFrameForMedia() off the main thread.
- context.paintFrameForMedia(*player, mediaItem.destination());
- });
- return true;
-}
-
-void RemoteRenderingBackend::didCreateImageBufferBackend(ImageBufferBackendHandle handle, QualifiedRenderingResourceIdentifier renderingResourceIdentifier)
-{
+ m_remoteDisplayLists.add(remoteDisplayList);
MESSAGE_CHECK(renderingResourceIdentifier.processIdentifier() == m_gpuConnectionToWebProcess->webProcessIdentifier(), "Sending didCreateImageBufferBackend() message to the wrong web process.");
send(Messages::RemoteRenderingBackendProxy::DidCreateImageBufferBackend(WTFMove(handle), renderingResourceIdentifier.object()), m_renderingBackendIdentifier);
}
@@ -190,215 +172,8 @@
m_remoteResourceCache.cacheImageBuffer(*imageBuffer, imageBufferResourceIdentifier);
updateRenderingResourceRequest();
-
- if (m_pendingWakeupInfo && m_pendingWakeupInfo->shouldPerformWakeup(imageBufferResourceIdentifier))
- resumeFromPendingWakeupInformation();
}
-RemoteRenderingBackend::ReplayerDelegate::ReplayerDelegate(WebCore::ImageBuffer& destination, RemoteRenderingBackend& remoteRenderingBackend, ProcessIdentifier webProcessIdentifier)
- : m_destination(destination)
- , m_remoteRenderingBackend(remoteRenderingBackend)
- , m_webProcessIdentifier(webProcessIdentifier)
-{
-}
-
-bool RemoteRenderingBackend::ReplayerDelegate::apply(WebCore::DisplayList::ItemHandle item, WebCore::GraphicsContext& graphicsContext)
-{
- auto apply = [&](auto&& destination) {
- return destination.apply(item, graphicsContext);
- };
-
- if (m_destination.renderingMode() == RenderingMode::Accelerated)
- return apply(static_cast<AcceleratedRemoteImageBuffer&>(m_destination));
- return apply(static_cast<UnacceleratedRemoteImageBuffer&>(m_destination));
-}
-
-void RemoteRenderingBackend::ReplayerDelegate::didCreateMaskImageBuffer(WebCore::ImageBuffer& imageBuffer)
-{
- m_remoteRenderingBackend.didCreateMaskImageBuffer(imageBuffer);
-}
-
-void RemoteRenderingBackend::ReplayerDelegate::didResetMaskImageBuffer()
-{
- m_remoteRenderingBackend.didResetMaskImageBuffer();
-}
-
-void RemoteRenderingBackend::ReplayerDelegate::recordResourceUse(RenderingResourceIdentifier renderingResourceIdentifier)
-{
- m_remoteRenderingBackend.remoteResourceCache().recordResourceUse({ renderingResourceIdentifier, m_webProcessIdentifier });
-}
-
-DisplayList::ReplayResult RemoteRenderingBackend::submit(const DisplayList::DisplayList& displayList, ImageBuffer& destination)
-{
- if (displayList.isEmpty())
- return { };
-
- ReplayerDelegate replayerDelegate(destination, *this, m_gpuConnectionToWebProcess->webProcessIdentifier());
-
- return WebCore::DisplayList::Replayer {
- destination.context(),
- displayList,
- &remoteResourceCache().resourceHeap(),
- m_currentMaskImageBuffer.get(),
- &replayerDelegate
- }.replay();
-}
-
-RefPtr<ImageBuffer> RemoteRenderingBackend::nextDestinationImageBufferAfterApplyingDisplayLists(ImageBuffer& initialDestination, size_t initialOffset, DisplayListReaderHandle& handle, GPUProcessWakeupReason reason, ProcessIdentifier webProcessIdentifier)
-{
- RefPtr destination { &initialDestination };
- Ref handleProtector { handle };
-
- auto offset = initialOffset;
- size_t sizeToRead = 0;
- do {
- sizeToRead = handle.unreadBytes();
- } while (!sizeToRead);
-
- while (destination) {
- auto displayList = handle.displayListForReading(offset, sizeToRead, *this);
- MESSAGE_CHECK_WITH_RETURN_VALUE(displayList, nullptr, "Failed to map display list from shared memory");
-
-#if !LOG_DISABLED
- auto startTime = MonotonicTime::now();
-#endif
- auto result = submit(*displayList, *destination);
- LOG_WITH_STREAM(SharedDisplayLists, stream << "Read [" << offset << ", " << offset + result.numberOfBytesRead << "]; Items[" << handle.identifier() << "] => Image(" << destination->renderingResourceIdentifier() << ") in " << MonotonicTime::now() - startTime);
- MESSAGE_CHECK_WITH_RETURN_VALUE(result.reasonForStopping != DisplayList::StopReplayReason::InvalidItemOrExtent, nullptr, "Detected invalid display list item or extent");
- MESSAGE_CHECK_WITH_RETURN_VALUE(result.reasonForStopping != DisplayList::StopReplayReason::OutOfMemory, nullptr, "Cound not allocate memory");
-
- auto advanceResult = handle.advance(result.numberOfBytesRead);
- MESSAGE_CHECK_WITH_RETURN_VALUE(advanceResult, nullptr, "Failed to advance display list reader handle");
- sizeToRead = *advanceResult;
-
- CheckedSize checkedOffset = offset;
- checkedOffset += result.numberOfBytesRead;
- MESSAGE_CHECK_WITH_RETURN_VALUE(!checkedOffset.hasOverflowed(), nullptr, "Overflowed when advancing shared display list handle offset");
-
- offset = checkedOffset;
- MESSAGE_CHECK_WITH_RETURN_VALUE(offset <= handle.sharedMemory().size(), nullptr, "Out-of-bounds offset into shared display list handle");
-
- if (result.reasonForStopping == DisplayList::StopReplayReason::ChangeDestinationImageBuffer) {
- destination = m_remoteResourceCache.cachedImageBuffer({ *result.nextDestinationImageBuffer, m_gpuConnectionToWebProcess->webProcessIdentifier() });
- if (!destination) {
- ASSERT(!m_pendingWakeupInfo);
- m_pendingWakeupInfo = {{
- handle.identifier(),
- offset,
- { *result.nextDestinationImageBuffer, webProcessIdentifier },
- reason,
- std::nullopt,
- RemoteRenderingBackendState::WaitingForDestinationImageBuffer
- }};
- }
- }
-
- if (result.reasonForStopping == DisplayList::StopReplayReason::MissingCachedResource) {
- m_pendingWakeupInfo = {{
- handle.identifier(),
- offset,
- { destination->renderingResourceIdentifier(), webProcessIdentifier },
- reason,
- { { *result.missingCachedResourceIdentifier, webProcessIdentifier } },
- RemoteRenderingBackendState::WaitingForCachedResource
- }};
- }
-
- if (m_pendingWakeupInfo)
- break;
-
- if (!sizeToRead) {
- if (reason != GPUProcessWakeupReason::ItemCountHysteresisExceeded)
- break;
-
- handle.startWaiting();
- m_resumeDisplayListSemaphore.waitFor(30_us);
-
- auto stopWaitingResult = handle.stopWaiting();
- MESSAGE_CHECK_WITH_RETURN_VALUE(stopWaitingResult, nullptr, "Invalid waiting status detected when resuming display list processing");
-
- auto resumeReadingInfo = stopWaitingResult.value();
- if (!resumeReadingInfo)
- break;
-
- sizeToRead = handle.unreadBytes();
- MESSAGE_CHECK_WITH_RETURN_VALUE(sizeToRead, nullptr, "No unread bytes when resuming display list processing");
-
- auto newDestinationIdentifier = makeObjectIdentifier<RenderingResourceIdentifierType>(resumeReadingInfo->destination);
- MESSAGE_CHECK_WITH_RETURN_VALUE(newDestinationIdentifier.isValid(), nullptr, "Invalid image buffer destination when resuming display list processing");
-
- destination = m_remoteResourceCache.cachedImageBuffer({ newDestinationIdentifier, m_gpuConnectionToWebProcess->webProcessIdentifier() });
- MESSAGE_CHECK_WITH_RETURN_VALUE(destination, nullptr, "Missing image buffer destination when resuming display list processing");
-
- offset = resumeReadingInfo->offset;
- }
- }
-
- return destination;
-}
-
-void RemoteRenderingBackend::wakeUpAndApplyDisplayList(const GPUProcessWakeupMessageArguments& arguments)
-{
- // Immediately turn the RenderingResourceIdentifier (which is error-prone) to a QualifiedRenderingResourceIdentifier,
- // and use a helper function to make sure that don't accidentally use the RenderingResourceIdentifier (because the helper function can't see it).
- wakeUpAndApplyDisplayListWithQualifiedIdentifier(arguments.itemBufferIdentifier, arguments.offset, { arguments.destinationImageBufferIdentifier, m_gpuConnectionToWebProcess->webProcessIdentifier() }, arguments.reason);
-}
-
-void RemoteRenderingBackend::wakeUpAndApplyDisplayListWithQualifiedIdentifier(WebCore::DisplayList::ItemBufferIdentifier itemBufferIdentifier, uint64_t offset, QualifiedRenderingResourceIdentifier destinationImageBufferIdentifier, GPUProcessWakeupReason reason)
-{
- ASSERT(!RunLoop::isMain());
-
- TraceScope tracingScope(WakeUpAndApplyDisplayListStart, WakeUpAndApplyDisplayListEnd);
-
- updateLastKnownState(RemoteRenderingBackendState::BeganReplayingDisplayList);
-
- RefPtr destinationImageBuffer = m_remoteResourceCache.cachedImageBuffer(destinationImageBufferIdentifier);
- MESSAGE_CHECK(destinationImageBuffer, "Missing destination image buffer");
-
- auto initialHandle = m_sharedDisplayListHandles.get(itemBufferIdentifier);
- MESSAGE_CHECK(initialHandle, "Missing initial shared display list handle");
-
- LOG_WITH_STREAM(SharedDisplayLists, stream << "Waking up to Items[" << itemBufferIdentifier << "] => Image(" << destinationImageBufferIdentifier.object() << ") at " << offset);
- destinationImageBuffer = nextDestinationImageBufferAfterApplyingDisplayLists(*destinationImageBuffer, offset, *initialHandle, reason, m_gpuConnectionToWebProcess->webProcessIdentifier());
-
- // FIXME: All the callers pass m_pendingWakeupInfo's fields so the body of this function should just be this loop.
- while (destinationImageBuffer && m_pendingWakeupInfo) {
- if (m_pendingWakeupInfo->missingCachedResourceIdentifier)
- break;
-
- auto nextHandle = m_sharedDisplayListHandles.get(m_pendingWakeupInfo->itemBufferIdentifier);
- if (!nextHandle) {
- // If the handle identifier is currently unknown, wait until the GPU process receives an
- // IPC message with a shared memory handle to the next item buffer.
- break;
- }
-
- // Otherwise, continue reading the next display list item buffer from the start.
- auto offset = m_pendingWakeupInfo->offset;
- auto reason = m_pendingWakeupInfo->reason;
- m_pendingWakeupInfo = std::nullopt;
- destinationImageBuffer = nextDestinationImageBufferAfterApplyingDisplayLists(*destinationImageBuffer, offset, *nextHandle, reason, m_gpuConnectionToWebProcess->webProcessIdentifier());
- }
- LOG_WITH_STREAM(SharedDisplayLists, stream << "Going back to sleep.");
-
- if (m_pendingWakeupInfo)
- updateLastKnownState(m_pendingWakeupInfo->state);
- else
- updateLastKnownState(RemoteRenderingBackendState::FinishedReplayingDisplayList);
-}
-
-void RemoteRenderingBackend::setNextItemBufferToRead(DisplayList::ItemBufferIdentifier identifier, QualifiedRenderingResourceIdentifier destinationIdentifier)
-{
- m_pendingWakeupInfo = {{
- identifier,
- SharedDisplayListHandle::headerSize(),
- destinationIdentifier,
- GPUProcessWakeupReason::Unspecified,
- std::nullopt,
- RemoteRenderingBackendState::WaitingForItemBuffer
- }};
-}
-
std::optional<SharedMemory::IPCHandle> RemoteRenderingBackend::updateSharedMemoryForGetPixelBufferHelper(size_t byteCount)
{
MESSAGE_CHECK_WITH_RETURN_VALUE(!m_getPixelBufferSharedMemory || byteCount > m_getPixelBufferSharedMemory->size(), std::nullopt, "The existing Shmem for getPixelBuffer() is already big enough to handle the request");
@@ -547,9 +322,6 @@
return;
m_remoteResourceCache.cacheNativeImage(*image, nativeImageResourceIdentifier);
-
- if (m_pendingWakeupInfo && m_pendingWakeupInfo->shouldPerformWakeup(nativeImageResourceIdentifier))
- resumeFromPendingWakeupInformation();
}
void RemoteRenderingBackend::cacheFont(Ref<WebCore::Font>&& font)
@@ -565,8 +337,6 @@
ASSERT(!RunLoop::isMain());
m_remoteResourceCache.cacheFont(WTFMove(font), fontResourceIdentifier);
- if (m_pendingWakeupInfo && m_pendingWakeupInfo->shouldPerformWakeup(fontResourceIdentifier))
- resumeFromPendingWakeupInformation();
}
void RemoteRenderingBackend::deleteAllFonts()
@@ -592,169 +362,9 @@
void RemoteRenderingBackend::finalizeRenderingUpdate(RenderingUpdateID renderingUpdateID)
{
- auto shouldPerformWakeup = [&] {
- return m_remoteResourceCache.cachedImageBuffer(m_pendingWakeupInfo->destinationImageBufferIdentifier) && m_sharedDisplayListHandles.contains(m_pendingWakeupInfo->itemBufferIdentifier);
- };
-
- if (m_pendingWakeupInfo && shouldPerformWakeup())
- resumeFromPendingWakeupInformation();
-
send(Messages::RemoteRenderingBackendProxy::DidFinalizeRenderingUpdate(renderingUpdateID), m_renderingBackendIdentifier);
}
-void RemoteRenderingBackend::didCreateSharedDisplayListHandle(DisplayList::ItemBufferIdentifier itemBufferIdentifier, const SharedMemory::IPCHandle& handle, RenderingResourceIdentifier destinationBufferIdentifier)
-{
- // Immediately turn the RenderingResourceIdentifier (which is error-prone) to a QualifiedRenderingResourceIdentifier,
- // and use a helper function to make sure that don't accidentally use the RenderingResourceIdentifier (because the helper function can't see it).
- didCreateSharedDisplayListHandleWithQualifiedIdentifier(itemBufferIdentifier, handle, { destinationBufferIdentifier, m_gpuConnectionToWebProcess->webProcessIdentifier() });
-}
-
-void RemoteRenderingBackend::didCreateSharedDisplayListHandleWithQualifiedIdentifier(DisplayList::ItemBufferIdentifier itemBufferIdentifier, const SharedMemory::IPCHandle& handle, QualifiedRenderingResourceIdentifier)
-{
- ASSERT(!RunLoop::isMain());
- MESSAGE_CHECK(!m_sharedDisplayListHandles.contains(itemBufferIdentifier), "Duplicate shared display list handle");
-
- if (auto sharedMemory = SharedMemory::map(handle.handle, SharedMemory::Protection::ReadWrite)) {
- auto handle = DisplayListReaderHandle::create(itemBufferIdentifier, sharedMemory.releaseNonNull());
- MESSAGE_CHECK(handle, "There must be enough space to create the handle.");
- m_sharedDisplayListHandles.set(itemBufferIdentifier, handle);
- }
-
- if (m_pendingWakeupInfo && m_pendingWakeupInfo->shouldPerformWakeup(itemBufferIdentifier))
- resumeFromPendingWakeupInformation();
-}
-
-void RemoteRenderingBackend::resumeFromPendingWakeupInformation()
-{
- auto itemBufferIdentifier = m_pendingWakeupInfo->itemBufferIdentifier;
- auto offset = m_pendingWakeupInfo->offset;
- auto destinationImageBufferIdentifier = m_pendingWakeupInfo->destinationImageBufferIdentifier;
- auto reason = m_pendingWakeupInfo->reason;
- m_pendingWakeupInfo = std::nullopt;
- wakeUpAndApplyDisplayListWithQualifiedIdentifier(itemBufferIdentifier, offset, destinationImageBufferIdentifier, reason);
-}
-
-void RemoteRenderingBackend::didCreateMaskImageBuffer(ImageBuffer& imageBuffer)
-{
- ASSERT(!RunLoop::isMain());
- MESSAGE_CHECK(!m_currentMaskImageBuffer, "Current mask image buffer is already set.");
- m_currentMaskImageBuffer = &imageBuffer;
-}
-
-void RemoteRenderingBackend::didResetMaskImageBuffer()
-{
- ASSERT(!RunLoop::isMain());
- MESSAGE_CHECK(m_currentMaskImageBuffer, "Current mask image buffer was not already set.");
- m_currentMaskImageBuffer = nullptr;
-}
-
-std::optional<DisplayList::ItemHandle> WARN_UNUSED_RETURN RemoteRenderingBackend::decodeItem(const uint8_t* data, size_t length, DisplayList::ItemType type, uint8_t* handleLocation)
-{
- /* This needs to match (1) isInlineItem() in DisplayListItemType.cpp, (2) RemoteImageBufferProxy::encodeItem(),
- * and (3) all the "static constexpr bool isInlineItem"s inside the individual item classes.
- * See the comment at the top of DisplayListItems.h for why. */
-
- switch (type) {
- case DisplayList::ItemType::BeginClipToDrawingCommands:
- return decodeAndCreate<DisplayList::BeginClipToDrawingCommands>(data, length, handleLocation);
- case DisplayList::ItemType::ClipOutToPath:
- return decodeAndCreate<DisplayList::ClipOutToPath>(data, length, handleLocation);
- case DisplayList::ItemType::ClipPath:
- return decodeAndCreate<DisplayList::ClipPath>(data, length, handleLocation);
- case DisplayList::ItemType::DrawFocusRingPath:
- return decodeAndCreate<DisplayList::DrawFocusRingPath>(data, length, handleLocation);
- case DisplayList::ItemType::DrawFocusRingRects:
- return decodeAndCreate<DisplayList::DrawFocusRingRects>(data, length, handleLocation);
- case DisplayList::ItemType::DrawGlyphs:
- return decodeAndCreate<DisplayList::DrawGlyphs>(data, length, handleLocation);
- case DisplayList::ItemType::DrawLinesForText:
- return decodeAndCreate<DisplayList::DrawLinesForText>(data, length, handleLocation);
- case DisplayList::ItemType::DrawPath:
- return decodeAndCreate<DisplayList::DrawPath>(data, length, handleLocation);
- case DisplayList::ItemType::FillCompositedRect:
- return decodeAndCreate<DisplayList::FillCompositedRect>(data, length, handleLocation);
- case DisplayList::ItemType::FillPath:
- return decodeAndCreate<DisplayList::FillPath>(data, length, handleLocation);
- case DisplayList::ItemType::FillRectWithColor:
- return decodeAndCreate<DisplayList::FillRectWithColor>(data, length, handleLocation);
- case DisplayList::ItemType::FillRectWithGradient:
- return decodeAndCreate<DisplayList::FillRectWithGradient>(data, length, handleLocation);
- case DisplayList::ItemType::FillRectWithRoundedHole:
- return decodeAndCreate<DisplayList::FillRectWithRoundedHole>(data, length, handleLocation);
- case DisplayList::ItemType::FillRoundedRect:
- return decodeAndCreate<DisplayList::FillRoundedRect>(data, length, handleLocation);
- case DisplayList::ItemType::GetPixelBuffer:
- return decodeAndCreate<DisplayList::GetPixelBuffer>(data, length, handleLocation);
- case DisplayList::ItemType::PutPixelBuffer:
- return decodeAndCreate<DisplayList::PutPixelBuffer>(data, length, handleLocation);
- case DisplayList::ItemType::SetLineDash:
- return decodeAndCreate<DisplayList::SetLineDash>(data, length, handleLocation);
- case DisplayList::ItemType::SetState:
- return decodeAndCreate<DisplayList::SetState>(data, length, handleLocation);
- case DisplayList::ItemType::StrokePath:
- return decodeAndCreate<DisplayList::StrokePath>(data, length, handleLocation);
- case DisplayList::ItemType::ApplyDeviceScaleFactor:
-#if USE(CG)
- case DisplayList::ItemType::ApplyFillPattern:
- case DisplayList::ItemType::ApplyStrokePattern:
-#endif
- case DisplayList::ItemType::BeginTransparencyLayer:
- case DisplayList::ItemType::ClearRect:
- case DisplayList::ItemType::ClearShadow:
- case DisplayList::ItemType::Clip:
- case DisplayList::ItemType::ClipOut:
- case DisplayList::ItemType::ClipToImageBuffer:
- case DisplayList::ItemType::EndClipToDrawingCommands:
- case DisplayList::ItemType::ConcatenateCTM:
- case DisplayList::ItemType::DrawDotsForDocumentMarker:
- case DisplayList::ItemType::DrawEllipse:
- case DisplayList::ItemType::DrawImageBuffer:
- case DisplayList::ItemType::DrawNativeImage:
- case DisplayList::ItemType::DrawPattern:
- case DisplayList::ItemType::DrawLine:
- case DisplayList::ItemType::DrawRect:
- case DisplayList::ItemType::EndTransparencyLayer:
- case DisplayList::ItemType::FillEllipse:
-#if ENABLE(INLINE_PATH_DATA)
- case DisplayList::ItemType::FillLine:
- case DisplayList::ItemType::FillArc:
- case DisplayList::ItemType::FillQuadCurve:
- case DisplayList::ItemType::FillBezierCurve:
-#endif
- case DisplayList::ItemType::FillRect:
- case DisplayList::ItemType::FlushContext:
- case DisplayList::ItemType::MetaCommandChangeDestinationImageBuffer:
- case DisplayList::ItemType::MetaCommandChangeItemBuffer:
-#if ENABLE(VIDEO)
- case DisplayList::ItemType::PaintFrameForMedia:
-#endif
- case DisplayList::ItemType::Restore:
- case DisplayList::ItemType::Rotate:
- case DisplayList::ItemType::Save:
- case DisplayList::ItemType::Scale:
- case DisplayList::ItemType::SetCTM:
- case DisplayList::ItemType::SetInlineFillColor:
- case DisplayList::ItemType::SetInlineStrokeColor:
- case DisplayList::ItemType::SetLineCap:
- case DisplayList::ItemType::SetLineJoin:
- case DisplayList::ItemType::SetMiterLimit:
- case DisplayList::ItemType::SetStrokeThickness:
- case DisplayList::ItemType::StrokeEllipse:
-#if ENABLE(INLINE_PATH_DATA)
- case DisplayList::ItemType::StrokeArc:
- case DisplayList::ItemType::StrokeQuadCurve:
- case DisplayList::ItemType::StrokeBezierCurve:
-#endif
- case DisplayList::ItemType::StrokeRect:
- case DisplayList::ItemType::StrokeLine:
- case DisplayList::ItemType::Translate:
- ASSERT_NOT_REACHED();
- return std::nullopt;
- }
- ASSERT_NOT_REACHED();
- return std::nullopt;
-}
-
void RemoteRenderingBackend::updateRenderingResourceRequest()
{
bool hasActiveDrawables = m_remoteResourceCache.hasActiveDrawables();
@@ -771,18 +381,6 @@
return !m_remoteResourceCache.hasActiveDrawables();
}
-RemoteRenderingBackendState RemoteRenderingBackend::lastKnownState() const
-{
- ASSERT(RunLoop::isMain());
- return m_lastKnownState.load();
-}
-
-void RemoteRenderingBackend::updateLastKnownState(RemoteRenderingBackendState state)
-{
- ASSERT(!RunLoop::isMain());
- m_lastKnownState.storeRelaxed(state);
-}
-
void RemoteRenderingBackend::performWithMediaPlayerOnMainThread(MediaPlayerIdentifier identifier, Function<void(MediaPlayer&)>&& callback)
{
callOnMainRunLoopAndWait([&, gpuConnectionToWebProcess = m_gpuConnectionToWebProcess, identifier] {
Modified: trunk/Source/WebKit/GPUProcess/graphics/RemoteRenderingBackend.h (284078 => 284079)
--- trunk/Source/WebKit/GPUProcess/graphics/RemoteRenderingBackend.h 2021-10-13 05:44:42 UTC (rev 284078)
+++ trunk/Source/WebKit/GPUProcess/graphics/RemoteRenderingBackend.h 2021-10-13 05:50:33 UTC (rev 284079)
@@ -28,17 +28,20 @@
#if ENABLE(GPU_PROCESS)
#include "Connection.h"
-#include "GPUProcessWakeupMessageArguments.h"
#include "IPCSemaphore.h"
#include "ImageBufferBackendHandle.h"
#include "MessageReceiver.h"
#include "MessageSender.h"
#include "QualifiedRenderingResourceIdentifier.h"
+#include "RemoteDisplayListRecorder.h"
#include "RemoteRenderingBackendState.h"
#include "RemoteResourceCache.h"
#include "RenderingBackendIdentifier.h"
#include "RenderingUpdateID.h"
#include "ScopedRenderingResourcesRequest.h"
+#include "StreamConnectionWorkQueue.h"
+#include "StreamMessageReceiver.h"
+#include "StreamServerConnection.h"
#include <WebCore/ColorSpace.h>
#include <WebCore/DisplayList.h>
#include <WebCore/DisplayListItems.h>
@@ -48,11 +51,6 @@
namespace WebCore {
-namespace DisplayList {
-class DisplayList;
-class Item;
-}
-
class DestinationColorSpace;
class FloatSize;
class NativeImage;
@@ -63,34 +61,24 @@
namespace WebKit {
-class DisplayListReaderHandle;
class GPUConnectionToWebProcess;
+class RemoteDisplayListRecorder;
struct RemoteRenderingBackendCreationParameters;
-class RemoteRenderingBackend
- : private IPC::MessageSender
- , public IPC::Connection::WorkQueueMessageReceiver
- , public WebCore::DisplayList::ItemBufferReadingClient {
+class RemoteRenderingBackend : private IPC::MessageSender, public IPC::StreamMessageReceiver {
public:
-
- static Ref<RemoteRenderingBackend> create(GPUConnectionToWebProcess&, RemoteRenderingBackendCreationParameters&&);
+ static Ref<RemoteRenderingBackend> create(GPUConnectionToWebProcess&, RemoteRenderingBackendCreationParameters&&, IPC::StreamConnectionBuffer&&);
virtual ~RemoteRenderingBackend();
void stopListeningForIPC();
RemoteResourceCache& remoteResourceCache() { return m_remoteResourceCache; }
- // Rendering operations.
- bool applyMediaItem(WebCore::DisplayList::ItemHandle, WebCore::GraphicsContext&);
+ void didReceiveStreamMessage(IPC::StreamServerConnectionBase&, IPC::Decoder&) final;
// Messages to be sent.
- void didCreateImageBufferBackend(ImageBufferBackendHandle, QualifiedRenderingResourceIdentifier);
+ void didCreateImageBufferBackend(ImageBufferBackendHandle, QualifiedRenderingResourceIdentifier, RemoteDisplayListRecorder&);
void didFlush(WebCore::GraphicsContextFlushIdentifier, QualifiedRenderingResourceIdentifier);
- void setNextItemBufferToRead(WebCore::DisplayList::ItemBufferIdentifier, QualifiedRenderingResourceIdentifier destination);
-
- void didCreateMaskImageBuffer(WebCore::ImageBuffer&);
- void didResetMaskImageBuffer();
-
void populateGetPixelBufferSharedMemory(std::optional<WebCore::PixelBuffer>&&);
bool allowsExitUnderMemoryPressure() const;
@@ -98,47 +86,22 @@
// Runs Function in RemoteRenderingBackend task queue.
void dispatch(Function<void()>&&);
- RemoteRenderingBackendState lastKnownState() const;
-
+ IPC::StreamServerConnection& streamConnection() const { return m_streamConnection.get(); }
void performWithMediaPlayerOnMainThread(WebCore::MediaPlayerIdentifier, Function<void(WebCore::MediaPlayer&)>&&);
private:
- RemoteRenderingBackend(GPUConnectionToWebProcess&, RemoteRenderingBackendCreationParameters&&);
+ RemoteRenderingBackend(GPUConnectionToWebProcess&, RemoteRenderingBackendCreationParameters&&, IPC::StreamConnectionBuffer&&);
void startListeningForIPC();
- std::optional<WebCore::DisplayList::ItemHandle> WARN_UNUSED_RETURN decodeItem(const uint8_t* data, size_t length, WebCore::DisplayList::ItemType, uint8_t* handleLocation) override;
-
- template<typename T>
- std::optional<WebCore::DisplayList::ItemHandle> WARN_UNUSED_RETURN decodeAndCreate(const uint8_t* data, size_t length, uint8_t* handleLocation)
- {
- if (auto item = IPC::Decoder::decodeSingleObject<T>(data, length)) {
- // FIXME: WebKit2 should not need to know that the first 8 bytes at the handle are reserved for the type.
- // Need to figure out a way to keep this knowledge within display list code in WebCore.
- new (handleLocation + sizeof(uint64_t)) T(WTFMove(*item));
- return {{ handleLocation }};
- }
- return std::nullopt;
- }
-
- WebCore::DisplayList::ReplayResult submit(const WebCore::DisplayList::DisplayList&, WebCore::ImageBuffer& destination);
- RefPtr<WebCore::ImageBuffer> nextDestinationImageBufferAfterApplyingDisplayLists(WebCore::ImageBuffer& initialDestination, size_t initialOffset, DisplayListReaderHandle&, GPUProcessWakeupReason, WebCore::ProcessIdentifier webProcessIdentifier);
-
std::optional<SharedMemory::IPCHandle> updateSharedMemoryForGetPixelBufferHelper(size_t byteCount);
void updateRenderingResourceRequest();
- void updateLastKnownState(RemoteRenderingBackendState);
-
// IPC::MessageSender.
IPC::Connection* messageSenderConnection() const override;
uint64_t messageSenderDestinationID() const override;
- // IPC::MessageReceiver
- void didReceiveMessage(IPC::Connection&, IPC::Decoder&) override;
- bool didReceiveSyncMessage(IPC::Connection&, IPC::Decoder&, UniqueRef<IPC::Encoder>&) override;
-
// Messages to be received.
void createImageBuffer(const WebCore::FloatSize& logicalSize, WebCore::RenderingMode, float resolutionScale, const WebCore::DestinationColorSpace&, WebCore::PixelFormat, WebCore::RenderingResourceIdentifier);
- void wakeUpAndApplyDisplayList(const GPUProcessWakeupMessageArguments&);
void updateSharedMemoryForGetPixelBuffer(uint32_t byteCount, CompletionHandler<void(const SharedMemory::IPCHandle&)>&&);
void semaphoreForGetPixelBuffer(CompletionHandler<void(const IPC::Semaphore&)>&&);
void updateSharedMemoryAndSemaphoreForGetPixelBuffer(uint32_t byteCount, CompletionHandler<void(const SharedMemory::IPCHandle&, const IPC::Semaphore&)>&&);
@@ -151,10 +114,8 @@
void deleteAllFonts();
void releaseRemoteResource(WebCore::RenderingResourceIdentifier, uint64_t useCount);
void finalizeRenderingUpdate(RenderingUpdateID);
- void didCreateSharedDisplayListHandle(WebCore::DisplayList::ItemBufferIdentifier, const SharedMemory::IPCHandle&, WebCore::RenderingResourceIdentifier destinationBufferIdentifier);
// Received messages translated to use QualifiedRenderingResourceIdentifier.
- void wakeUpAndApplyDisplayListWithQualifiedIdentifier(WebCore::DisplayList::ItemBufferIdentifier, uint64_t offset, QualifiedRenderingResourceIdentifier, GPUProcessWakeupReason);
void createImageBufferWithQualifiedIdentifier(const WebCore::FloatSize& logicalSize, WebCore::RenderingMode, float resolutionScale, const WebCore::DestinationColorSpace&, WebCore::PixelFormat, QualifiedRenderingResourceIdentifier);
void getDataURLForImageBufferWithQualifiedIdentifier(const String& mimeType, std::optional<double> quality, WebCore::PreserveResolution, QualifiedRenderingResourceIdentifier, CompletionHandler<void(String&&)>&&);
void getDataForImageBufferWithQualifiedIdentifier(const String& mimeType, std::optional<double> quality, QualifiedRenderingResourceIdentifier, CompletionHandler<void(Vector<uint8_t>&&)>&&);
@@ -164,55 +125,15 @@
void releaseRemoteResourceWithQualifiedIdentifier(QualifiedRenderingResourceIdentifier, uint64_t useCount);
void cacheFontWithQualifiedIdentifier(Ref<WebCore::Font>&&, QualifiedRenderingResourceIdentifier);
- void resumeFromPendingWakeupInformation();
-
- class ReplayerDelegate : public WebCore::DisplayList::Replayer::Delegate {
- public:
- ReplayerDelegate(WebCore::ImageBuffer&, RemoteRenderingBackend&, WebCore::ProcessIdentifier webProcessIdentifier);
-
- private:
- bool apply(WebCore::DisplayList::ItemHandle, WebCore::GraphicsContext&) final;
- void didCreateMaskImageBuffer(WebCore::ImageBuffer&) final;
- void didResetMaskImageBuffer() final;
- void recordResourceUse(WebCore::RenderingResourceIdentifier) final;
-
- WebCore::ImageBuffer& m_destination;
- RemoteRenderingBackend& m_remoteRenderingBackend;
- WebCore::ProcessIdentifier m_webProcessIdentifier;
- };
-
- struct PendingWakeupInformation {
- WebCore::DisplayList::ItemBufferIdentifier itemBufferIdentifier;
- uint64_t offset { 0 };
- QualifiedRenderingResourceIdentifier destinationImageBufferIdentifier;
- GPUProcessWakeupReason reason { GPUProcessWakeupReason::Unspecified };
- std::optional<QualifiedRenderingResourceIdentifier> missingCachedResourceIdentifier;
- RemoteRenderingBackendState state { RemoteRenderingBackendState::Initialized };
-
- bool shouldPerformWakeup(QualifiedRenderingResourceIdentifier identifier) const
- {
- return destinationImageBufferIdentifier == identifier
- || missingCachedResourceIdentifier == identifier;
- }
-
- bool shouldPerformWakeup(WebCore::DisplayList::ItemBufferIdentifier identifier) const
- {
- return itemBufferIdentifier == identifier;
- }
- };
-
- Ref<WorkQueue> m_workQueue;
+ IPC::StreamConnectionWorkQueue m_workQueue;
+ Ref<IPC::StreamServerConnection> m_streamConnection;
RemoteResourceCache m_remoteResourceCache;
Ref<GPUConnectionToWebProcess> m_gpuConnectionToWebProcess;
RenderingBackendIdentifier m_renderingBackendIdentifier;
- HashMap<WebCore::DisplayList::ItemBufferIdentifier, RefPtr<DisplayListReaderHandle>> m_sharedDisplayListHandles;
- std::optional<PendingWakeupInformation> m_pendingWakeupInfo;
- IPC::Semaphore m_resumeDisplayListSemaphore;
IPC::Semaphore m_getPixelBufferSemaphore;
RefPtr<SharedMemory> m_getPixelBufferSharedMemory;
ScopedRenderingResourcesRequest m_renderingResourcesRequest;
- RefPtr<WebCore::ImageBuffer> m_currentMaskImageBuffer;
- Atomic<RemoteRenderingBackendState> m_lastKnownState { RemoteRenderingBackendState::Initialized };
+ WeakHashSet<RemoteDisplayListRecorder> m_remoteDisplayLists;
};
} // namespace WebKit
Modified: trunk/Source/WebKit/GPUProcess/graphics/RemoteRenderingBackend.messages.in (284078 => 284079)
--- trunk/Source/WebKit/GPUProcess/graphics/RemoteRenderingBackend.messages.in 2021-10-13 05:44:42 UTC (rev 284078)
+++ trunk/Source/WebKit/GPUProcess/graphics/RemoteRenderingBackend.messages.in 2021-10-13 05:50:33 UTC (rev 284079)
@@ -22,20 +22,18 @@
#if ENABLE(GPU_PROCESS)
-messages -> RemoteRenderingBackend {
+messages -> RemoteRenderingBackend NotRefCounted Stream {
CreateImageBuffer(WebCore::FloatSize logicalSize, WebCore::RenderingMode renderingMode, float resolutionScale, WebCore::DestinationColorSpace colorSpace, enum:uint8_t WebCore::PixelFormat pixelFormat, WebCore::RenderingResourceIdentifier renderingResourceIdentifier)
- WakeUpAndApplyDisplayList(struct WebKit::GPUProcessWakeupMessageArguments arguments)
- UpdateSharedMemoryForGetPixelBuffer(uint32_t byteCount) -> (WebKit::SharedMemory::IPCHandle handle) Synchronous
- SemaphoreForGetPixelBuffer() -> (IPC::Semaphore semaphore) Synchronous
- UpdateSharedMemoryAndSemaphoreForGetPixelBuffer(uint32_t byteCount) -> (WebKit::SharedMemory::IPCHandle handle, IPC::Semaphore semaphore) Synchronous
+ UpdateSharedMemoryForGetPixelBuffer(uint32_t byteCount) -> (WebKit::SharedMemory::IPCHandle handle) Synchronous NotStreamEncodableReply
+ SemaphoreForGetPixelBuffer() -> (IPC::Semaphore semaphore) Synchronous NotStreamEncodableReply
+ UpdateSharedMemoryAndSemaphoreForGetPixelBuffer(uint32_t byteCount) -> (WebKit::SharedMemory::IPCHandle handle, IPC::Semaphore semaphore) Synchronous NotStreamEncodableReply
DestroyGetPixelBufferSharedMemory()
GetDataURLForImageBuffer(String mimeType, std::optional<double> quality, enum:uint8_t WebCore::PreserveResolution preserveResolution, WebCore::RenderingResourceIdentifier renderingResourceIdentifier) -> (String urlString) Synchronous
GetDataForImageBuffer(String mimeType, std::optional<double> quality, WebCore::RenderingResourceIdentifier renderingResourceIdentifier) -> (Vector<uint8_t> data) Synchronous
- GetShareableBitmapForImageBuffer(WebCore::RenderingResourceIdentifier imageBuffer, enum:uint8_t WebCore::PreserveResolution preserveResolution) -> (WebKit::ShareableBitmap::Handle handle) Synchronous
- CacheNativeImage(WebKit::ShareableBitmap::Handle handle, WebCore::RenderingResourceIdentifier renderingResourceIdentifier)
- CacheFont(IPC::FontReference font)
+ GetShareableBitmapForImageBuffer(WebCore::RenderingResourceIdentifier imageBuffer, enum:uint8_t WebCore::PreserveResolution preserveResolution) -> (WebKit::ShareableBitmap::Handle handle) Synchronous NotStreamEncodableReply
+ CacheNativeImage(WebKit::ShareableBitmap::Handle handle, WebCore::RenderingResourceIdentifier renderingResourceIdentifier) NotStreamEncodable
+ CacheFont(IPC::FontReference font) NotStreamEncodable
DeleteAllFonts()
- DidCreateSharedDisplayListHandle(WebCore::DisplayList::ItemBufferIdentifier identifier, WebKit::SharedMemory::IPCHandle handle, WebCore::RenderingResourceIdentifier destinationBufferIdentifier)
ReleaseRemoteResource(WebCore::RenderingResourceIdentifier renderingResourceIdentifier, uint64_t useCount)
FinalizeRenderingUpdate(WebKit::RenderingUpdateID renderingUpdateID)
}
Modified: trunk/Source/WebKit/GPUProcess/graphics/RemoteRenderingBackendCreationParameters.h (284078 => 284079)
--- trunk/Source/WebKit/GPUProcess/graphics/RemoteRenderingBackendCreationParameters.h 2021-10-13 05:44:42 UTC (rev 284078)
+++ trunk/Source/WebKit/GPUProcess/graphics/RemoteRenderingBackendCreationParameters.h 2021-10-13 05:50:33 UTC (rev 284079)
@@ -36,13 +36,12 @@
struct RemoteRenderingBackendCreationParameters {
RenderingBackendIdentifier identifier;
- IPC::Semaphore resumeDisplayListSemaphore;
WebPageProxyIdentifier pageProxyID;
WebCore::PageIdentifier pageID;
void encode(IPC::Encoder& encoder) const
{
- encoder << identifier << resumeDisplayListSemaphore << pageProxyID << pageID;
+ encoder << identifier << pageProxyID << pageID;
}
static std::optional<RemoteRenderingBackendCreationParameters> decode(IPC::Decoder& decoder)
@@ -52,11 +51,6 @@
if (!identifier)
return std::nullopt;
- std::optional<IPC::Semaphore> resumeDisplayListSemaphore;
- decoder >> resumeDisplayListSemaphore;
- if (!resumeDisplayListSemaphore)
- return std::nullopt;
-
std::optional<WebPageProxyIdentifier> pageProxyID;
decoder >> pageProxyID;
if (!pageProxyID)
@@ -67,7 +61,7 @@
if (!pageID)
return std::nullopt;
- return {{ *identifier, WTFMove(*resumeDisplayListSemaphore), *pageProxyID, *pageID }};
+ return { { *identifier, *pageProxyID, *pageID } };
}
};
Modified: trunk/Source/WebKit/GPUProcess/mac/com.apple.WebKit.GPUProcess.sb.in (284078 => 284079)
--- trunk/Source/WebKit/GPUProcess/mac/com.apple.WebKit.GPUProcess.sb.in 2021-10-13 05:44:42 UTC (rev 284078)
+++ trunk/Source/WebKit/GPUProcess/mac/com.apple.WebKit.GPUProcess.sb.in 2021-10-13 05:50:33 UTC (rev 284079)
@@ -742,9 +742,7 @@
(allow mach-lookup
(global-name "com.apple.audio.audiohald")
(global-name "com.apple.CARenderServer") ; Needed for [CAContext remoteContextWithOptions]
-#if __MAC_OS_X_VERSION_MIN_REQUIRED < 120000
(global-name "com.apple.lsd.mapdb")
-#endif
(global-name "com.apple.fonts")
(global-name "com.apple.PowerManagement.control")
(global-name "com.apple.trustd.agent")
Modified: trunk/Source/WebKit/WebProcess/GPU/graphics/RemoteImageBufferProxy.h (284078 => 284079)
--- trunk/Source/WebKit/WebProcess/GPU/graphics/RemoteImageBufferProxy.h 2021-10-13 05:44:42 UTC (rev 284078)
+++ trunk/Source/WebKit/WebProcess/GPU/graphics/RemoteImageBufferProxy.h 2021-10-13 05:50:33 UTC (rev 284079)
@@ -29,13 +29,13 @@
#include "Encoder.h"
#include "Logging.h"
+#include "RemoteDisplayListRecorderProxy.h"
+#include "RemoteRenderingBackendMessages.h"
#include "RemoteRenderingBackendProxy.h"
#include "SharedMemory.h"
+#include <WebCore/ConcreteImageBuffer.h>
#include <WebCore/DisplayList.h>
-#include <WebCore/DisplayListImageBuffer.h>
#include <WebCore/DisplayListItems.h>
-#include <WebCore/DisplayListRecorder.h>
-#include <WebCore/DisplayListReplayer.h>
#include <WebCore/MIMETypeRegistry.h>
#include <wtf/Condition.h>
#include <wtf/Lock.h>
@@ -47,12 +47,11 @@
template<typename BackendType> class ThreadSafeRemoteImageBufferFlusher;
template<typename BackendType>
-class RemoteImageBufferProxy : public WebCore::DisplayList::ImageBuffer<BackendType>, public WebCore::DisplayList::RecorderImpl::Delegate, public WebCore::DisplayList::ItemBufferWritingClient {
- using BaseDisplayListImageBuffer = WebCore::DisplayList::ImageBuffer<BackendType>;
- using BaseDisplayListImageBuffer::m_backend;
- using BaseDisplayListImageBuffer::m_drawingContext;
- using BaseDisplayListImageBuffer::m_renderingResourceIdentifier;
- using BaseDisplayListImageBuffer::resolutionScale;
+class RemoteImageBufferProxy : public WebCore::ConcreteImageBuffer<BackendType> {
+ using BaseConcreteImageBuffer = WebCore::ConcreteImageBuffer<BackendType>;
+ using BaseConcreteImageBuffer::m_backend;
+ using BaseConcreteImageBuffer::m_renderingResourceIdentifier;
+ using BaseConcreteImageBuffer::resolutionScale;
public:
static RefPtr<RemoteImageBufferProxy> create(const WebCore::FloatSize& size, float resolutionScale, const WebCore::DestinationColorSpace& colorSpace, WebCore::PixelFormat pixelFormat, RemoteRenderingBackendProxy& remoteRenderingBackendProxy)
@@ -66,7 +65,7 @@
~RemoteImageBufferProxy()
{
if (!m_remoteRenderingBackendProxy || m_remoteRenderingBackendProxy->isGPUProcessConnectionClosed()) {
- clearDisplayList();
+ m_remoteDisplayList.resetNeedsFlush();
return;
}
@@ -98,19 +97,14 @@
protected:
RemoteImageBufferProxy(const WebCore::ImageBufferBackend::Parameters& parameters, RemoteRenderingBackendProxy& remoteRenderingBackendProxy)
- : BaseDisplayListImageBuffer(parameters, this)
+ : BaseConcreteImageBuffer(parameters)
, m_remoteRenderingBackendProxy(makeWeakPtr(remoteRenderingBackendProxy))
+ , m_remoteDisplayList(*this, remoteRenderingBackendProxy, { { }, BaseConcreteImageBuffer::logicalSize() }, BaseConcreteImageBuffer::baseTransform())
{
ASSERT(m_remoteRenderingBackendProxy);
m_remoteRenderingBackendProxy->remoteResourceCacheProxy().cacheImageBuffer(*this);
-
- m_drawingContext.displayList().setItemBufferWritingClient(this);
- m_drawingContext.displayList().setItemBufferReadingClient(nullptr);
- m_drawingContext.displayList().setTracksDrawingItemExtents(false);
}
- WebCore::RenderingMode renderingMode() const final { return BaseDisplayListImageBuffer::renderingMode(); }
-
// It is safe to access m_receivedFlushIdentifier from the main thread without locking since it
// only gets modified on the main thread.
bool hasPendingFlush() const WTF_IGNORES_THREAD_SAFETY_ANALYSIS
@@ -219,7 +213,7 @@
return std::nullopt;
auto& mutableThis = const_cast<RemoteImageBufferProxy&>(*this);
- mutableThis.m_drawingContext.recorder().getPixelBuffer(destinationFormat, srcRect);
+ mutableThis.m_remoteDisplayList.getPixelBuffer(destinationFormat, srcRect);
mutableThis.flushDrawingContextAsync();
if (m_remoteRenderingBackendProxy->waitForGetPixelBufferToComplete(timeout))
@@ -229,12 +223,28 @@
return pixelBuffer;
}
+ void clearBackend() final
+ {
+ m_remoteDisplayList.resetNeedsFlush();
+ BaseConcreteImageBuffer::clearBackend();
+ }
+
+ WebCore::GraphicsContext& context() const final
+ {
+ return const_cast<RemoteImageBufferProxy*>(this)->m_remoteDisplayList;
+ }
+
+ WebCore::GraphicsContext* drawingContext() final
+ {
+ return &m_remoteDisplayList;
+ }
+
void putPixelBuffer(const WebCore::PixelBuffer& pixelBuffer, const WebCore::IntRect& srcRect, const WebCore::IntPoint& destPoint = { }, WebCore::AlphaPremultiplication destFormat = WebCore::AlphaPremultiplication::Premultiplied) final
{
// The math inside PixelBuffer::create() doesn't agree with the math inside ImageBufferBackend::putPixelBuffer() about how m_resolutionScale interacts with the data in the ImageBuffer.
// This means that putPixelBuffer() is only called when resolutionScale() == 1.
ASSERT(resolutionScale() == 1);
- m_drawingContext.recorder().putPixelBuffer(pixelBuffer, srcRect, destPoint, destFormat);
+ m_remoteDisplayList.putPixelBuffer(pixelBuffer, srcRect, destPoint, destFormat);
}
bool prefersPreparationForDisplay() final { return true; }
@@ -260,94 +270,32 @@
if (UNLIKELY(!m_remoteRenderingBackendProxy))
return;
- if (!m_drawingContext.displayList().isEmpty() || !hasPendingFlush()) {
+ if (m_remoteDisplayList.needsFlush() || !hasPendingFlush()) {
m_sentFlushIdentifier = WebCore::GraphicsContextFlushIdentifier::generate();
- m_drawingContext.recorder().flushContext(m_sentFlushIdentifier);
+ m_remoteDisplayList.flushContext(m_sentFlushIdentifier);
}
- m_remoteRenderingBackendProxy->sendDeferredWakeupMessageIfNeeded();
- clearDisplayList();
+ m_remoteDisplayList.resetNeedsFlush();
}
- void recordNativeImageUse(WebCore::NativeImage& image) final
+ void recordNativeImageUse(WebCore::NativeImage& image)
{
if (m_remoteRenderingBackendProxy)
m_remoteRenderingBackendProxy->remoteResourceCacheProxy().recordNativeImageUse(image);
}
- bool isCachedImageBuffer(const WebCore::ImageBuffer& imageBuffer) const final
+ void recordFontUse(WebCore::Font& font)
{
- if (!m_remoteRenderingBackendProxy)
- return false;
- auto cachedImageBuffer = m_remoteRenderingBackendProxy->remoteResourceCacheProxy().cachedImageBuffer(imageBuffer.renderingResourceIdentifier());
- ASSERT(!cachedImageBuffer || cachedImageBuffer == &imageBuffer);
- return cachedImageBuffer;
- }
-
- void changeDestinationImageBuffer(WebCore::RenderingResourceIdentifier nextImageBuffer) final
- {
- bool wasEmpty = m_drawingContext.displayList().isEmpty();
- m_drawingContext.displayList().template append<WebCore::DisplayList::MetaCommandChangeDestinationImageBuffer>(nextImageBuffer);
- if (wasEmpty)
- clearDisplayList();
- }
-
- void prepareToAppendDisplayListItems(WebCore::DisplayList::ItemBufferHandle&& handle) final
- {
- m_drawingContext.displayList().prepareToAppend(WTFMove(handle));
- }
-
- void clearDisplayList()
- {
- m_drawingContext.displayList().clear();
- }
-
- bool canAppendItemOfType(WebCore::DisplayList::ItemType) final
- {
- if (UNLIKELY(!m_remoteRenderingBackendProxy))
- return false;
- m_remoteRenderingBackendProxy->willAppendItem(m_renderingResourceIdentifier);
- return true;
- }
-
- void didAppendData(const WebCore::DisplayList::ItemBufferHandle& handle, size_t numberOfBytes, WebCore::DisplayList::DidChangeItemBuffer didChangeItemBuffer) final
- {
- if (LIKELY(m_remoteRenderingBackendProxy))
- m_remoteRenderingBackendProxy->didAppendData(handle, numberOfBytes, didChangeItemBuffer, m_renderingResourceIdentifier);
- }
-
- void recordFontUse(WebCore::Font& font) final
- {
if (m_remoteRenderingBackendProxy)
m_remoteRenderingBackendProxy->remoteResourceCacheProxy().recordFontUse(font);
}
- void recordImageBufferUse(WebCore::ImageBuffer& imageBuffer) final
+ void recordImageBufferUse(WebCore::ImageBuffer& imageBuffer)
{
if (m_remoteRenderingBackendProxy)
m_remoteRenderingBackendProxy->remoteResourceCacheProxy().recordImageBufferUse(imageBuffer);
}
- WebCore::DisplayList::ItemBufferHandle createItemBuffer(size_t capacity) final
- {
- if (LIKELY(m_remoteRenderingBackendProxy))
- return m_remoteRenderingBackendProxy->createItemBuffer(capacity, m_renderingResourceIdentifier);
-
- ASSERT_NOT_REACHED();
- return { };
- }
-
- RefPtr<WebCore::SharedBuffer> encodeItemOutOfLine(const WebCore::DisplayList::DisplayListItem& item) const final
- {
- return std::visit([](const auto& displayListItem) -> RefPtr<WebCore::SharedBuffer> {
- using DisplayListItemType = typename WTF::RemoveCVAndReference<decltype(displayListItem)>::type;
- if constexpr (!DisplayListItemType::isInlineItem)
- return IPC::Encoder::encodeSingleObject<DisplayListItemType>(displayListItem);
- RELEASE_ASSERT_NOT_REACHED();
- return nullptr;
- }, item);
- }
-
std::unique_ptr<WebCore::ThreadSafeImageBufferFlusher> createFlusher() final
{
return WTF::makeUnique<ThreadSafeRemoteImageBufferFlusher<BackendType>>(*this);
@@ -358,6 +306,7 @@
Condition m_receivedFlushIdentifierChangedCondition;
WebCore::GraphicsContextFlushIdentifier m_receivedFlushIdentifier WTF_GUARDED_BY_LOCK(m_receivedFlushIdentifierLock); // Only modified on the main thread but may get queried on a secondary thread.
WeakPtr<RemoteRenderingBackendProxy> m_remoteRenderingBackendProxy;
+ RemoteDisplayListRecorderProxy m_remoteDisplayList;
};
template<typename BackendType>
Modified: trunk/Source/WebKit/WebProcess/GPU/graphics/RemoteRenderingBackendProxy.cpp (284078 => 284079)
--- trunk/Source/WebKit/WebProcess/GPU/graphics/RemoteRenderingBackendProxy.cpp 2021-10-13 05:44:42 UTC (rev 284078)
+++ trunk/Source/WebKit/WebProcess/GPU/graphics/RemoteRenderingBackendProxy.cpp 2021-10-13 05:50:33 UTC (rev 284079)
@@ -28,7 +28,6 @@
#if ENABLE(GPU_PROCESS)
-#include "DisplayListWriterHandle.h"
#include "GPUConnectionToWebProcess.h"
#include "Logging.h"
#include "PlatformRemoteImageBufferProxy.h"
@@ -52,7 +51,6 @@
RemoteRenderingBackendProxy::RemoteRenderingBackendProxy(WebPage& webPage)
: m_parameters {
RenderingBackendIdentifier::generate(),
- IPC::Semaphore { },
webPage.webPageProxyIdentifier(),
webPage.identifier()
}
@@ -77,7 +75,9 @@
auto& gpuProcessConnection = WebProcess::singleton().ensureGPUProcessConnection();
gpuProcessConnection.addClient(*this);
gpuProcessConnection.messageReceiverMap().addMessageReceiver(Messages::RemoteRenderingBackendProxy::messageReceiverName(), renderingBackendIdentifier().toUInt64(), *this);
- gpuProcessConnection.connection().send(Messages::GPUConnectionToWebProcess::CreateRenderingBackend(m_parameters), 0, IPC::SendOption::DispatchMessageEvenWhenWaitingForSyncReply);
+ static constexpr auto connectionBufferSize = 1 << 21;
+ m_streamConnection = makeUnique<IPC::StreamClientConnection>(gpuProcessConnection.connection(), connectionBufferSize);
+ gpuProcessConnection.connection().send(Messages::GPUConnectionToWebProcess::CreateRenderingBackend(m_parameters, m_streamConnection->streamBuffer()), 0, IPC::SendOption::DispatchMessageEvenWhenWaitingForSyncReply);
m_gpuProcessConnection = makeWeakPtr(gpuProcessConnection);
}
return *m_gpuProcessConnection;
@@ -91,12 +91,6 @@
m_remoteResourceCacheProxy.remoteResourceCacheWasDestroyed();
- m_identifiersOfReusableHandles.clear();
- m_sharedDisplayListHandles.clear();
- m_currentDestinationImageBufferIdentifier = std::nullopt;
- m_deferredWakeupMessageArguments = std::nullopt;
- m_remainingItemsToAppendBeforeSendingWakeup = 0;
-
if (m_destroyGetPixelBufferSharedMemoryTimer.isActive())
m_destroyGetPixelBufferSharedMemoryTimer.stop();
m_getPixelBufferSemaphore = std::nullopt;
@@ -133,7 +127,7 @@
void RemoteRenderingBackendProxy::createRemoteImageBuffer(ImageBuffer& imageBuffer)
{
- send(Messages::RemoteRenderingBackend::CreateImageBuffer(imageBuffer.logicalSize(), imageBuffer.renderingMode(), imageBuffer.resolutionScale(), imageBuffer.colorSpace(), imageBuffer.pixelFormat(), imageBuffer.renderingResourceIdentifier()), renderingBackendIdentifier(), IPC::SendOption::DispatchMessageEvenWhenWaitingForSyncReply);
+ sendToStream(Messages::RemoteRenderingBackend::CreateImageBuffer(imageBuffer.logicalSize(), imageBuffer.renderingMode(), imageBuffer.resolutionScale(), imageBuffer.colorSpace(), imageBuffer.pixelFormat(), imageBuffer.renderingResourceIdentifier()));
}
RefPtr<ImageBuffer> RemoteRenderingBackendProxy::createImageBuffer(const FloatSize& size, RenderingMode renderingMode, float resolutionScale, const DestinationColorSpace& colorSpace, PixelFormat pixelFormat)
@@ -163,8 +157,6 @@
SharedMemory* RemoteRenderingBackendProxy::sharedMemoryForGetPixelBuffer(size_t dataSize, IPC::Timeout timeout)
{
- sendDeferredWakeupMessageIfNeeded();
-
bool needsSharedMemory = !m_getPixelBufferSharedMemory || dataSize > m_getPixelBufferSharedMemoryLength;
bool needsSemaphore = !m_getPixelBufferSemaphore;
@@ -175,11 +167,11 @@
IPC::Semaphore semaphore;
if (needsSharedMemory && needsSemaphore)
- sendSync(Messages::RemoteRenderingBackend::UpdateSharedMemoryAndSemaphoreForGetPixelBuffer(dataSize), Messages::RemoteRenderingBackend::UpdateSharedMemoryAndSemaphoreForGetPixelBuffer::Reply(handle, semaphore), renderingBackendIdentifier(), timeout, IPC::SendSyncOption::MaintainOrderingWithAsyncMessages);
+ sendSyncToStream(Messages::RemoteRenderingBackend::UpdateSharedMemoryAndSemaphoreForGetPixelBuffer(dataSize), Messages::RemoteRenderingBackend::UpdateSharedMemoryAndSemaphoreForGetPixelBuffer::Reply(handle, semaphore), timeout);
else if (needsSharedMemory)
- sendSync(Messages::RemoteRenderingBackend::UpdateSharedMemoryForGetPixelBuffer(dataSize), Messages::RemoteRenderingBackend::UpdateSharedMemoryForGetPixelBuffer::Reply(handle), renderingBackendIdentifier(), timeout, IPC::SendSyncOption::MaintainOrderingWithAsyncMessages);
+ sendSyncToStream(Messages::RemoteRenderingBackend::UpdateSharedMemoryForGetPixelBuffer(dataSize), Messages::RemoteRenderingBackend::UpdateSharedMemoryForGetPixelBuffer::Reply(handle), timeout);
else if (needsSemaphore)
- sendSync(Messages::RemoteRenderingBackend::SemaphoreForGetPixelBuffer(), Messages::RemoteRenderingBackend::SemaphoreForGetPixelBuffer::Reply(semaphore), renderingBackendIdentifier(), timeout);
+ sendSyncToStream(Messages::RemoteRenderingBackend::SemaphoreForGetPixelBuffer(), Messages::RemoteRenderingBackend::SemaphoreForGetPixelBuffer::Reply(semaphore), timeout);
if (!handle.handle.isNull()) {
m_getPixelBufferSharedMemory = SharedMemory::map(handle.handle, SharedMemory::Protection::ReadOnly);
@@ -204,33 +196,27 @@
void RemoteRenderingBackendProxy::destroyGetPixelBufferSharedMemory()
{
m_getPixelBufferSharedMemory = nullptr;
- send(Messages::RemoteRenderingBackend::DestroyGetPixelBufferSharedMemory(), renderingBackendIdentifier(), IPC::SendOption::DispatchMessageEvenWhenWaitingForSyncReply);
+ sendToStream(Messages::RemoteRenderingBackend::DestroyGetPixelBufferSharedMemory());
}
String RemoteRenderingBackendProxy::getDataURLForImageBuffer(const String& mimeType, std::optional<double> quality, PreserveResolution preserveResolution, RenderingResourceIdentifier renderingResourceIdentifier)
{
- sendDeferredWakeupMessageIfNeeded();
-
String urlString;
- sendSync(Messages::RemoteRenderingBackend::GetDataURLForImageBuffer(mimeType, quality, preserveResolution, renderingResourceIdentifier), Messages::RemoteRenderingBackend::GetDataURLForImageBuffer::Reply(urlString), renderingBackendIdentifier(), 1_s);
+ sendSyncToStream(Messages::RemoteRenderingBackend::GetDataURLForImageBuffer(mimeType, quality, preserveResolution, renderingResourceIdentifier), Messages::RemoteRenderingBackend::GetDataURLForImageBuffer::Reply(urlString), 1_s);
return urlString;
}
Vector<uint8_t> RemoteRenderingBackendProxy::getDataForImageBuffer(const String& mimeType, std::optional<double> quality, RenderingResourceIdentifier renderingResourceIdentifier)
{
- sendDeferredWakeupMessageIfNeeded();
-
Vector<uint8_t> data;
- sendSync(Messages::RemoteRenderingBackend::GetDataForImageBuffer(mimeType, quality, renderingResourceIdentifier), Messages::RemoteRenderingBackend::GetDataForImageBuffer::Reply(data), renderingBackendIdentifier(), 1_s);
+ sendSyncToStream(Messages::RemoteRenderingBackend::GetDataForImageBuffer(mimeType, quality, renderingResourceIdentifier), Messages::RemoteRenderingBackend::GetDataForImageBuffer::Reply(data), 1_s);
return data;
}
RefPtr<ShareableBitmap> RemoteRenderingBackendProxy::getShareableBitmap(RenderingResourceIdentifier imageBuffer, PreserveResolution preserveResolution)
{
- sendDeferredWakeupMessageIfNeeded();
-
ShareableBitmap::Handle handle;
- auto sendResult = sendSync(Messages::RemoteRenderingBackend::GetShareableBitmapForImageBuffer(imageBuffer, preserveResolution), Messages::RemoteRenderingBackend::GetShareableBitmapForImageBuffer::Reply(handle), renderingBackendIdentifier(), 1_s);
+ auto sendResult = sendSyncToStream(Messages::RemoteRenderingBackend::GetShareableBitmapForImageBuffer(imageBuffer, preserveResolution), Messages::RemoteRenderingBackend::GetShareableBitmapForImageBuffer::Reply(handle), 1_s);
if (handle.isNull())
return { };
ASSERT_UNUSED(sendResult, sendResult);
@@ -239,30 +225,27 @@
void RemoteRenderingBackendProxy::cacheNativeImage(const ShareableBitmap::Handle& handle, RenderingResourceIdentifier renderingResourceIdentifier)
{
- send(Messages::RemoteRenderingBackend::CacheNativeImage(handle, renderingResourceIdentifier), renderingBackendIdentifier(), IPC::SendOption::DispatchMessageEvenWhenWaitingForSyncReply);
+ sendToStream(Messages::RemoteRenderingBackend::CacheNativeImage(handle, renderingResourceIdentifier));
}
-void RemoteRenderingBackendProxy::cacheFont(Ref<WebCore::Font>&& font)
+void RemoteRenderingBackendProxy::cacheFont(Ref<Font>&& font)
{
- send(Messages::RemoteRenderingBackend::CacheFont(WTFMove(font)), renderingBackendIdentifier(), IPC::SendOption::DispatchMessageEvenWhenWaitingForSyncReply);
+ sendToStream(Messages::RemoteRenderingBackend::CacheFont(WTFMove(font)));
}
void RemoteRenderingBackendProxy::deleteAllFonts()
{
- send(Messages::RemoteRenderingBackend::DeleteAllFonts(), renderingBackendIdentifier(), IPC::SendOption::DispatchMessageEvenWhenWaitingForSyncReply);
+ sendToStream(Messages::RemoteRenderingBackend::DeleteAllFonts());
}
void RemoteRenderingBackendProxy::releaseRemoteResource(RenderingResourceIdentifier renderingResourceIdentifier, uint64_t useCount)
{
- if (renderingResourceIdentifier == m_currentDestinationImageBufferIdentifier)
- m_currentDestinationImageBufferIdentifier = std::nullopt;
-
- send(Messages::RemoteRenderingBackend::ReleaseRemoteResource(renderingResourceIdentifier, useCount), renderingBackendIdentifier(), IPC::SendOption::DispatchMessageEvenWhenWaitingForSyncReply);
+ sendToStream(Messages::RemoteRenderingBackend::ReleaseRemoteResource(renderingResourceIdentifier, useCount));
}
void RemoteRenderingBackendProxy::finalizeRenderingUpdate()
{
- send(Messages::RemoteRenderingBackend::FinalizeRenderingUpdate(m_renderingUpdateID), renderingBackendIdentifier(), IPC::SendOption::DispatchMessageEvenWhenWaitingForSyncReply);
+ sendToStream(Messages::RemoteRenderingBackend::FinalizeRenderingUpdate(m_renderingUpdateID));
m_remoteResourceCacheProxy.finalizeRenderingUpdate();
m_renderingUpdateID.increment();
}
@@ -293,160 +276,36 @@
m_didRenderingUpdateID = std::min(didRenderingUpdateID, m_renderingUpdateID);
}
-void RemoteRenderingBackendProxy::willAppendItem(RenderingResourceIdentifier newDestinationIdentifier)
+RenderingBackendIdentifier RemoteRenderingBackendProxy::renderingBackendIdentifier() const
{
- if (m_currentDestinationImageBufferIdentifier == newDestinationIdentifier)
- return;
-
- if (auto previousDestinationBufferIdentifier = std::exchange(m_currentDestinationImageBufferIdentifier, newDestinationIdentifier)) {
- if (auto imageBuffer = m_remoteResourceCacheProxy.cachedImageBuffer(*previousDestinationBufferIdentifier))
- imageBuffer->changeDestinationImageBuffer(newDestinationIdentifier);
- else
- ASSERT_NOT_REACHED();
- }
-
- auto handle = mostRecentlyUsedDisplayListHandle();
- if (UNLIKELY(!handle))
- return;
-
- auto newDestination = m_remoteResourceCacheProxy.cachedImageBuffer(newDestinationIdentifier);
- if (UNLIKELY(!newDestination)) {
- ASSERT_NOT_REACHED();
- return;
- }
-
- handle->moveWritableOffsetToStartIfPossible();
- newDestination->prepareToAppendDisplayListItems(handle->createHandle());
+ return m_parameters.identifier;
}
-void RemoteRenderingBackendProxy::sendWakeupMessage(const GPUProcessWakeupMessageArguments& arguments)
+RenderingBackendIdentifier RemoteRenderingBackendProxy::ensureBackendCreated()
{
- LOG_WITH_STREAM(SharedDisplayLists, stream << "Sending wakeup: Items[" << arguments.itemBufferIdentifier << "] => Image(" << arguments.destinationImageBufferIdentifier << ") at " << arguments.offset);
- send(Messages::RemoteRenderingBackend::WakeUpAndApplyDisplayList(arguments), renderingBackendIdentifier(), IPC::SendOption::DispatchMessageEvenWhenWaitingForSyncReply);
+ ensureGPUProcessConnection();
+ return renderingBackendIdentifier();
}
-void RemoteRenderingBackendProxy::sendDeferredWakeupMessageIfNeeded()
+IPC::StreamClientConnection& RemoteRenderingBackendProxy::streamConnection()
{
- auto arguments = std::exchange(m_deferredWakeupMessageArguments, std::nullopt);
- if (!arguments)
- return;
-
- sendWakeupMessage(*arguments);
- m_remainingItemsToAppendBeforeSendingWakeup = 0;
+ ensureGPUProcessConnection();
+ if (UNLIKELY(m_needsWakeUpSemaphoreForDisplayListStream))
+ messageSenderConnection()->waitForAndDispatchImmediately<Messages::RemoteRenderingBackendProxy::DidCreateWakeUpSemaphoreForDisplayListStream>(renderingBackendIdentifier(), 3_s, IPC::WaitForOption::InterruptWaitingIfSyncMessageArrives);
+ return *m_streamConnection;
}
-void RemoteRenderingBackendProxy::didAppendData(const DisplayList::ItemBufferHandle& handle, size_t numberOfBytes, DisplayList::DidChangeItemBuffer didChangeItemBuffer, RenderingResourceIdentifier destinationImageBuffer)
+void RemoteRenderingBackendProxy::didCreateWakeUpSemaphoreForDisplayListStream(IPC::Semaphore&& semaphore)
{
- auto* sharedHandle = m_sharedDisplayListHandles.get(handle.identifier);
- if (UNLIKELY(!sharedHandle))
- RELEASE_ASSERT_NOT_REACHED();
-
- bool wasEmpty = sharedHandle->advance(numberOfBytes) == numberOfBytes;
- if (!wasEmpty || didChangeItemBuffer == DisplayList::DidChangeItemBuffer::Yes) {
- if (m_deferredWakeupMessageArguments) {
- auto imageBuffer = m_remoteResourceCacheProxy.cachedImageBuffer(m_deferredWakeupMessageArguments->destinationImageBufferIdentifier);
- if (imageBuffer && imageBuffer->backend() && sharedHandle->tryToResume({ m_deferredWakeupMessageArguments->offset, m_deferredWakeupMessageArguments->destinationImageBufferIdentifier.toUInt64() })) {
- m_parameters.resumeDisplayListSemaphore.signal();
- m_deferredWakeupMessageArguments = std::nullopt;
- m_remainingItemsToAppendBeforeSendingWakeup = 0;
- } else if (!--m_remainingItemsToAppendBeforeSendingWakeup) {
- m_deferredWakeupMessageArguments->reason = GPUProcessWakeupReason::ItemCountHysteresisExceeded;
- sendWakeupMessage(*std::exchange(m_deferredWakeupMessageArguments, std::nullopt));
- }
- }
+ if (!m_streamConnection) {
+ ASSERT_NOT_REACHED();
return;
}
- sendDeferredWakeupMessageIfNeeded();
-
- auto imageBuffer = m_remoteResourceCacheProxy.cachedImageBuffer(destinationImageBuffer);
- auto offsetToRead = sharedHandle->writableOffset() - numberOfBytes;
- if (imageBuffer && imageBuffer->backend() && sharedHandle->tryToResume({ offsetToRead, destinationImageBuffer.toUInt64() })) {
- m_parameters.resumeDisplayListSemaphore.signal();
- return;
- }
-
- // Instead of sending the wakeup message immediately, wait for some additional data. This gives the
- // web process a "head start", decreasing the likelihood that the GPU process will encounter frequent
- // wakeups when processing a large amount of display list items.
- constexpr unsigned itemCountHysteresisBeforeSendingWakeup = 512;
-
- m_remainingItemsToAppendBeforeSendingWakeup = itemCountHysteresisBeforeSendingWakeup;
- m_deferredWakeupMessageArguments = {{ handle.identifier, offsetToRead, destinationImageBuffer }};
+ m_streamConnection->setWakeUpSemaphore(WTFMove(semaphore));
+ m_needsWakeUpSemaphoreForDisplayListStream = false;
}
-RefPtr<DisplayListWriterHandle> RemoteRenderingBackendProxy::mostRecentlyUsedDisplayListHandle()
-{
- if (UNLIKELY(m_identifiersOfReusableHandles.isEmpty()))
- return nullptr;
-
- return m_sharedDisplayListHandles.get(m_identifiersOfReusableHandles.first());
-}
-
-RefPtr<DisplayListWriterHandle> RemoteRenderingBackendProxy::findReusableDisplayListHandle(size_t capacity)
-{
- auto mostRecentlyUsedHandle = mostRecentlyUsedDisplayListHandle();
- if (UNLIKELY(!mostRecentlyUsedHandle))
- return nullptr;
-
- mostRecentlyUsedHandle->moveWritableOffsetToStartIfPossible();
- if (mostRecentlyUsedHandle->availableCapacity() >= capacity)
- return mostRecentlyUsedHandle;
-
- m_identifiersOfReusableHandles.append(m_identifiersOfReusableHandles.takeFirst());
-
- auto leastRecentlyUsedIdentifier = m_identifiersOfReusableHandles.first();
- if (leastRecentlyUsedIdentifier != mostRecentlyUsedHandle->identifier()) {
- RefPtr handle = m_sharedDisplayListHandles.get(leastRecentlyUsedIdentifier);
- if (handle->moveWritableOffsetToStartIfPossible() && handle->availableCapacity() >= capacity)
- return handle;
- }
-
- return nullptr;
-}
-
-DisplayList::ItemBufferHandle RemoteRenderingBackendProxy::createItemBuffer(size_t capacity, RenderingResourceIdentifier destinationBufferIdentifier)
-{
- if (auto handle = findReusableDisplayListHandle(capacity)) {
- LOG_WITH_STREAM(SharedDisplayLists, stream << "Reusing Items[" << handle->identifier() << "] => Image(" << destinationBufferIdentifier << ") (remaining capacity: " << handle->availableCapacity() << ")");
- return handle->createHandle();
- }
-
- static constexpr size_t defaultSharedItemBufferSize = 1 << 16;
- static_assert(defaultSharedItemBufferSize > SharedDisplayListHandle::headerSize());
-
- auto sharedMemory = SharedMemory::allocate(std::max(defaultSharedItemBufferSize, capacity + SharedDisplayListHandle::headerSize()));
- if (!sharedMemory)
- return { };
-
- SharedMemory::Handle sharedMemoryHandle;
- sharedMemory->createHandle(sharedMemoryHandle, SharedMemory::Protection::ReadWrite);
-
- auto identifier = DisplayList::ItemBufferIdentifier::generate();
- send(Messages::RemoteRenderingBackend::DidCreateSharedDisplayListHandle(identifier, { WTFMove(sharedMemoryHandle), sharedMemory->size() }, destinationBufferIdentifier), renderingBackendIdentifier(), IPC::SendOption::DispatchMessageEvenWhenWaitingForSyncReply);
-
- auto newHandle = DisplayListWriterHandle::create(identifier, sharedMemory.releaseNonNull());
- RELEASE_ASSERT(newHandle, "There must be enough space to create the handle.");
- auto displayListHandle = newHandle->createHandle();
-
- m_identifiersOfReusableHandles.prepend(identifier);
- m_sharedDisplayListHandles.set(identifier, WTFMove(newHandle));
-
- LOG_WITH_STREAM(SharedDisplayLists, stream << "Allocated Items[" << identifier << "] => Image(" << destinationBufferIdentifier << ")");
- return displayListHandle;
-}
-
-RenderingBackendIdentifier RemoteRenderingBackendProxy::renderingBackendIdentifier() const
-{
- return m_parameters.identifier;
-}
-
-RenderingBackendIdentifier RemoteRenderingBackendProxy::ensureBackendCreated()
-{
- ensureGPUProcessConnection();
- return renderingBackendIdentifier();
-}
-
void RemoteRenderingBackendProxy::recordNativeImageUse(NativeImage& image)
{
m_remoteResourceCacheProxy.recordNativeImageUse(image);
Modified: trunk/Source/WebKit/WebProcess/GPU/graphics/RemoteRenderingBackendProxy.h (284078 => 284079)
--- trunk/Source/WebKit/WebProcess/GPU/graphics/RemoteRenderingBackendProxy.h 2021-10-13 05:44:42 UTC (rev 284078)
+++ trunk/Source/WebKit/WebProcess/GPU/graphics/RemoteRenderingBackendProxy.h 2021-10-13 05:50:33 UTC (rev 284079)
@@ -33,11 +33,13 @@
#include "ImageBufferBackendHandle.h"
#include "MessageReceiver.h"
#include "MessageSender.h"
+#include "RemoteDisplayListRecorderMessages.h"
#include "RemoteRenderingBackendCreationParameters.h"
+#include "RemoteRenderingBackendMessages.h"
#include "RemoteResourceCacheProxy.h"
#include "RenderingBackendIdentifier.h"
#include "RenderingUpdateID.h"
-#include <WebCore/DisplayList.h>
+#include "StreamClientConnection.h"
#include <WebCore/RenderingResourceIdentifier.h>
#include <WebCore/Timer.h>
#include <wtf/Deque.h>
@@ -45,11 +47,6 @@
namespace WebCore {
-namespace DisplayList {
-class DisplayList;
-class Item;
-}
-
class DestinationColorSpace;
class FloatSize;
class PixelBuffer;
@@ -61,7 +58,6 @@
namespace WebKit {
-class DisplayListWriterHandle;
class WebPage;
class RemoteRenderingBackendProxy
@@ -77,12 +73,7 @@
using WeakValueType = GPUProcessConnection::Client::WeakValueType;
RemoteResourceCacheProxy& remoteResourceCacheProxy() { return m_remoteResourceCacheProxy; }
- WebCore::DisplayList::ItemBufferHandle createItemBuffer(size_t capacity, WebCore::RenderingResourceIdentifier destinationBufferIdentifier);
- void didAppendData(const WebCore::DisplayList::ItemBufferHandle&, size_t numberOfBytes, WebCore::DisplayList::DidChangeItemBuffer, WebCore::RenderingResourceIdentifier destinationImageBuffer);
- void willAppendItem(WebCore::RenderingResourceIdentifier);
- void sendDeferredWakeupMessageIfNeeded();
-
SharedMemory* sharedMemoryForGetPixelBuffer(size_t dataSize, IPC::Timeout);
bool waitForGetPixelBufferToComplete(IPC::Timeout);
void destroyGetPixelBufferSharedMemory();
@@ -101,7 +92,6 @@
RefPtr<WebCore::ImageBuffer> createImageBuffer(const WebCore::FloatSize&, WebCore::RenderingMode, float resolutionScale, const WebCore::DestinationColorSpace&, WebCore::PixelFormat);
String getDataURLForImageBuffer(const String& mimeType, std::optional<double> quality, WebCore::PreserveResolution, WebCore::RenderingResourceIdentifier);
Vector<uint8_t> getDataForImageBuffer(const String& mimeType, std::optional<double> quality, WebCore::RenderingResourceIdentifier);
- WebCore::GraphicsContextFlushIdentifier flushDisplayListAndCommit(const WebCore::DisplayList::DisplayList&, WebCore::RenderingResourceIdentifier);
RefPtr<ShareableBitmap> getShareableBitmap(WebCore::RenderingResourceIdentifier, WebCore::PreserveResolution);
void cacheNativeImage(const ShareableBitmap::Handle&, WebCore::RenderingResourceIdentifier);
void cacheFont(Ref<WebCore::Font>&&);
@@ -125,10 +115,13 @@
bool isGPUProcessConnectionClosed() const { return !m_gpuProcessConnection; }
+ void didCreateWakeUpSemaphoreForDisplayListStream(IPC::Semaphore&&);
+
template<typename T, typename U>
void sendToStream(T&& message, ObjectIdentifier<U> identifier)
{
- // FIXME: Not yet implemented.
+ // FIXME: We should consider making the send timeout finite.
+ streamConnection().send(WTFMove(message), identifier, Seconds::infinity());
}
template<typename T>
@@ -144,6 +137,14 @@
private:
explicit RemoteRenderingBackendProxy(WebPage&);
+ IPC::StreamClientConnection& streamConnection();
+
+ template<typename T>
+ auto sendSyncToStream(T&& message, typename T::Reply&& reply, IPC::Timeout timeout)
+ {
+ return streamConnection().sendSync(WTFMove(message), WTFMove(reply), renderingBackendIdentifier(), timeout);
+ }
+
// GPUProcessConnection::Client
void gpuProcessConnectionDidClose(GPUProcessConnection&) final;
@@ -154,21 +155,11 @@
void didFlush(WebCore::GraphicsContextFlushIdentifier, WebCore::RenderingResourceIdentifier);
void didFinalizeRenderingUpdate(RenderingUpdateID didRenderingUpdateID);
- RefPtr<DisplayListWriterHandle> mostRecentlyUsedDisplayListHandle();
- RefPtr<DisplayListWriterHandle> findReusableDisplayListHandle(size_t capacity);
-
- void sendWakeupMessage(const GPUProcessWakeupMessageArguments&);
-
+ std::unique_ptr<IPC::StreamClientConnection> m_streamConnection;
RemoteRenderingBackendCreationParameters m_parameters;
WeakPtr<GPUProcessConnection> m_gpuProcessConnection;
RemoteResourceCacheProxy m_remoteResourceCacheProxy { *this };
- HashMap<WebCore::DisplayList::ItemBufferIdentifier, RefPtr<DisplayListWriterHandle>> m_sharedDisplayListHandles;
- Deque<WebCore::DisplayList::ItemBufferIdentifier> m_identifiersOfReusableHandles;
- std::optional<WebCore::RenderingResourceIdentifier> m_currentDestinationImageBufferIdentifier;
- std::optional<GPUProcessWakeupMessageArguments> m_deferredWakeupMessageArguments;
- unsigned m_remainingItemsToAppendBeforeSendingWakeup { 0 };
-
std::optional<IPC::Semaphore> m_getPixelBufferSemaphore;
RefPtr<SharedMemory> m_getPixelBufferSharedMemory;
uint64_t m_getPixelBufferSharedMemoryLength { 0 };
@@ -176,6 +167,8 @@
RenderingUpdateID m_renderingUpdateID;
RenderingUpdateID m_didRenderingUpdateID;
+
+ bool m_needsWakeUpSemaphoreForDisplayListStream { true };
};
} // namespace WebKit
Modified: trunk/Source/WebKit/WebProcess/GPU/graphics/RemoteRenderingBackendProxy.messages.in (284078 => 284079)
--- trunk/Source/WebKit/WebProcess/GPU/graphics/RemoteRenderingBackendProxy.messages.in 2021-10-13 05:44:42 UTC (rev 284078)
+++ trunk/Source/WebKit/WebProcess/GPU/graphics/RemoteRenderingBackendProxy.messages.in 2021-10-13 05:50:33 UTC (rev 284079)
@@ -26,6 +26,7 @@
DidCreateImageBufferBackend(WebKit::ImageBufferBackendHandle handle, WebCore::RenderingResourceIdentifier renderingResourceIdentifier)
DidFlush(WebCore::GraphicsContextFlushIdentifier flushIdentifier, WebCore::RenderingResourceIdentifier renderingResourceIdentifier)
DidFinalizeRenderingUpdate(WebKit::RenderingUpdateID didRenderingUpdateID)
+ DidCreateWakeUpSemaphoreForDisplayListStream(IPC::Semaphore wakeUpSemaphore)
}
#endif // ENABLE(GPU_PROCESS)
Modified: trunk/Source/WebKit/WebProcess/WebPage/IPCTestingAPI.cpp (284078 => 284079)
--- trunk/Source/WebKit/WebProcess/WebPage/IPCTestingAPI.cpp 2021-10-13 05:44:42 UTC (rev 284078)
+++ trunk/Source/WebKit/WebProcess/WebPage/IPCTestingAPI.cpp 2021-10-13 05:50:33 UTC (rev 284079)
@@ -761,13 +761,6 @@
if (!identifier)
return false;
- auto jsSemaphore = jsObject->get(globalObject, JSC::Identifier::fromString(globalObject->vm(), "semaphore"_s));
- if (scope.exception())
- return false;
- RefPtr semaphoreObject = JSIPCSemaphore::toWrapped(toRef(globalObject), toRef(jsSemaphore));
- if (!semaphoreObject)
- return false;
-
auto pageProxyID = getObjectIdentifierFromProperty<WebPageProxyIdentifierType>(globalObject, jsObject, "pageProxyID"_s, scope);
if (!pageProxyID)
return false;
@@ -776,10 +769,8 @@
if (!pageID)
return false;
- auto semaphore = semaphoreObject->exchange();
- RemoteRenderingBackendCreationParameters parameters { *identifier, WTFMove(semaphore), *pageProxyID, *pageID };
+ RemoteRenderingBackendCreationParameters parameters { *identifier, *pageProxyID, *pageID };
encoder << parameters;
- semaphoreObject->exchange(WTFMove(parameters.resumeDisplayListSemaphore));
return true;
}
#endif
