Changeset 292282 in webkit

Timestamp:

Apr 4, 2022, 12:53:56 AM (4 years ago)

Author:

commit-queue@webkit.org

Message:

StreamClientConnection should have waitForAndDispatchImmediately
​https://bugs.webkit.org/show_bug.cgi?id=238622

Patch by Kimmo Kinnunen <​kkinnunen@apple.com> on 2022-04-04
Reviewed by Simon Fraser.

IPC::StreamClientConnection should have the same communication methods
as the IPC::Connection. The stream connection will forward
the calls to underlying IPC::Connection, if needed.
Add missing IPC::StreamClientConnection::waitForAndDispatchImmediately()
and use it.
Remove conveinence accessor methods for the IPC::Connection, as that should be
accessed by accessing the stream connection in the respective classes.

No new tests, refactor.

• Platform/IPC/StreamClientConnection.h:

(IPC::StreamClientConnection::waitForAndDispatchImmediately):

• WebProcess/GPU/graphics/RemoteGraphicsContextGLProxy.cpp:

(WebKit::RemoteGraphicsContextGLProxy::RemoteGraphicsContextGLProxy):
(WebKit::RemoteGraphicsContextGLProxy::waitUntilInitialized):

• WebProcess/GPU/graphics/RemoteGraphicsContextGLProxy.h:

(WebKit::RemoteGraphicsContextGLProxy::sendSync):

• WebProcess/GPU/graphics/RemoteRenderingBackendProxy.cpp:

(WebKit::RemoteRenderingBackendProxy::waitForDidCreateImageBufferBackend):
(WebKit::RemoteRenderingBackendProxy::waitForDidFlush):
(WebKit::RemoteRenderingBackendProxy::streamConnection):

• WebProcess/GPU/graphics/RemoteRenderingBackendProxy.h:
• WebProcess/GPU/graphics/WebGPU/RemoteGPUProxy.cpp:

(WebKit::RemoteGPUProxy::RemoteGPUProxy):
(WebKit::RemoteGPUProxy::waitUntilInitialized):

Location:

trunk/Source/WebKit

Files:

• ChangeLog (modified) (1 diff)
• Platform/IPC/StreamClientConnection.h (modified) (2 diffs)
• WebProcess/GPU/graphics/RemoteGraphicsContextGLProxy.cpp (modified) (2 diffs)
• WebProcess/GPU/graphics/RemoteGraphicsContextGLProxy.h (modified) (1 diff)
• WebProcess/GPU/graphics/RemoteRenderingBackendProxy.cpp (modified) (4 diffs)
• WebProcess/GPU/graphics/RemoteRenderingBackendProxy.h (modified) (1 diff)
• WebProcess/GPU/graphics/WebGPU/RemoteGPUProxy.cpp (modified) (2 diffs)

trunk/Source/WebKit/ChangeLog

@@ +1 @@
+2022-04-04  Kimmo Kinnunen  <kkinnunen@apple.com>
+
+        StreamClientConnection should have waitForAndDispatchImmediately
+        https://bugs.webkit.org/show_bug.cgi?id=238622
+
+        Reviewed by Simon Fraser.
+
+        IPC::StreamClientConnection should have the same communication methods
+        as the IPC::Connection. The stream connection will forward
+        the calls to underlying IPC::Connection, if needed.
+        Add missing IPC::StreamClientConnection::waitForAndDispatchImmediately()
+        and use it.
+        Remove conveinence accessor methods for the IPC::Connection, as that should be
+        accessed by accessing the stream connection in the respective classes.
+
+        No new tests, refactor.
+
+        * Platform/IPC/StreamClientConnection.h:
+        (IPC::StreamClientConnection::waitForAndDispatchImmediately):
+        * WebProcess/GPU/graphics/RemoteGraphicsContextGLProxy.cpp:
+        (WebKit::RemoteGraphicsContextGLProxy::RemoteGraphicsContextGLProxy):
+        (WebKit::RemoteGraphicsContextGLProxy::waitUntilInitialized):
+        * WebProcess/GPU/graphics/RemoteGraphicsContextGLProxy.h:
+        (WebKit::RemoteGraphicsContextGLProxy::sendSync):
+        * WebProcess/GPU/graphics/RemoteRenderingBackendProxy.cpp:
+        (WebKit::RemoteRenderingBackendProxy::waitForDidCreateImageBufferBackend):
+        (WebKit::RemoteRenderingBackendProxy::waitForDidFlush):
+        (WebKit::RemoteRenderingBackendProxy::streamConnection):
+        * WebProcess/GPU/graphics/RemoteRenderingBackendProxy.h:
+        * WebProcess/GPU/graphics/WebGPU/RemoteGPUProxy.cpp:
+        (WebKit::RemoteGPUProxy::RemoteGPUProxy):
+        (WebKit::RemoteGPUProxy::waitUntilInitialized):
+
 2022-04-04  Kimmo Kinnunen  <kkinnunen@apple.com>
 

trunk/Source/WebKit/Platform/IPC/StreamClientConnection.h

@@ -75 +75 @@
     template<typename T, typename U>
     SendSyncResult sendSync(T&& message, typename T::Reply&&, ObjectIdentifier<U> destinationID, Timeout);
+
+    template<typename T, typename U>
+    bool waitForAndDispatchImmediately(ObjectIdentifier<U> destinationID, Timeout, OptionSet<WaitForOption> = { });
+
     StreamConnectionBuffer& bufferForTesting();
 
@@ -178 +182 @@
     sendProcessOutOfStreamMessage(WTFMove(*span));
     return m_connection.sendSync(WTFMove(message), WTFMove(reply), destinationID.toUInt64(), timeout);
+}
+
+template<typename T, typename U>
+bool StreamClientConnection::waitForAndDispatchImmediately(ObjectIdentifier<U> destinationID, Timeout timeout, OptionSet<WaitForOption> waitForOptions)
+{
+    return m_connection.waitForAndDispatchImmediately<T>(destinationID, timeout, waitForOptions);
 }
 

trunk/Source/WebKit/WebProcess/GPU/graphics/RemoteGraphicsContextGLProxy.cpp

@@ -55 +55 @@
     m_gpuProcessConnection->addClient(*this);
     m_gpuProcessConnection->messageReceiverMap().addMessageReceiver(Messages::RemoteGraphicsContextGLProxy::messageReceiverName(), m_graphicsContextGLIdentifier.toUInt64(), *this);
-    connection().send(Messages::GPUConnectionToWebProcess::CreateGraphicsContextGL(attributes, m_graphicsContextGLIdentifier, renderingBackend, m_streamConnection.streamBuffer()), 0, IPC::SendOption::DispatchMessageEvenWhenWaitingForSyncReply);
+    m_gpuProcessConnection->connection().send(Messages::GPUConnectionToWebProcess::CreateGraphicsContextGL(attributes, m_graphicsContextGLIdentifier, renderingBackend, m_streamConnection.streamBuffer()), 0, IPC::SendOption::DispatchMessageEvenWhenWaitingForSyncReply);
     // TODO: We must wait until initialized, because at the moment we cannot receive IPC messages
     // during wait while in synchronous stream send. Should be fixed as part of https://bugs.webkit.org/show_bug.cgi?id=217211.
@@ -315 +315 @@
     if (m_didInitialize)
         return;
-    if (connection().waitForAndDispatchImmediately<Messages::RemoteGraphicsContextGLProxy::WasCreated>(m_graphicsContextGLIdentifier, defaultSendTimeout))
+    if (m_streamConnection.waitForAndDispatchImmediately<Messages::RemoteGraphicsContextGLProxy::WasCreated>(m_graphicsContextGLIdentifier, defaultSendTimeout))
         return;
     markContextLost();

trunk/Source/WebKit/WebProcess/GPU/graphics/RemoteGraphicsContextGLProxy.h

@@ -343 +343 @@
         return m_streamConnection.sendSync(WTFMove(message), WTFMove(reply), m_graphicsContextGLIdentifier, defaultSendTimeout);
     }
-    IPC::Connection& connection() const { return m_gpuProcessConnection->connection(); }
 
     GraphicsContextGLIdentifier m_graphicsContextGLIdentifier { GraphicsContextGLIdentifier::generate() };

trunk/Source/WebKit/WebProcess/GPU/graphics/RemoteRenderingBackendProxy.cpp

@@ -86 +86 @@
 }
 
-IPC::Connection& RemoteRenderingBackendProxy::gpuProcessConnection()
-{
-    return ensureGPUProcessConnection().connection();
-}
-
 void RemoteRenderingBackendProxy::gpuProcessConnectionDidClose(GPUProcessConnection& previousConnection)
 {
@@ -108 +103 @@
 RemoteRenderingBackendProxy::DidReceiveBackendCreationResult RemoteRenderingBackendProxy::waitForDidCreateImageBufferBackend()
 {
-    if (!gpuProcessConnection().waitForAndDispatchImmediately<Messages::RemoteRenderingBackendProxy::DidCreateImageBufferBackend>(renderingBackendIdentifier(), 1_s, IPC::WaitForOption::InterruptWaitingIfSyncMessageArrives))
+    if (!streamConnection().waitForAndDispatchImmediately<Messages::RemoteRenderingBackendProxy::DidCreateImageBufferBackend>(renderingBackendIdentifier(), 1_s, IPC::WaitForOption::InterruptWaitingIfSyncMessageArrives))
         return DidReceiveBackendCreationResult::TimeoutOrIPCFailure;
     return DidReceiveBackendCreationResult::ReceivedAnyResponse;
@@ -115 +110 @@
 bool RemoteRenderingBackendProxy::waitForDidFlush()
 {
-    return gpuProcessConnection().waitForAndDispatchImmediately<Messages::RemoteRenderingBackendProxy::DidFlush>(renderingBackendIdentifier(), 1_s, IPC::WaitForOption::InterruptWaitingIfSyncMessageArrives);
+    return streamConnection().waitForAndDispatchImmediately<Messages::RemoteRenderingBackendProxy::DidFlush>(renderingBackendIdentifier(), 1_s, IPC::WaitForOption::InterruptWaitingIfSyncMessageArrives);
 }
 
@@ -418 +413 @@
     ensureGPUProcessConnection();
     if (UNLIKELY(m_needsWakeUpSemaphoreForDisplayListStream))
-        gpuProcessConnection().waitForAndDispatchImmediately<Messages::RemoteRenderingBackendProxy::DidCreateWakeUpSemaphoreForDisplayListStream>(renderingBackendIdentifier(), 3_s, IPC::WaitForOption::InterruptWaitingIfSyncMessageArrives);
+        m_streamConnection->waitForAndDispatchImmediately<Messages::RemoteRenderingBackendProxy::DidCreateWakeUpSemaphoreForDisplayListStream>(renderingBackendIdentifier(), 3_s, IPC::WaitForOption::InterruptWaitingIfSyncMessageArrives);
     return *m_streamConnection;
 }

trunk/Source/WebKit/WebProcess/GPU/graphics/RemoteRenderingBackendProxy.h

@@ -162 +162 @@
 
     GPUProcessConnection& ensureGPUProcessConnection();
-    IPC::Connection& gpuProcessConnection();
 
     // Returns std::nullopt if no update is needed or allocation failed.

trunk/Source/WebKit/WebProcess/GPU/graphics/WebGPU/RemoteGPUProxy.cpp

@@ -51 +51 @@
     m_gpuProcessConnection->addClient(*this);
     m_gpuProcessConnection->messageReceiverMap().addMessageReceiver(Messages::RemoteGPUProxy::messageReceiverName(), identifier.toUInt64(), *this);
-    connection().send(Messages::GPUConnectionToWebProcess::CreateRemoteGPU(identifier, renderingBackend, m_streamConnection.streamBuffer()), 0, IPC::SendOption::DispatchMessageEvenWhenWaitingForSyncReply);
+    m_gpuProcessConnection->connection().send(Messages::GPUConnectionToWebProcess::CreateRemoteGPU(identifier, renderingBackend, m_streamConnection.streamBuffer()), 0, IPC::SendOption::DispatchMessageEvenWhenWaitingForSyncReply);
     // TODO: We must wait until initialized, because at the moment we cannot receive IPC messages
     // during wait while in synchronous stream send. Should be fixed as part of https://bugs.webkit.org/show_bug.cgi?id=217211.
@@ -86 +86 @@
     if (m_didInitialize)
         return;
-    if (connection().waitForAndDispatchImmediately<Messages::RemoteGPUProxy::WasCreated>(m_backing, defaultSendTimeout))
+    if (m_streamConnection.waitForAndDispatchImmediately<Messages::RemoteGPUProxy::WasCreated>(m_backing, defaultSendTimeout))
         return;
     m_lost = true;