Changeset 289247 in webkit


Ignore:
Timestamp:
Feb 7, 2022 4:18:53 PM (5 months ago)
Author:
Chris Dumez
Message:

Add support for sharing Shared Workers (including across WebProcesses)
​https://bugs.webkit.org/show_bug.cgi?id=235958
<rdar://problem/88330666>

Reviewed by Darin Adler.

LayoutTests/imported/w3c:

Rebaseline existing WPT tests involving shared workers.

  • web-platform-tests/content-security-policy/connect-src/shared-worker-connect-src-allowed.sub-expected.txt:
  • web-platform-tests/content-security-policy/connect-src/shared-worker-connect-src-blocked.sub-expected.txt:
  • web-platform-tests/content-security-policy/inside-worker/sharedworker-report-only.sub-expected.txt:
  • web-platform-tests/content-security-policy/inside-worker/sharedworker-script-src.sub-expected.txt:
  • web-platform-tests/content-security-policy/script-src/worker-set-timeout.sub-expected.txt:
  • web-platform-tests/html/browsers/offline/appcache/workers/appcache-worker.https-expected.txt:
  • web-platform-tests/html/cross-origin-embedder-policy/cross-origin-isolated-permission.https-expected.txt:
  • web-platform-tests/html/cross-origin-embedder-policy/shared-workers.https-expected.txt:
  • web-platform-tests/html/cross-origin-embedder-policy/worker-inheritance.sub.https-expected.txt:
  • web-platform-tests/service-workers/service-worker/claim-shared-worker-fetch.https-expected.txt:
  • web-platform-tests/workers/SharedWorker_dataUrl-expected.txt:
  • web-platform-tests/workers/modules/shared-worker-import-blob-url.window-expected.txt:
  • web-platform-tests/workers/modules/shared-worker-import-data-url-cross-origin-expected.txt:
  • web-platform-tests/workers/modules/shared-worker-import-data-url.window-expected.txt:
  • web-platform-tests/workers/modules/shared-worker-import-referrer-expected.txt:
  • web-platform-tests/workers/modules/shared-worker-import.window-expected.txt:
  • web-platform-tests/workers/modules/shared-worker-options-credentials-expected.txt:
  • web-platform-tests/workers/semantics/multiple-workers/004-expected.txt:
  • web-platform-tests/workers/semantics/multiple-workers/008-expected.txt:
  • web-platform-tests/workers/shared-worker-from-blob-url.window-expected.txt:
  • web-platform-tests/workers/shared-worker-name-via-options-expected.txt:
  • web-platform-tests/workers/shared-worker-options-mismatch-expected.txt:
  • web-platform-tests/xhr/open-url-redirected-sharedworker-origin-expected.txt:

Source/WebCore:

Add support for sharing Shared Workers, including across WebProcesses. The architecture
is modeled after the one we use for Service Workers since they are very similar. I tried
sharing as much code as possible with Service Workers but some more work can probably be
done in this area.

With this change, shared workers should be mostly functional and spec compliant. However,
the feature remains disabled by default for now as there are still WPT tests failures I
need to investigate. Also, I need to implement a better process suspension logic on iOS
to replace the hack I added in this patch (to make the tests run reliably on iOS).

As with Service Workers, Shared Workers are partitioned by (Top Origin + Frame Origin)
for privacy reasons. This is achieved via the SharedWorkerKey object that we use as
HashMap key.

No new tests, covered by existing WPT tests.

  • Headers.cmake:
  • Sources.txt:
  • WebCore.xcodeproj/project.pbxproj:
  • platform/Logging.h:
  • workers/shared/SharedWorker.cpp:

(WebCore::SharedWorker::fromIdentifier):
(WebCore::SharedWorker::create):
(WebCore::SharedWorker::SharedWorker):
(WebCore::SharedWorker::~SharedWorker):
(WebCore::SharedWorker::didFinishLoading):
(WebCore::SharedWorker::virtualHasPendingActivity const):
(WebCore::SharedWorker::stop):
(WebCore::SharedWorker::terminate): Deleted.

  • workers/shared/SharedWorker.h:
  • workers/shared/SharedWorker.idl:
  • workers/shared/SharedWorkerKey.h: Added.

(WebCore::SharedWorkerKey::hash const):
(WebCore::SharedWorkerKey::encode const):
(WebCore::SharedWorkerKey::decode):
(WebCore::operator==):
(WTF::DefaultHash<WebCore::SharedWorkerKey>::hash):
(WTF::DefaultHash<WebCore::SharedWorkerKey>::equal):
(WTF::HashTraits<WebCore::SharedWorkerKey>::constructDeletedValue):
(WTF::HashTraits<WebCore::SharedWorkerKey>::isDeletedValue):

  • workers/shared/SharedWorkerManager.cpp: Removed.

(WebCore::SharedWorkerManager::singleton): Deleted.
(WebCore::SharedWorkerManager::connect): Deleted.
(WebCore::SharedWorkerManager::scriptLoadFailed): Deleted.
(WebCore::SharedWorkerManager::scriptLoadedSuccessfully): Deleted.

  • workers/shared/SharedWorkerManager.h: Removed.
  • workers/shared/SharedWorkerObjectConnection.cpp:

(WebCore::SharedWorkerObjectConnection::fetchScriptInClient):
(WebCore::SharedWorkerObjectConnection::notifyWorkerObjectOfLoadCompletion):
(WebCore::SharedWorkerObjectConnection::postExceptionToWorkerObject):

  • workers/shared/SharedWorkerObjectConnection.h:
  • workers/shared/SharedWorkerObjectIdentifier.h: Copied from Source/WebCore/workers/shared/SharedWorkerObjectConnection.cpp.
  • workers/shared/SharedWorkerScriptLoader.cpp:

(WebCore::SharedWorkerScriptLoader::SharedWorkerScriptLoader):
(WebCore::SharedWorkerScriptLoader::load):
(WebCore::SharedWorkerScriptLoader::notifyFinished):

  • workers/shared/SharedWorkerScriptLoader.h:

(WebCore::SharedWorkerScriptLoader::options const):
(WebCore::SharedWorkerScriptLoader::identifier const): Deleted.
(WebCore::SharedWorkerScriptLoader::options): Deleted.

  • workers/shared/context/SharedWorkerContextManager.cpp: Added.

(WebCore::SharedWorkerContextManager::singleton):
(WebCore::SharedWorkerContextManager::sharedWorker const):
(WebCore::SharedWorkerContextManager::stopSharedWorker):
(WebCore::SharedWorkerContextManager::stopAllSharedWorkers):
(WebCore::SharedWorkerContextManager::setConnection):
(WebCore::SharedWorkerContextManager::connection const):
(WebCore::SharedWorkerContextManager::registerSharedWorkerThread):
(WebCore::SharedWorkerContextManager::Connection::postConnectEvent):
(WebCore::SharedWorkerContextManager::Connection::terminateSharedWorker):

  • workers/shared/context/SharedWorkerContextManager.h: Added.

(WebCore::SharedWorkerContextManager::Connection::~Connection):
(WebCore::SharedWorkerContextManager::Connection::isClosed const):
(WebCore::SharedWorkerContextManager::Connection::setAsClosed):

  • workers/shared/context/SharedWorkerThreadProxy.cpp:

(WebCore::generateWorkerParameters):
(WebCore::SharedWorkerThreadProxy::SharedWorkerThreadProxy):
(WebCore::SharedWorkerThreadProxy::~SharedWorkerThreadProxy):
(WebCore::SharedWorkerThreadProxy::notifyNetworkStateChange):
(WebCore::SharedWorkerThreadProxy::postExceptionToWorkerObject):
(WebCore::SharedWorkerThreadProxy::createCacheStorageConnection):
(WebCore::SharedWorkerThreadProxy::createRTCDataChannelRemoteHandlerConnection):
(WebCore::SharedWorkerThreadProxy::postTaskToLoader):
(WebCore::SharedWorkerThreadProxy::postTaskForModeToWorkerOrWorkletGlobalScope):
(WebCore::SharedWorkerThreadProxy::networkStateChanged):
(WebCore::SharedWorkerThreadProxy::startWorkerGlobalScope): Deleted.
(WebCore::SharedWorkerThreadProxy::terminateWorkerGlobalScope): Deleted.
(WebCore::SharedWorkerThreadProxy::postMessageToWorkerGlobalScope): Deleted.
(WebCore::SharedWorkerThreadProxy::postTaskToWorkerGlobalScope): Deleted.
(WebCore::SharedWorkerThreadProxy::hasPendingActivity const): Deleted.
(WebCore::SharedWorkerThreadProxy::workerObjectDestroyed): Deleted.
(WebCore::SharedWorkerThreadProxy::suspendForBackForwardCache): Deleted.
(WebCore::SharedWorkerThreadProxy::resumeForBackForwardCache): Deleted.
(WebCore::SharedWorkerThreadProxy::workerGlobalScopeDestroyed): Deleted.
(WebCore::SharedWorkerThreadProxy::postMessageToWorkerObject): Deleted.
(WebCore::SharedWorkerThreadProxy::confirmMessageFromWorkerObject): Deleted.
(WebCore::SharedWorkerThreadProxy::reportPendingActivity): Deleted.
(WebCore::SharedWorkerThreadProxy::workerGlobalScopeDestroyedInternal): Deleted.

  • workers/shared/context/SharedWorkerThreadProxy.h:

Source/WebKit:

Add support for sharing Shared Workers, including across WebProcesses. The architecture
is modeled after the one we use for Service Workers since they are very similar. I tried
sharing as much code as possible with Service Workers but some more work can probably be
done in this area.

With this change, shared workers should be mostly functional and spec compliant. However,
the feature remains disabled by default for now as there are still WPT tests failures I
need to investigate. Also, I need to implement a better process suspension logic on iOS
to replace the hack I added in this patch (to make the tests run reliably on iOS).

As with Service Workers, Shared Workers are partitioned by (Top Origin + Frame Origin)
for privacy reasons. This is achieved via the SharedWorkerKey object that we use as
HashMap key.

  • CMakeLists.txt:
  • DerivedSources-input.xcfilelist:
  • DerivedSources-output.xcfilelist:
  • DerivedSources.make:
  • NetworkProcess/NetworkConnectionToWebProcess.cpp:

(WebKit::m_schemeRegistry):
(WebKit::NetworkConnectionToWebProcess::~NetworkConnectionToWebProcess):
(WebKit::NetworkConnectionToWebProcess::didReceiveMessage):
(WebKit::NetworkConnectionToWebProcess::didClose):
(WebKit::NetworkConnectionToWebProcess::establishSharedWorkerContextConnection):
(WebKit::NetworkConnectionToWebProcess::establishSharedWorkerServerConnection):
(WebKit::NetworkConnectionToWebProcess::closeSharedWorkerContextConnection):
(WebKit::NetworkConnectionToWebProcess::unregisterSharedWorkerConnection):
(WebKit::NetworkConnectionToWebProcess::sharedWorkerServerToContextConnectionIsNoLongerNeeded):
(WebKit::NetworkConnectionToWebProcess::sharedWorkerConnection):

  • NetworkProcess/NetworkConnectionToWebProcess.h:
  • NetworkProcess/NetworkConnectionToWebProcess.messages.in:
  • NetworkProcess/NetworkSession.cpp:

(WebKit::NetworkSession::ensureSharedWorkerServer):

  • NetworkProcess/NetworkSession.h:

(WebKit::NetworkSession::sharedWorkerServer):

  • NetworkProcess/SharedWorker/WebSharedWorker.cpp: Copied from Source/WebKit/WebProcess/Storage/WebSharedWorkerObjectConnection.cpp.

(WebKit::WebSharedWorker::WebSharedWorker):
(WebKit::WebSharedWorker::~WebSharedWorker):
(WebKit::WebSharedWorker::fromIdentifier):
(WebKit::WebSharedWorker::registrableDomain const):

  • NetworkProcess/SharedWorker/WebSharedWorker.h: Added.

(WebKit::WebSharedWorker::identifier const):
(WebKit::WebSharedWorker::key const):
(WebKit::WebSharedWorker::workerOptions const):
(WebKit::WebSharedWorker::origin const):
(WebKit::WebSharedWorker::url const):
(WebKit::WebSharedWorker::sharedWorkerObjects):
(WebKit::WebSharedWorker::isRunning const):
(WebKit::WebSharedWorker::markAsRunning):
(WebKit::WebSharedWorker::fetchResult const):
(WebKit::WebSharedWorker::setFetchResult):
(WebKit::WebSharedWorker::didFinishFetching const):

  • NetworkProcess/SharedWorker/WebSharedWorkerServer.cpp: Added.

(WebKit::WebSharedWorkerServer::WebSharedWorkerServer):
(WebKit::WebSharedWorkerServer::sessionID):
(WebKit::WebSharedWorkerServer::requestSharedWorker):
(WebKit::WebSharedWorkerServer::didFinishFetchingSharedWorkerScript):
(WebKit::WebSharedWorkerServer::needsContextConnectionForRegistrableDomain const):
(WebKit::WebSharedWorkerServer::createContextConnection):
(WebKit::WebSharedWorkerServer::addContextConnection):
(WebKit::WebSharedWorkerServer::removeContextConnection):
(WebKit::WebSharedWorkerServer::contextConnectionCreated):
(WebKit::WebSharedWorkerServer::sharedWorkerObjectIsGoingAway):
(WebKit::WebSharedWorkerServer::shutDownSharedWorker):
(WebKit::WebSharedWorkerServer::addConnection):
(WebKit::WebSharedWorkerServer::removeConnection):
(WebKit::WebSharedWorkerServer::contextConnectionForRegistrableDomain const):
(WebKit::WebSharedWorkerServer::postExceptionToWorkerObject):

  • NetworkProcess/SharedWorker/WebSharedWorkerServer.h: Added.
  • NetworkProcess/SharedWorker/WebSharedWorkerServerConnection.cpp: Added.

(WebKit::WebSharedWorkerServerConnection::WebSharedWorkerServerConnection):
(WebKit::WebSharedWorkerServerConnection::~WebSharedWorkerServerConnection):
(WebKit::WebSharedWorkerServerConnection::messageSenderConnection const):
(WebKit::WebSharedWorkerServerConnection::sessionID):
(WebKit::WebSharedWorkerServerConnection::session):
(WebKit::WebSharedWorkerServerConnection::requestSharedWorker):
(WebKit::WebSharedWorkerServerConnection::sharedWorkerObjectIsGoingAway):
(WebKit::WebSharedWorkerServerConnection::fetchScriptInClient):
(WebKit::WebSharedWorkerServerConnection::notifyWorkerObjectOfLoadCompletion):
(WebKit::WebSharedWorkerServerConnection::postExceptionToWorkerObject):

  • NetworkProcess/SharedWorker/WebSharedWorkerServerConnection.h: Added.

(WebKit::WebSharedWorkerServerConnection::server):
(WebKit::WebSharedWorkerServerConnection::server const):
(WebKit::WebSharedWorkerServerConnection::webProcessIdentifier const):

  • NetworkProcess/SharedWorker/WebSharedWorkerServerConnection.messages.in: Added.
  • NetworkProcess/SharedWorker/WebSharedWorkerServerToContextConnection.cpp: Added.

(WebKit::WebSharedWorkerServerToContextConnection::WebSharedWorkerServerToContextConnection):
(WebKit::WebSharedWorkerServerToContextConnection::~WebSharedWorkerServerToContextConnection):
(WebKit::WebSharedWorkerServerToContextConnection::webProcessIdentifier const):
(WebKit::WebSharedWorkerServerToContextConnection::ipcConnection const):
(WebKit::WebSharedWorkerServerToContextConnection::messageSenderConnection const):
(WebKit::WebSharedWorkerServerToContextConnection::messageSenderDestinationID const):
(WebKit::WebSharedWorkerServerToContextConnection::connectionIsNoLongerNeeded):
(WebKit::WebSharedWorkerServerToContextConnection::postExceptionToWorkerObject):
(WebKit::WebSharedWorkerServerToContextConnection::launchSharedWorker):
(WebKit::WebSharedWorkerServerToContextConnection::postConnectEvent):
(WebKit::WebSharedWorkerServerToContextConnection::terminateSharedWorker):

  • NetworkProcess/SharedWorker/WebSharedWorkerServerToContextConnection.h: Added.
  • NetworkProcess/SharedWorker/WebSharedWorkerServerToContextConnection.messages.in: Added.
  • Platform/Logging.h:
  • Scripts/webkit/messages.py:

(types_that_cannot_be_forward_declared):

  • Sources.txt:
  • UIProcess/Network/NetworkProcessProxy.cpp:

(WebKit::NetworkProcessProxy::terminateUnresponsiveServiceWorkerProcesses):
(WebKit::NetworkProcessProxy::establishSharedWorkerContextConnectionToNetworkProcess):
(WebKit::NetworkProcessProxy::establishServiceWorkerContextConnectionToNetworkProcess):
(WebKit::NetworkProcessProxy::serviceWorkerContextConnectionNoLongerNeeded):
(WebKit::NetworkProcessProxy::sharedWorkerContextConnectionNoLongerNeeded):

  • UIProcess/Network/NetworkProcessProxy.h:
  • UIProcess/Network/NetworkProcessProxy.messages.in:
  • UIProcess/WebPageProxy.cpp:

(WebKit::WebPageProxy::setUserAgent):

  • UIProcess/WebProcessPool.cpp:

(WebKit::WebProcessPool::establishServiceWorkerContextConnectionToNetworkProcess):
(WebKit::WebProcessPool::removeFromWorkerProcesses):
(WebKit::WebProcessPool::establishSharedWorkerContextConnectionToNetworkProcess):
(WebKit::WebProcessPool::disconnectProcess):
(WebKit::WebProcessPool::userContentControllerIdentifierForWorkers):
(WebKit::WebProcessPool::createWebPage):
(WebKit::WebProcessPool::updateWorkerUserAgent):
(WebKit::WebProcessPool::terminateServiceWorkers):
(WebKit::WebProcessPool::workerProcesses):
(WebKit::WebProcessPool::updateProcessAssertions):
(WebKit::WebProcessPool::isServiceWorkerPageID const):
(WebKit::WebProcessPool::serviceWorkerProxiesCount const):
(WebKit::WebProcessPool::hasServiceWorkerForegroundActivityForTesting const):
(WebKit::WebProcessPool::hasServiceWorkerBackgroundActivityForTesting const):
(WebKit::WebProcessPool::removeFromServiceWorkerProcesses): Deleted.
(WebKit::WebProcessPool::userContentControllerIdentifierForServiceWorkers): Deleted.
(WebKit::WebProcessPool::updateServiceWorkerUserAgent): Deleted.
(WebKit::WebProcessPool::serviceWorkerProcesses): Deleted.

  • UIProcess/WebProcessPool.h:
  • UIProcess/WebProcessProxy.cpp:

(WebKit::WebProcessProxy::createForWorkers):
(WebKit::WebProcessProxy::didBecomeUnresponsive):
(WebKit::WebProcessProxy::didStartProvisionalLoadForMainFrame):
(WebKit::WebProcessProxy::setWorkerUserAgent):
(WebKit::WebProcessProxy::updateWorkerPreferencesStore):
(WebKit::WebProcessProxy::updateWorkerProcessAssertion):
(WebKit::WebProcessProxy::establishSharedWorkerContext):
(WebKit::WebProcessProxy::registerServiceWorkerClientProcess):
(WebKit::WebProcessProxy::unregisterServiceWorkerClientProcess):
(WebKit::WebProcessProxy::startServiceWorkerBackgroundProcessing):
(WebKit::WebProcessProxy::endServiceWorkerBackgroundProcessing):
(WebKit::WebProcessProxy::disableWorkers):
(WebKit::WebProcessProxy::enableWorkers):
(WebKit::WebProcessProxy::createForServiceWorkers): Deleted.
(WebKit::WebProcessProxy::setServiceWorkerUserAgent): Deleted.
(WebKit::WebProcessProxy::updateServiceWorkerPreferencesStore): Deleted.
(WebKit::WebProcessProxy::updateServiceWorkerProcessAssertion): Deleted.
(WebKit::WebProcessProxy::disableServiceWorkers): Deleted.
(WebKit::WebProcessProxy::enableServiceWorkers): Deleted.

  • UIProcess/WebProcessProxy.h:

(WebKit::WebProcessProxy::isRunningSharedWorkers const):
(WebKit::WebProcessProxy::isStandaloneSharedWorkerProcess const):
(WebKit::WebProcessProxy::isRunningWorkers const):
(WebKit::WebProcessProxy::hasServiceWorkerPageProxy):

  • WebKit.xcodeproj/project.pbxproj:
  • WebProcess/Network/NetworkProcessConnection.cpp:

(WebKit::NetworkProcessConnection::didReceiveMessage):

  • WebProcess/Network/NetworkProcessConnection.h:
  • WebProcess/Storage/WebSharedWorkerContextManagerConnection.cpp: Added.

(WebKit::WebSharedWorkerContextManagerConnection::WebSharedWorkerContextManagerConnection):
(WebKit::m_userContentController):
(WebKit::WebSharedWorkerContextManagerConnection::establishConnection):
(WebKit::WebSharedWorkerContextManagerConnection::postExceptionToWorkerObject):
(WebKit::WebSharedWorkerContextManagerConnection::updatePreferencesStore):
(WebKit::WebSharedWorkerContextManagerConnection::launchSharedWorker):
(WebKit::WebSharedWorkerContextManagerConnection::close):

  • WebProcess/Storage/WebSharedWorkerContextManagerConnection.h: Added.
  • WebProcess/Storage/WebSharedWorkerContextManagerConnection.messages.in: Added.
  • WebProcess/Storage/WebSharedWorkerObjectConnection.cpp:

(WebKit::WebSharedWorkerObjectConnection::WebSharedWorkerObjectConnection):
(WebKit::WebSharedWorkerObjectConnection::~WebSharedWorkerObjectConnection):
(WebKit::WebSharedWorkerObjectConnection::requestSharedWorker):
(WebKit::WebSharedWorkerObjectConnection::sharedWorkerObjectIsGoingAway):

  • WebProcess/Storage/WebSharedWorkerObjectConnection.h:
  • WebProcess/Storage/WebSharedWorkerObjectConnection.messages.in: Added.
  • WebProcess/WebProcess.cpp:

(WebKit::WebProcess::didReceiveMessage):
(WebKit::WebProcess::establishSharedWorkerContextConnectionToNetworkProcess):

  • WebProcess/WebProcess.h:
  • WebProcess/WebProcess.messages.in:

LayoutTests:

Rebaseline existing WPT tests involving shared workers.

  • TestExpectations:
  • platform/gtk-wk2/imported/w3c/web-platform-tests/content-security-policy/inside-worker/sharedworker-connect-src.sub-expected.txt: Added.
  • platform/gtk-wk2/imported/w3c/web-platform-tests/content-security-policy/inside-worker/sharedworker-report-only.sub-expected.txt: Added.
  • platform/gtk-wk2/imported/w3c/web-platform-tests/content-security-policy/inside-worker/sharedworker-script-src.sub-expected.txt: Added.
  • platform/gtk-wk2/imported/w3c/web-platform-tests/workers/modules/shared-worker-import-blob-url.window-expected.txt: Copied from LayoutTests/imported/w3c/web-platform-tests/workers/modules/shared-worker-import-blob-url.window-expected.txt.
  • platform/gtk-wk2/imported/w3c/web-platform-tests/workers/modules/shared-worker-import-data-url.window-expected.txt: Copied from LayoutTests/imported/w3c/web-platform-tests/workers/modules/shared-worker-import-data-url.window-expected.txt.
  • platform/gtk-wk2/imported/w3c/web-platform-tests/workers/modules/shared-worker-import.window-expected.txt: Copied from LayoutTests/imported/w3c/web-platform-tests/workers/modules/shared-worker-import.window-expected.txt.
  • platform/gtk-wk2/imported/w3c/web-platform-tests/workers/modules/shared-worker-options-credentials-expected.txt: Added.
  • platform/gtk-wk2/imported/w3c/web-platform-tests/xhr/open-url-redirected-sharedworker-origin-expected.txt: Copied from LayoutTests/imported/w3c/web-platform-tests/xhr/open-url-redirected-sharedworker-origin-expected.txt.
Location:
trunk
Files:
27 added
2 deleted
82 edited
6 copied

Legend:

Unmodified
Added
Removed

  • trunk/LayoutTests/ChangeLog

    r289244 r289247  
     12022-02-07  Chris Dumez  <cdumez@apple.com>
     2
     3        Add support for sharing Shared Workers (including across WebProcesses)
     4        https://bugs.webkit.org/show_bug.cgi?id=235958
     5        <rdar://problem/88330666>
     6
     7        Reviewed by Darin Adler.
     8
     9        Rebaseline existing WPT tests involving shared workers.
     10
     11        * TestExpectations:
     12        * platform/gtk-wk2/imported/w3c/web-platform-tests/content-security-policy/inside-worker/sharedworker-connect-src.sub-expected.txt: Added.
     13        * platform/gtk-wk2/imported/w3c/web-platform-tests/content-security-policy/inside-worker/sharedworker-report-only.sub-expected.txt: Added.
     14        * platform/gtk-wk2/imported/w3c/web-platform-tests/content-security-policy/inside-worker/sharedworker-script-src.sub-expected.txt: Added.
     15        * platform/gtk-wk2/imported/w3c/web-platform-tests/workers/modules/shared-worker-import-blob-url.window-expected.txt: Copied from LayoutTests/imported/w3c/web-platform-tests/workers/modules/shared-worker-import-blob-url.window-expected.txt.
     16        * platform/gtk-wk2/imported/w3c/web-platform-tests/workers/modules/shared-worker-import-data-url.window-expected.txt: Copied from LayoutTests/imported/w3c/web-platform-tests/workers/modules/shared-worker-import-data-url.window-expected.txt.
     17        * platform/gtk-wk2/imported/w3c/web-platform-tests/workers/modules/shared-worker-import.window-expected.txt: Copied from LayoutTests/imported/w3c/web-platform-tests/workers/modules/shared-worker-import.window-expected.txt.
     18        * platform/gtk-wk2/imported/w3c/web-platform-tests/workers/modules/shared-worker-options-credentials-expected.txt: Added.
     19        * platform/gtk-wk2/imported/w3c/web-platform-tests/xhr/open-url-redirected-sharedworker-origin-expected.txt: Copied from LayoutTests/imported/w3c/web-platform-tests/xhr/open-url-redirected-sharedworker-origin-expected.txt.
     20
    1212022-02-07  Chris Dumez  <cdumez@apple.com>
    222

  • trunk/LayoutTests/TestExpectations

    r289244 r289247  
    460460imported/w3c/web-platform-tests/webaudio/the-audio-api/the-audionode-interface/audionode-disconnect-audioparam.html [ DumpJSConsoleLogInStdErr ]
    461461imported/w3c/web-platform-tests/workers/same-origin-check.sub.html [ DumpJSConsoleLogInStdErr ]
    462 imported/w3c/web-platform-tests/workers/shared-worker-name-via-options.html [ DumpJSConsoleLogInStdErr ]
    463462fast/files/file-reader-back-forward-cache.html [ DumpJSConsoleLogInStdErr ]
    464463fast/history/page-cache-createImageBitmap.html [ DumpJSConsoleLogInStdErr ]
    … …  
    850849imported/w3c/web-platform-tests/html/webappapis/system-state-and-capabilities/the-navigator-object/plugins-and-mimetypes.html [ Failure Pass ]
    851850imported/w3c/web-platform-tests/beacon/beacon-redirect.sub.window.html [ Failure Pass ]
     851imported/w3c/web-platform-tests/html/cross-origin-embedder-policy/anonymous-iframe/sharedworker-partitioning.tentative.https.window.html [ Failure Pass ]
    852852
    853853imported/w3c/web-platform-tests/html/semantics/document-metadata/the-link-element/link-load-error-events.html [ DumpJSConsoleLogInStdErr ]
    … …  
    51135113imported/w3c/web-platform-tests/workers/modules/dedicated-worker-import-csp.html [ Skip ]
    51145114
     5115# Test is flaky because MessagePort messages may get received in a different order when several MessagePorts are involved,
     5116# due to how MessagePort::dispatchMessages() is implemented.
     5117imported/w3c/web-platform-tests/workers/shared-worker-name-via-options.html [ DumpJSConsoleLogInStdErr Failure Pass ]
     5118
    51155119# Plugins
    51165120# FIXME: Remove these tests.

  • trunk/LayoutTests/imported/w3c/ChangeLog

    r289236 r289247  
     12022-02-07  Chris Dumez  <cdumez@apple.com>
     2
     3        Add support for sharing Shared Workers (including across WebProcesses)
     4        https://bugs.webkit.org/show_bug.cgi?id=235958
     5        <rdar://problem/88330666>
     6
     7        Reviewed by Darin Adler.
     8
     9        Rebaseline existing WPT tests involving shared workers.
     10
     11        * web-platform-tests/content-security-policy/connect-src/shared-worker-connect-src-allowed.sub-expected.txt:
     12        * web-platform-tests/content-security-policy/connect-src/shared-worker-connect-src-blocked.sub-expected.txt:
     13        * web-platform-tests/content-security-policy/inside-worker/sharedworker-report-only.sub-expected.txt:
     14        * web-platform-tests/content-security-policy/inside-worker/sharedworker-script-src.sub-expected.txt:
     15        * web-platform-tests/content-security-policy/script-src/worker-set-timeout.sub-expected.txt:
     16        * web-platform-tests/html/browsers/offline/appcache/workers/appcache-worker.https-expected.txt:
     17        * web-platform-tests/html/cross-origin-embedder-policy/cross-origin-isolated-permission.https-expected.txt:
     18        * web-platform-tests/html/cross-origin-embedder-policy/shared-workers.https-expected.txt:
     19        * web-platform-tests/html/cross-origin-embedder-policy/worker-inheritance.sub.https-expected.txt:
     20        * web-platform-tests/service-workers/service-worker/claim-shared-worker-fetch.https-expected.txt:
     21        * web-platform-tests/workers/SharedWorker_dataUrl-expected.txt:
     22        * web-platform-tests/workers/modules/shared-worker-import-blob-url.window-expected.txt:
     23        * web-platform-tests/workers/modules/shared-worker-import-data-url-cross-origin-expected.txt:
     24        * web-platform-tests/workers/modules/shared-worker-import-data-url.window-expected.txt:
     25        * web-platform-tests/workers/modules/shared-worker-import-referrer-expected.txt:
     26        * web-platform-tests/workers/modules/shared-worker-import.window-expected.txt:
     27        * web-platform-tests/workers/modules/shared-worker-options-credentials-expected.txt:
     28        * web-platform-tests/workers/semantics/multiple-workers/004-expected.txt:
     29        * web-platform-tests/workers/semantics/multiple-workers/008-expected.txt:
     30        * web-platform-tests/workers/shared-worker-from-blob-url.window-expected.txt:
     31        * web-platform-tests/workers/shared-worker-name-via-options-expected.txt:
     32        * web-platform-tests/workers/shared-worker-options-mismatch-expected.txt:
     33        * web-platform-tests/xhr/open-url-redirected-sharedworker-origin-expected.txt:
     34
    1352022-02-07  Chris Dumez  <cdumez@apple.com>
    236

  • trunk/LayoutTests/imported/w3c/web-platform-tests/content-security-policy/connect-src/shared-worker-connect-src-allowed.sub-expected.txt

    r289119 r289247  
    1 Blocked access to external URL http://www1.localhost:8800/content-security-policy/support/fail.asis
    21
    32FAIL Expecting logs: ["xhr allowed","TEST COMPLETE"] assert_unreached: unexpected log: xhr blocked Reached unreachable code

  • trunk/LayoutTests/imported/w3c/web-platform-tests/content-security-policy/connect-src/shared-worker-connect-src-blocked.sub-expected.txt

    r289119 r289247  
    1 Blocked access to external URL http://www1.localhost:8800/content-security-policy/support/fail.asis
    21This test loads a shared worker, delivered with its own policy. The worker should be blocked from making an XHR as that policy specifies a connect-src 'none', though this resource's policy is connect-src *. No report should be sent since the worker's policy doesn't specify a report-uri.
    32

  • trunk/LayoutTests/imported/w3c/web-platform-tests/content-security-policy/inside-worker/sharedworker-report-only.sub-expected.txt

    r286821 r289247  
    1 Blocked access to external URL https://www.localhost:9444/content-security-policy/support/resource.py?cross-origin-fetch
    2 Blocked access to external URL https://www.localhost:9444/content-security-policy/support/resource.py?cross-origin-xhr
    3 Blocked access to external URL https://www.localhost:9444/content-security-policy/support/resource.py?cross-origin-fetch
    41
    52PASS Same-origin 'fetch()'.

  • trunk/LayoutTests/imported/w3c/web-platform-tests/content-security-policy/inside-worker/sharedworker-script-src.sub-expected.txt

    r286821 r289247  
    33
    44TIMEOUT sharedworker-script-src Test timed out
    5 FAIL Cross-origin `importScripts()` not blocked in http: withour CSP  A network error occurred.
    6 FAIL `eval()` not blocked in http: without CSP Refused to evaluate a string as JavaScript because 'unsafe-eval' is not an allowed source of script in the following Content Security Policy directive: "script-src 'self' 'nonce-a' blob: filesystem:".
    7 
    8 FAIL `setTimeout([string])` not blocked in http: without CSP assert_unreached: callback not called. Reached unreachable code
     5FAIL Cross-origin `importScripts()` not blocked in http: withour CSP Load failed
     6PASS `eval()` not blocked in http: without CSP
     7PASS `setTimeout([string])` not blocked in http: without CSP
    98TIMEOUT Cross-origin `importScripts()` blocked in http: with script-src 'self' Test timed out
    109NOTRUN `eval()` blocked in http: with script-src 'self'

  • trunk/LayoutTests/imported/w3c/web-platform-tests/content-security-policy/script-src/worker-set-timeout.sub-expected.txt

    r286821 r289247  
    11
    22FAIL Dedicated worker inherits CSP from main document assert_equals: expected "setTimeout allowed" but got "setTimeout blocked"
    3 FAIL Shared worker delivers its own CSP assert_equals: expected "setTimeout blocked" but got "setTimeout allowed"
     3PASS Shared worker delivers its own CSP
    44

  • trunk/LayoutTests/imported/w3c/web-platform-tests/html/browsers/offline/appcache/workers/appcache-worker.https-expected.txt

    r286821 r289247  
    66PASS Dedicated worker of the fallbacked script
    77PASS Dedicated worker of the not-in-cache script
    8 PASS Shared worker of the cached script
    9 PASS Shared worker of the fallbacked script
     8FAIL Shared worker of the cached script assert_equals: expected "Done: cached" but got "Error: Importing a non-cached script must fail."
     9FAIL Shared worker of the fallbacked script assert_equals: expected "Done: fallbacked" but got "Error: Importing a non-cached script must fail."
    1010TIMEOUT Shared worker of the not-in-cache script Test timed out
    1111

  • trunk/LayoutTests/imported/w3c/web-platform-tests/html/cross-origin-embedder-policy/cross-origin-isolated-permission.https-expected.txt

    r286821 r289247  
    2121FAIL dedicated worker: scheme = blob, value = (\) assert_equals: expected false but got true
    2222PASS shared worker: withCoopCoep = false
    23 PASS shared worker: withCoopCoep = true
     23FAIL shared worker: withCoopCoep = true assert_equals: expected true but got false
    2424PASS service worker: withCoopCoep = false
    2525FAIL service worker: withCoopCoep = true assert_equals: expected true but got false

  • trunk/LayoutTests/imported/w3c/web-platform-tests/html/cross-origin-embedder-policy/shared-workers.https-expected.txt

    r286821 r289247  
    33
    44PASS default policy (derived from response)
    5 FAIL "require-corp" (derived from response) assert_equals: expected "failure" but got "success"
     5PASS "require-corp" (derived from response)
    66PASS default policy (derived from owner set due to use of local scheme - blob URL)
    77FAIL "require-corp" (derived from owner set due to use of local scheme - blob URL) assert_equals: expected "failure" but got "success"

  • trunk/LayoutTests/imported/w3c/web-platform-tests/html/cross-origin-embedder-policy/worker-inheritance.sub.https-expected.txt

    r286821 r289247  
    1 Blocked access to external URL https://www.localhost:9444/common/blank.html
    21Blocked access to external URL https://www.localhost:9444/common/blank.html
    32Blocked access to external URL https://www.localhost:9444/common/blank.html

  • trunk/LayoutTests/imported/w3c/web-platform-tests/service-workers/service-worker/claim-shared-worker-fetch.https-expected.txt

    r289120 r289247  
    11
    2 PASS fetch() in SharedWorker should be intercepted after the client is claimed.
    32
     3FAIL fetch() in SharedWorker should be intercepted after the client is claimed. assert_equals: fetch() in the shared worker should be intercepted. expected "Intercepted!" but got "a simple text file\n"
     4

  • trunk/LayoutTests/imported/w3c/web-platform-tests/workers/SharedWorker-script-error-expected.txt

    r289116 r289247  
    1 CONSOLE MESSAGE: Error: assert_unreached: FAIL: onerror invoked for a script error. Reached unreachable code
    2 
    3 Harness Error (FAIL), message = Error: assert_unreached: FAIL: onerror invoked for a script error. Reached unreachable code
    41
    52PASS Test script error unhandled.

  • trunk/LayoutTests/imported/w3c/web-platform-tests/workers/SharedWorker_dataUrl-expected.txt

    r286821 r289247  
    1 CONSOLE MESSAGE: Error: assert_equals: expected 2 but got 1
    21
    32
    4 Harness Error (FAIL), message = Error: assert_equals: expected 2 but got 1
     3PASS Data URL not shared by cross-origin SharedWorkers
     4PASS Data URLs shared by same-origin SharedWorkers
    55
    6 PASS Data URL not shared by cross-origin SharedWorkers
    7 TIMEOUT Data URLs shared by same-origin SharedWorkers Test timed out
    8 
    9 Harness Error (FAIL), message = Error: assert_equals: expected 2 but got 1
    10 
    11 PASS Data URL not shared by cross-origin SharedWorkers
    12 TIMEOUT Data URLs shared by same-origin SharedWorkers Test timed out
    13 

  • trunk/LayoutTests/imported/w3c/web-platform-tests/workers/modules/shared-worker-import-blob-url.window-expected.txt

    r286821 r289247  
    1 Blocked access to external URL https://www1.localhost:9443/workers/modules/resources/export-on-load-script.py
    21
    32PASS Static import.

  • trunk/LayoutTests/imported/w3c/web-platform-tests/workers/modules/shared-worker-import-data-url-cross-origin-expected.txt

    r286821 r289247  
    1 CONSOLE MESSAGE: Origin null is not allowed by Access-Control-Allow-Origin. Status code: 200
    21
    32Harness Error (TIMEOUT), message = null

  • trunk/LayoutTests/imported/w3c/web-platform-tests/workers/modules/shared-worker-import-data-url.window-expected.txt

    r286821 r289247  
    1 Blocked access to external URL https://www1.localhost:9443/workers/modules/resources/export-on-load-script.py
    21
    32Harness Error (TIMEOUT), message = null

  • trunk/LayoutTests/imported/w3c/web-platform-tests/workers/modules/shared-worker-import-failure-expected.txt

    r286821 r289247  
    1 CONSOLE MESSAGE: Cannot load static-import-worker.js.
    21
    32PASS importScripts() on module worker should throw an exception.
    … …  
    65PASS Dynamic import for non-existent script should throw an exception.
    76PASS SharedWorker construction for an invalid URL should throw an exception.
    8 FAIL SharedWorker construction for a file URL should throw an exception. assert_throws_dom: function "() => new SharedWorker(scriptURL, { type: 'module' })" did not throw
     7PASS SharedWorker construction for a file URL should throw an exception.
    98

  • trunk/LayoutTests/imported/w3c/web-platform-tests/workers/modules/shared-worker-import-referrer-expected.txt

    r289116 r289247  
    1 Blocked access to external URL https://www1.localhost:9443/workers/modules/resources/export-referrer-checker.py
    2 Blocked access to external URL https://www1.localhost:9443/workers/modules/resources/export-referrer-checker.py
    3 Blocked access to external URL https://www1.localhost:9443/workers/modules/resources/export-referrer-checker.py
    4 Blocked access to external URL https://www1.localhost:9443/workers/modules/resources/export-referrer-checker.py
    5 Blocked access to external URL https://www1.localhost:9443/workers/modules/resources/export-referrer-checker.py
    6 Blocked access to external URL https://www1.localhost:9443/workers/modules/resources/export-referrer-checker.py
    71
    82PASS Same-origin top-level module script loading with "no-referrer" referrer policy
    93PASS Same-origin top-level module script loading with "origin" referrer policy
    104PASS Same-origin top-level module script loading with "same-origin" referrer policy
    11 PASS Same-origin static import with "no-referrer" referrer policy.
    12 PASS Same-origin static import with "origin" referrer policy.
     5FAIL Same-origin static import with "no-referrer" referrer policy. assert_equals: expected "" but got "http://localhost:8800/workers/modules/resources/static-import-same-origin-referrer-checker-worker.js"
     6FAIL Same-origin static import with "origin" referrer policy. assert_equals: expected "http://localhost:8800/" but got "http://localhost:8800/workers/modules/resources/static-import-same-origin-referrer-checker-worker.js"
    137PASS Same-origin static import with "same-origin" referrer policy.
    148FAIL Cross-origin static import with "no-referrer" referrer policy. promise_test: Unhandled rejection with value: object "TypeError: Type error"
    159FAIL Cross-origin static import with "origin" referrer policy. promise_test: Unhandled rejection with value: object "TypeError: Type error"
    1610FAIL Cross-origin static import with "same-origin" referrer policy. promise_test: Unhandled rejection with value: object "TypeError: Type error"
    17 FAIL Same-origin dynamic import with "no-referrer" referrer policy. assert_equals: expected "" but got "http://localhost:8800/workers/modules/resources/dynamic-import-same-origin-referrer-checker-worker.js"
    18 FAIL Same-origin dynamic import with "origin" referrer policy. assert_equals: expected "http://localhost:8800/" but got "http://localhost:8800/workers/modules/resources/dynamic-import-same-origin-referrer-checker-worker.js"
     11PASS Same-origin dynamic import with "no-referrer" referrer policy.
     12PASS Same-origin dynamic import with "origin" referrer policy.
    1913PASS Same-origin dynamic import with "same-origin" referrer policy.
    2014FAIL Cross-origin dynamic import with "no-referrer" referrer policy. promise_test: Unhandled rejection with value: object "TypeError: Type error"

  • trunk/LayoutTests/imported/w3c/web-platform-tests/workers/modules/shared-worker-import.window-expected.txt

    r286821 r289247  
    1 Blocked access to external URL https://www1.localhost:9443/workers/modules/resources/export-on-load-script.py
    21
    32PASS Static import.

  • trunk/LayoutTests/imported/w3c/web-platform-tests/workers/modules/shared-worker-options-credentials-expected.txt

    r286821 r289247  
    1 Blocked access to external URL http://www1.localhost:8800/workers/modules/resources/export-credentials.py
    21
    32Harness Error (TIMEOUT), message = null

  • trunk/LayoutTests/imported/w3c/web-platform-tests/workers/semantics/multiple-workers/004-expected.txt

    r286821 r289247  
    11
    2 Harness Error (TIMEOUT), message = null
     2PASS shared worker with multiple documents
    33
    4 NOTRUN shared worker with multiple documents
    5 

  • trunk/LayoutTests/imported/w3c/web-platform-tests/workers/semantics/multiple-workers/008-expected.txt

    r286821 r289247  
    11
    2 Harness Error (TIMEOUT), message = null
     2PASS messagechannel in shared worker
    33
    4 TIMEOUT messagechannel in shared worker Test timed out
    5 

  • trunk/LayoutTests/imported/w3c/web-platform-tests/workers/semantics/reporting-errors/003-expected.txt

    r286821 r289247  
    11
    2 FAIL shared worker, no error event on worker or port assert_unreached: error on worker Reached unreachable code
     2PASS shared worker, no error event on worker or port
    33

  • trunk/LayoutTests/imported/w3c/web-platform-tests/workers/semantics/reporting-errors/004-expected.txt

    r286821 r289247  
    11
    2 FAIL shared worker in two documents and window.onerror assert_unreached: (outer) error on worker Reached unreachable code
     2PASS shared worker in two documents and window.onerror
    33

  • trunk/LayoutTests/imported/w3c/web-platform-tests/workers/shared-worker-from-blob-url.window-expected.txt

    r286821 r289247  
    11
    2 Harness Error (TIMEOUT), message = null
     2PASS Creating a shared worker from a blob URL works.
     3PASS Creating a shared worker from a blob URL works immediately before revoking.
     4PASS Connecting to a shared worker on a revoked blob URL works.
    35
    4 FAIL Creating a shared worker from a blob URL works. assert_equals: expected "worker_OK_2" but got "worker_OK_1"
    5 PASS Creating a shared worker from a blob URL works immediately before revoking.
    6 TIMEOUT Connecting to a shared worker on a revoked blob URL works. Test timed out
    7 

  • trunk/LayoutTests/imported/w3c/web-platform-tests/workers/shared-worker-in-data-url-context.window-expected.txt

    r267649 r289247  
     1CONSOLE MESSAGE: Cannot load http://localhost:8800/workers/support/post-message-on-load-worker.js.
    12
    2 FAIL Create a shared worker in a data url frame assert_equals: expected "PASS" but got "SharedWorker construction unexpectedly synchronously failed"
    3 FAIL Create a data url shared worker in a data url frame assert_equals: expected "PASS" but got "SharedWorker construction unexpectedly synchronously failed"
     3PASS Create a shared worker in a data url frame
     4PASS Create a data url shared worker in a data url frame
    45

  • trunk/LayoutTests/imported/w3c/web-platform-tests/workers/shared-worker-name-via-options-expected.txt

    r286821 r289247  
    11
    2 FAIL Test the name property of shared workers mixing constructor options and constructor strings Error: assert_equals: expected 2 but got 1
     2PASS Test the name property of shared workers mixing constructor options and constructor strings
    33

  • trunk/LayoutTests/imported/w3c/web-platform-tests/workers/shared-worker-options-mismatch-expected.txt

    r282484 r289247  
    11
    2 Harness Error (TIMEOUT), message = null
     2PASS Connecting to shared worker with different options should be blocked: default to module
     3PASS Connecting to shared worker with different options should be blocked: module to default
     4PASS Connecting to shared worker with different options should be blocked: classic to module
     5PASS Connecting to shared worker with different options should be blocked: module to classic
     6PASS Connecting to shared worker with different options should be blocked: default to omit in classic
     7PASS Connecting to shared worker with different options should be blocked: default to include in classic
     8PASS Connecting to shared worker with different options should be blocked: omit to default in classic
     9PASS Connecting to shared worker with different options should be blocked: omit to same-origin in classic
     10PASS Connecting to shared worker with different options should be blocked: omit to include in classic
     11PASS Connecting to shared worker with different options should be blocked: same-origin to omit in classic
     12PASS Connecting to shared worker with different options should be blocked: same-origin to include in classic
     13PASS Connecting to shared worker with different options should be blocked: include to default in classic
     14PASS Connecting to shared worker with different options should be blocked: include to omit in classic
     15PASS Connecting to shared worker with different options should be blocked: include to same-origin in classic
     16PASS Connecting to shared worker with different options should be blocked: default to omit in module
     17PASS Connecting to shared worker with different options should be blocked: default to include in module
     18PASS Connecting to shared worker with different options should be blocked: omit to default in module
     19PASS Connecting to shared worker with different options should be blocked: omit to same-origin in module
     20PASS Connecting to shared worker with different options should be blocked: omit to include in module
     21PASS Connecting to shared worker with different options should be blocked: same-origin to omit in module
     22PASS Connecting to shared worker with different options should be blocked: same-origin to include in module
     23PASS Connecting to shared worker with different options should be blocked: include to default in module
     24PASS Connecting to shared worker with different options should be blocked: include to omit in module
     25PASS Connecting to shared worker with different options should be blocked: include to same-origin in module
    326
    4 TIMEOUT Connecting to shared worker with different options should be blocked: default to module Test timed out
    5 NOTRUN Connecting to shared worker with different options should be blocked: module to default
    6 NOTRUN Connecting to shared worker with different options should be blocked: classic to module
    7 NOTRUN Connecting to shared worker with different options should be blocked: module to classic
    8 NOTRUN Connecting to shared worker with different options should be blocked: default to omit in classic
    9 NOTRUN Connecting to shared worker with different options should be blocked: default to include in classic
    10 NOTRUN Connecting to shared worker with different options should be blocked: omit to default in classic
    11 NOTRUN Connecting to shared worker with different options should be blocked: omit to same-origin in classic
    12 NOTRUN Connecting to shared worker with different options should be blocked: omit to include in classic
    13 NOTRUN Connecting to shared worker with different options should be blocked: same-origin to omit in classic
    14 NOTRUN Connecting to shared worker with different options should be blocked: same-origin to include in classic
    15 NOTRUN Connecting to shared worker with different options should be blocked: include to default in classic
    16 NOTRUN Connecting to shared worker with different options should be blocked: include to omit in classic
    17 NOTRUN Connecting to shared worker with different options should be blocked: include to same-origin in classic
    18 NOTRUN Connecting to shared worker with different options should be blocked: default to omit in module
    19 NOTRUN Connecting to shared worker with different options should be blocked: default to include in module
    20 NOTRUN Connecting to shared worker with different options should be blocked: omit to default in module
    21 NOTRUN Connecting to shared worker with different options should be blocked: omit to same-origin in module
    22 NOTRUN Connecting to shared worker with different options should be blocked: omit to include in module
    23 NOTRUN Connecting to shared worker with different options should be blocked: same-origin to omit in module
    24 NOTRUN Connecting to shared worker with different options should be blocked: same-origin to include in module
    25 NOTRUN Connecting to shared worker with different options should be blocked: include to default in module
    26 NOTRUN Connecting to shared worker with different options should be blocked: include to omit in module
    27 NOTRUN Connecting to shared worker with different options should be blocked: include to same-origin in module
    28 

  • trunk/LayoutTests/imported/w3c/web-platform-tests/xhr/open-url-redirected-sharedworker-origin-expected.txt

    r286821 r289247  
    1 Blocked access to external URL http://www2.localhost:8800/xhr/resources/inspect-headers.py?filter_name=origin&cors
    21
    32FAIL Referer header assert_equals: expected "Referer: http://localhost:8800/xhr/resources/workerxhr-origin-referrer.js\n" but got "Referer: http://localhost:8800/xhr/resources/redirect.py?location=workerxhr-origin-referrer.js\n"

  • trunk/LayoutTests/platform/gtk/imported/w3c/web-platform-tests/workers/modules/shared-worker-import-blob-url.window-expected.txt

    r289246 r289247  
    1 Blocked access to external URL https://www1.localhost:9443/workers/modules/resources/export-on-load-script.py
    21
    32PASS Static import.
    4 FAIL Static import (cross-origin). promise_test: Unhandled rejection with value: "Importing a module script failed."
     3PASS Static import (cross-origin).
    54PASS Static import (redirect).
    65PASS Nested static import.

  • trunk/LayoutTests/platform/gtk/imported/w3c/web-platform-tests/workers/modules/shared-worker-import-data-url.window-expected.txt

    r289246 r289247  
    1 Blocked access to external URL https://www1.localhost:9443/workers/modules/resources/export-on-load-script.py
    21
    32Harness Error (TIMEOUT), message = null
    43
    54PASS Static import.
    6 TIMEOUT Static import (cross-origin). Test timed out
    7 NOTRUN Static import (redirect).
     5PASS Static import (cross-origin).
     6TIMEOUT Static import (redirect). Test timed out
    87NOTRUN Nested static import.
    98NOTRUN Static import and then dynamic import.

  • trunk/LayoutTests/platform/gtk/imported/w3c/web-platform-tests/workers/modules/shared-worker-import.window-expected.txt

    r289246 r289247  
    1 Blocked access to external URL https://www1.localhost:9443/workers/modules/resources/export-on-load-script.py
    21
    32PASS Static import.
    4 FAIL Static import (cross-origin). promise_test: Unhandled rejection with value: "Importing a module script failed."
     3PASS Static import (cross-origin).
    54PASS Static import (redirect).
    65PASS Nested static import.

  • trunk/LayoutTests/platform/gtk/imported/w3c/web-platform-tests/xhr/open-url-redirected-sharedworker-origin-expected.txt

    r289246 r289247  
    1 Blocked access to external URL http://www2.localhost:8800/xhr/resources/inspect-headers.py?filter_name=origin&cors
    21
    32FAIL Referer header assert_equals: expected "Referer: http://localhost:8800/xhr/resources/workerxhr-origin-referrer.js\n" but got "Referer: http://localhost:8800/xhr/resources/redirect.py?location=workerxhr-origin-referrer.js\n"
    4 FAIL Origin header assert_equals: expected "Origin: http://localhost:8800\n" but got ""
     3PASS Origin header
    54PASS Request URL test
    65

  • trunk/LayoutTests/platform/mac-wk1/TestExpectations

    r289244 r289247  
    225225imported/w3c/web-platform-tests/workers/semantics/xhr/006.html [ Skip ]
    226226imported/w3c/web-platform-tests/workers/shared-worker-from-blob-url.window.html [ Skip ]
     227imported/w3c/web-platform-tests/workers/shared-worker-in-data-url-context.window.html [ Skip ]
    227228imported/w3c/web-platform-tests/workers/shared-worker-name-via-options.html [ Skip ]
    228229imported/w3c/web-platform-tests/workers/shared-worker-options-mismatch.html [ Skip ]

  • trunk/LayoutTests/platform/win/TestExpectations

    r289238 r289247  
    337337imported/w3c/web-platform-tests/workers/semantics/xhr/006.html [ Skip ]
    338338imported/w3c/web-platform-tests/workers/shared-worker-from-blob-url.window.html [ Skip ]
     339imported/w3c/web-platform-tests/workers/shared-worker-in-data-url-context.window.html [ Skip ]
    339340imported/w3c/web-platform-tests/workers/shared-worker-name-via-options.html [ Skip ]
    340341imported/w3c/web-platform-tests/workers/shared-worker-options-mismatch.html [ Skip ]

  • trunk/Source/WebCore/ChangeLog

    r289246 r289247  
     12022-02-07  Chris Dumez  <cdumez@apple.com>
     2
     3        Add support for sharing Shared Workers (including across WebProcesses)
     4        https://bugs.webkit.org/show_bug.cgi?id=235958
     5        <rdar://problem/88330666>
     6
     7        Reviewed by Darin Adler.
     8
     9        Add support for sharing Shared Workers, including across WebProcesses. The architecture
     10        is modeled after the one we use for Service Workers since they are very similar. I tried
     11        sharing as much code as possible with Service Workers but some more work can probably be
     12        done in this area.
     13
     14        With this change, shared workers should be mostly functional and spec compliant. However,
     15        the feature remains disabled by default for now as there are still WPT tests failures I
     16        need to investigate. Also, I need to implement a better process suspension logic on iOS
     17        to replace the hack I added in this patch (to make the tests run reliably on iOS).
     18
     19        As with Service Workers, Shared Workers are partitioned by (Top Origin + Frame Origin)
     20        for privacy reasons. This is achieved via the SharedWorkerKey object that we use as
     21        HashMap key.
     22
     23        No new tests, covered by existing WPT tests.
     24
     25        * Headers.cmake:
     26        * Sources.txt:
     27        * WebCore.xcodeproj/project.pbxproj:
     28        * platform/Logging.h:
     29        * workers/shared/SharedWorker.cpp:
     30        (WebCore::SharedWorker::fromIdentifier):
     31        (WebCore::SharedWorker::create):
     32        (WebCore::SharedWorker::SharedWorker):
     33        (WebCore::SharedWorker::~SharedWorker):
     34        (WebCore::SharedWorker::didFinishLoading):
     35        (WebCore::SharedWorker::virtualHasPendingActivity const):
     36        (WebCore::SharedWorker::stop):
     37        (WebCore::SharedWorker::terminate): Deleted.
     38        * workers/shared/SharedWorker.h:
     39        * workers/shared/SharedWorker.idl:
     40        * workers/shared/SharedWorkerKey.h: Added.
     41        (WebCore::SharedWorkerKey::hash const):
     42        (WebCore::SharedWorkerKey::encode const):
     43        (WebCore::SharedWorkerKey::decode):
     44        (WebCore::operator==):
     45        (WTF::DefaultHash<WebCore::SharedWorkerKey>::hash):
     46        (WTF::DefaultHash<WebCore::SharedWorkerKey>::equal):
     47        (WTF::HashTraits<WebCore::SharedWorkerKey>::constructDeletedValue):
     48        (WTF::HashTraits<WebCore::SharedWorkerKey>::isDeletedValue):
     49        * workers/shared/SharedWorkerManager.cpp: Removed.
     50        (WebCore::SharedWorkerManager::singleton): Deleted.
     51        (WebCore::SharedWorkerManager::connect): Deleted.
     52        (WebCore::SharedWorkerManager::scriptLoadFailed): Deleted.
     53        (WebCore::SharedWorkerManager::scriptLoadedSuccessfully): Deleted.
     54        * workers/shared/SharedWorkerManager.h: Removed.
     55        * workers/shared/SharedWorkerObjectConnection.cpp:
     56        (WebCore::SharedWorkerObjectConnection::fetchScriptInClient):
     57        (WebCore::SharedWorkerObjectConnection::notifyWorkerObjectOfLoadCompletion):
     58        (WebCore::SharedWorkerObjectConnection::postExceptionToWorkerObject):
     59        * workers/shared/SharedWorkerObjectConnection.h:
     60        * workers/shared/SharedWorkerObjectIdentifier.h: Copied from Source/WebCore/workers/shared/SharedWorkerObjectConnection.cpp.
     61        * workers/shared/SharedWorkerScriptLoader.cpp:
     62        (WebCore::SharedWorkerScriptLoader::SharedWorkerScriptLoader):
     63        (WebCore::SharedWorkerScriptLoader::load):
     64        (WebCore::SharedWorkerScriptLoader::notifyFinished):
     65        * workers/shared/SharedWorkerScriptLoader.h:
     66        (WebCore::SharedWorkerScriptLoader::options const):
     67        (WebCore::SharedWorkerScriptLoader::identifier const): Deleted.
     68        (WebCore::SharedWorkerScriptLoader::options): Deleted.
     69        * workers/shared/context/SharedWorkerContextManager.cpp: Added.
     70        (WebCore::SharedWorkerContextManager::singleton):
     71        (WebCore::SharedWorkerContextManager::sharedWorker const):
     72        (WebCore::SharedWorkerContextManager::stopSharedWorker):
     73        (WebCore::SharedWorkerContextManager::stopAllSharedWorkers):
     74        (WebCore::SharedWorkerContextManager::setConnection):
     75        (WebCore::SharedWorkerContextManager::connection const):
     76        (WebCore::SharedWorkerContextManager::registerSharedWorkerThread):
     77        (WebCore::SharedWorkerContextManager::Connection::postConnectEvent):
     78        (WebCore::SharedWorkerContextManager::Connection::terminateSharedWorker):
     79        * workers/shared/context/SharedWorkerContextManager.h: Added.
     80        (WebCore::SharedWorkerContextManager::Connection::~Connection):
     81        (WebCore::SharedWorkerContextManager::Connection::isClosed const):
     82        (WebCore::SharedWorkerContextManager::Connection::setAsClosed):
     83        * workers/shared/context/SharedWorkerThreadProxy.cpp:
     84        (WebCore::generateWorkerParameters):
     85        (WebCore::SharedWorkerThreadProxy::SharedWorkerThreadProxy):
     86        (WebCore::SharedWorkerThreadProxy::~SharedWorkerThreadProxy):
     87        (WebCore::SharedWorkerThreadProxy::notifyNetworkStateChange):
     88        (WebCore::SharedWorkerThreadProxy::postExceptionToWorkerObject):
     89        (WebCore::SharedWorkerThreadProxy::createCacheStorageConnection):
     90        (WebCore::SharedWorkerThreadProxy::createRTCDataChannelRemoteHandlerConnection):
     91        (WebCore::SharedWorkerThreadProxy::postTaskToLoader):
     92        (WebCore::SharedWorkerThreadProxy::postTaskForModeToWorkerOrWorkletGlobalScope):
     93        (WebCore::SharedWorkerThreadProxy::networkStateChanged):
     94        (WebCore::SharedWorkerThreadProxy::startWorkerGlobalScope): Deleted.
     95        (WebCore::SharedWorkerThreadProxy::terminateWorkerGlobalScope): Deleted.
     96        (WebCore::SharedWorkerThreadProxy::postMessageToWorkerGlobalScope): Deleted.
     97        (WebCore::SharedWorkerThreadProxy::postTaskToWorkerGlobalScope): Deleted.
     98        (WebCore::SharedWorkerThreadProxy::hasPendingActivity const): Deleted.
     99        (WebCore::SharedWorkerThreadProxy::workerObjectDestroyed): Deleted.
     100        (WebCore::SharedWorkerThreadProxy::suspendForBackForwardCache): Deleted.
     101        (WebCore::SharedWorkerThreadProxy::resumeForBackForwardCache): Deleted.
     102        (WebCore::SharedWorkerThreadProxy::workerGlobalScopeDestroyed): Deleted.
     103        (WebCore::SharedWorkerThreadProxy::postMessageToWorkerObject): Deleted.
     104        (WebCore::SharedWorkerThreadProxy::confirmMessageFromWorkerObject): Deleted.
     105        (WebCore::SharedWorkerThreadProxy::reportPendingActivity): Deleted.
     106        (WebCore::SharedWorkerThreadProxy::workerGlobalScopeDestroyedInternal): Deleted.
     107        * workers/shared/context/SharedWorkerThreadProxy.h:
     108
    11092022-02-07  Megan Gardner  <megan_gardner@apple.com>
    2110

  • trunk/Source/WebCore/Headers.cmake

    r289210 r289247  
    19651965    workers/WorkerGlobalScope.h
    19661966    workers/WorkerLoaderProxy.h
     1967    workers/WorkerObjectProxy.h
     1968    workers/WorkerOptions.h
    19671969    workers/WorkerOrWorkletGlobalScope.h
    19681970    workers/WorkerOrWorkletScriptController.h
    19691971    workers/WorkerOrWorkletThread.h
     1972    workers/WorkerReportingProxy.h
    19701973    workers/WorkerRunLoop.h
    19711974    workers/WorkerScriptLoader.h
    … …  
    20112014
    20122015    workers/shared/SharedWorkerIdentifier.h
    2013     workers/shared/SharedWorkerManager.h
     2016    workers/shared/SharedWorkerKey.h
    20142017    workers/shared/SharedWorkerObjectConnection.h
     2018    workers/shared/SharedWorkerObjectIdentifier.h
    20152019    workers/shared/SharedWorkerProvider.h
     2020
     2021    workers/shared/context/SharedWorkerContextManager.h
    20162022    workers/shared/context/SharedWorkerThread.h
    20172023    workers/shared/context/SharedWorkerThreadProxy.h

  • trunk/Source/WebCore/Modules/indexeddb/IDBDatabaseIdentifier.h

    r284857 r289247  
    2828#include "ClientOrigin.h"
    2929#include "SecurityOriginData.h"
    30 #include <wtf/text/StringHash.h>
    31 #include <wtf/text/WTFString.h>
    3230
    3331namespace WebCore {
    … …  
    5048    {
    5149        return m_databaseName.isHashTableDeletedValue();
    52     }
    53 
    54     unsigned hash() const
    55     {
    56         unsigned nameHash = StringHash::hash(m_databaseName);
    57         unsigned originHash = m_origin.hash();
    58         unsigned transientHash = m_isTransient;
    59 
    60         unsigned hashCodes[3] = { nameHash, originHash, transientHash };
    61         return StringHasher::hashMemory<sizeof(hashCodes)>(hashCodes);
    6250    }
    6351
    … …  
    10088};
    10189
     90inline void add(Hasher& hasher, const IDBDatabaseIdentifier& identifier)
     91{
     92    add(hasher, identifier.databaseName(), identifier.origin(), identifier.isTransient());
     93}
     94
    10295struct IDBDatabaseIdentifierHash {
    103     static unsigned hash(const IDBDatabaseIdentifier& a) { return a.hash(); }
     96    static unsigned hash(const IDBDatabaseIdentifier& a) { return computeHash(a); }
    10497    static bool equal(const IDBDatabaseIdentifier& a, const IDBDatabaseIdentifier& b) { return a == b; }
    10598    static const bool safeToCompareToEmptyOrDeleted = false;

  • trunk/Source/WebCore/Sources.txt

    r289222 r289247  
    27882788workers/shared/SharedWorker.cpp
    27892789workers/shared/SharedWorkerGlobalScope.cpp
    2790 workers/shared/SharedWorkerManager.cpp
    27912790workers/shared/SharedWorkerObjectConnection.cpp
    27922791workers/shared/SharedWorkerProvider.cpp
    27932792workers/shared/SharedWorkerScriptLoader.cpp
     2793workers/shared/context/SharedWorkerContextManager.cpp
    27942794workers/shared/context/SharedWorkerThread.cpp
    27952795workers/shared/context/SharedWorkerThreadProxy.cpp

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

    r289222 r289247  
    904904                2E43464D0F546A8200B0F1BA /* WorkerLocation.h in Headers */ = {isa = PBXBuildFile; fileRef = 2E43463B0F546A8200B0F1BA /* WorkerLocation.h */; };
    905905                2E4346500F546A8200B0F1BA /* WorkerMessagingProxy.h in Headers */ = {isa = PBXBuildFile; fileRef = 2E43463E0F546A8200B0F1BA /* WorkerMessagingProxy.h */; };
    906                 2E4346510F546A8200B0F1BA /* WorkerObjectProxy.h in Headers */ = {isa = PBXBuildFile; fileRef = 2E43463F0F546A8200B0F1BA /* WorkerObjectProxy.h */; };
     906                2E4346510F546A8200B0F1BA /* WorkerObjectProxy.h in Headers */ = {isa = PBXBuildFile; fileRef = 2E43463F0F546A8200B0F1BA /* WorkerObjectProxy.h */; settings = {ATTRIBUTES = (Private, ); }; };
    907907                2E4346530F546A8200B0F1BA /* WorkerRunLoop.h in Headers */ = {isa = PBXBuildFile; fileRef = 2E4346410F546A8200B0F1BA /* WorkerRunLoop.h */; settings = {ATTRIBUTES = (Private, ); }; };
    908908                2E4346550F546A8200B0F1BA /* WorkerThread.h in Headers */ = {isa = PBXBuildFile; fileRef = 2E4346430F546A8200B0F1BA /* WorkerThread.h */; settings = {ATTRIBUTES = (Private, ); }; };
    … …  
    11261126                416D75A220C651A500D02D2C /* NetworkLoadInformation.h in Headers */ = {isa = PBXBuildFile; fileRef = 416D759F20C6441300D02D2C /* NetworkLoadInformation.h */; settings = {ATTRIBUTES = (Private, ); }; };
    11271127                416E0B3A209BC3CB004A95D9 /* FetchIdentifier.h in Headers */ = {isa = PBXBuildFile; fileRef = 416E0B37209BC3C2004A95D9 /* FetchIdentifier.h */; settings = {ATTRIBUTES = (Private, ); }; };
    1128                 416E29A6102FA962007FC14E /* WorkerReportingProxy.h in Headers */ = {isa = PBXBuildFile; fileRef = 416E29A5102FA962007FC14E /* WorkerReportingProxy.h */; };
     1128                416E29A6102FA962007FC14E /* WorkerReportingProxy.h in Headers */ = {isa = PBXBuildFile; fileRef = 416E29A5102FA962007FC14E /* WorkerReportingProxy.h */; settings = {ATTRIBUTES = (Private, ); }; };
    11291129                416E6FE81BBD12DF000A3F64 /* ReadableStreamInternalsBuiltins.h in Headers */ = {isa = PBXBuildFile; fileRef = 9B03D8061BB3110D00B764D9 /* ReadableStreamInternalsBuiltins.h */; settings = {ATTRIBUTES = (Private, ); }; };
    11301130                416E6FE81BBD12DF000A3F65 /* JSDOMBindingInternalsBuiltins.h in Headers */ = {isa = PBXBuildFile; fileRef = 9B03D8061BB3110D00B764DA /* JSDOMBindingInternalsBuiltins.h */; settings = {ATTRIBUTES = (Private, ); }; };
    … …  
    13481348                467A68D8275EA995009B31C5 /* SharedWorkerScriptLoader.h in Headers */ = {isa = PBXBuildFile; fileRef = 467A68D5275EA98C009B31C5 /* SharedWorkerScriptLoader.h */; };
    13491349                467A68D9275EA998009B31C5 /* SharedWorkerThreadProxy.h in Headers */ = {isa = PBXBuildFile; fileRef = 467A68D6275EA98C009B31C5 /* SharedWorkerThreadProxy.h */; settings = {ATTRIBUTES = (Private, ); }; };
    1350                 467A68DA275EA99C009B31C5 /* SharedWorkerManager.h in Headers */ = {isa = PBXBuildFile; fileRef = 467A68D2275EA98A009B31C5 /* SharedWorkerManager.h */; settings = {ATTRIBUTES = (Private, ); }; };
    13511350                4682D2001F79783000C863DB /* StoredCredentialsPolicy.h in Headers */ = {isa = PBXBuildFile; fileRef = 4682D1FF1F79782300C863DB /* StoredCredentialsPolicy.h */; settings = {ATTRIBUTES = (Private, ); }; };
    13521351                468344E01EDDFAAA00B7795B /* DOMRectList.h in Headers */ = {isa = PBXBuildFile; fileRef = 468344DE1EDDFA5F00B7795B /* DOMRectList.h */; settings = {ATTRIBUTES = (Private, ); }; };
    … …  
    13541353                4683DF412767E91A007D00C8 /* ShadowRealmGlobalScope.h in Headers */ = {isa = PBXBuildFile; fileRef = 4683DF3B2767DF26007D00C8 /* ShadowRealmGlobalScope.h */; settings = {ATTRIBUTES = (Private, ); }; };
    13551354                4688EE3C26DD2610002AF5C4 /* CrossOriginMode.h in Headers */ = {isa = PBXBuildFile; fileRef = 4688EE3A26DD260C002AF5C4 /* CrossOriginMode.h */; settings = {ATTRIBUTES = (Private, ); }; };
     1355                46943DC92763F817004B610E /* SharedWorkerObjectIdentifier.h in Headers */ = {isa = PBXBuildFile; fileRef = 46943DC72763F80E004B610E /* SharedWorkerObjectIdentifier.h */; settings = {ATTRIBUTES = (Private, ); }; };
     1356                46985F2327A4A6AD0097A32B /* SharedWorkerKey.h in Headers */ = {isa = PBXBuildFile; fileRef = 46985F2227A4A6860097A32B /* SharedWorkerKey.h */; settings = {ATTRIBUTES = (Private, ); }; };
    13561357                469CCCFE269D021C006E0314 /* BroadcastChannel.h in Headers */ = {isa = PBXBuildFile; fileRef = 469CCCFC269D0202006E0314 /* BroadcastChannel.h */; settings = {ATTRIBUTES = (Private, ); }; };
    13571358                469D77B82701625100142FA6 /* NavigationRequester.h in Headers */ = {isa = PBXBuildFile; fileRef = 469D77B62701625000142FA6 /* NavigationRequester.h */; settings = {ATTRIBUTES = (Private, ); }; };
     1359                46A78B342799BD71001154FE /* WorkerOptions.h in Headers */ = {isa = PBXBuildFile; fileRef = 5C1B1D2626F18A4B00882DA2 /* WorkerOptions.h */; settings = {ATTRIBUTES = (Private, ); }; };
    13581360                46AAAA3D25D3632000BAF42F /* AudioFileReaderCocoa.h in Headers */ = {isa = PBXBuildFile; fileRef = 46AAAA3A25D3631400BAF42F /* AudioFileReaderCocoa.h */; };
    13591361                46B63F6C1C6E8D19002E914B /* JSEventTargetCustom.h in Headers */ = {isa = PBXBuildFile; fileRef = 46B63F6B1C6E8CDF002E914B /* JSEventTargetCustom.h */; settings = {ATTRIBUTES = (Private, ); }; };
    … …  
    13761378                46C83EFE1A9BBE2900A79A41 /* GeoNotifier.h in Headers */ = {isa = PBXBuildFile; fileRef = 46C83EFC1A9BBE2900A79A41 /* GeoNotifier.h */; settings = {ATTRIBUTES = (Private, ); }; };
    13771379                46CA9C441F97BBE9004CFC3A /* VisibilityState.h in Headers */ = {isa = PBXBuildFile; fileRef = 46CA9C411F97BBE7004CFC3A /* VisibilityState.h */; settings = {ATTRIBUTES = (Private, ); }; };
     1380                46CF504A27AB1EA40070DBC8 /* SharedWorkerContextManager.h in Headers */ = {isa = PBXBuildFile; fileRef = 46CF504827AB1EA10070DBC8 /* SharedWorkerContextManager.h */; settings = {ATTRIBUTES = (Private, ); }; };
    13781381                46D0004026A0FEB300D1BF1E /* SubmitEvent.h in Headers */ = {isa = PBXBuildFile; fileRef = 46D0003E26A0FE6F00D1BF1E /* SubmitEvent.h */; };
    13791382                46DA4A0227AB039300E375A8 /* TransferredMessagePort.h in Headers */ = {isa = PBXBuildFile; fileRef = 46DA4A0027AB038D00E375A8 /* TransferredMessagePort.h */; settings = {ATTRIBUTES = (Private, ); }; };
    … …  
    92499252                467A68D0275EA989009B31C5 /* SharedWorkerThread.cpp */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.cpp.cpp; path = SharedWorkerThread.cpp; sourceTree = "<group>"; };
    92509253                467A68D1275EA98A009B31C5 /* SharedWorkerScriptLoader.cpp */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.cpp.cpp; path = SharedWorkerScriptLoader.cpp; sourceTree = "<group>"; };
    9251                 467A68D2275EA98A009B31C5 /* SharedWorkerManager.h */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.c.h; path = SharedWorkerManager.h; sourceTree = "<group>"; };
    9252                 467A68D3275EA98B009B31C5 /* SharedWorkerManager.cpp */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.cpp.cpp; path = SharedWorkerManager.cpp; sourceTree = "<group>"; };
    92539254                467A68D4275EA98B009B31C5 /* SharedWorkerThread.h */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.c.h; path = SharedWorkerThread.h; sourceTree = "<group>"; };
    92549255                467A68D5275EA98C009B31C5 /* SharedWorkerScriptLoader.h */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.c.h; path = SharedWorkerScriptLoader.h; sourceTree = "<group>"; };
    … …  
    92669267                4688EE3A26DD260C002AF5C4 /* CrossOriginMode.h */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.c.h; path = CrossOriginMode.h; sourceTree = "<group>"; };
    92679268                468B8BDE25CC849300F67822 /* JSBaseAudioContextCustom.cpp */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.cpp.cpp; path = JSBaseAudioContextCustom.cpp; sourceTree = "<group>"; };
     9269                46943DC72763F80E004B610E /* SharedWorkerObjectIdentifier.h */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.c.h; path = SharedWorkerObjectIdentifier.h; sourceTree = "<group>"; };
     9270                46985F2227A4A6860097A32B /* SharedWorkerKey.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = SharedWorkerKey.h; sourceTree = "<group>"; };
    92689271                469CCCFA269D0202006E0314 /* BroadcastChannel.cpp */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.cpp.cpp; path = BroadcastChannel.cpp; sourceTree = "<group>"; };
    92699272                469CCCFC269D0202006E0314 /* BroadcastChannel.h */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.c.h; path = BroadcastChannel.h; sourceTree = "<group>"; };
    … …  
    93069309                46CA9C411F97BBE7004CFC3A /* VisibilityState.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = VisibilityState.h; sourceTree = "<group>"; };
    93079310                46CA9C421F97BBE7004CFC3A /* VisibilityState.idl */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text; path = VisibilityState.idl; sourceTree = "<group>"; };
     9311                46CF504827AB1EA10070DBC8 /* SharedWorkerContextManager.h */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.c.h; path = SharedWorkerContextManager.h; sourceTree = "<group>"; };
     9312                46CF504927AB1EA10070DBC8 /* SharedWorkerContextManager.cpp */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.cpp.cpp; path = SharedWorkerContextManager.cpp; sourceTree = "<group>"; };
    93089313                46D0003C26A0FE6F00D1BF1E /* SubmitEvent.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = SubmitEvent.cpp; sourceTree = "<group>"; };
    93099314                46D0003E26A0FE6F00D1BF1E /* SubmitEvent.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = SubmitEvent.h; sourceTree = "<group>"; };
    … …  
    2158021585                        isa = PBXGroup;
    2158121586                        children = (
     21587                                46CF504927AB1EA10070DBC8 /* SharedWorkerContextManager.cpp */,
     21588                                46CF504827AB1EA10070DBC8 /* SharedWorkerContextManager.h */,
    2158221589                                467A68D0275EA989009B31C5 /* SharedWorkerThread.cpp */,
    2158321590                                467A68D4275EA98B009B31C5 /* SharedWorkerThread.h */,
    … …  
    2159921606                                46694CE02759448C00E3150E /* SharedWorkerGlobalScope.idl */,
    2160021607                                46EC444827AB337F00FFCD96 /* SharedWorkerIdentifier.h */,
    21601                                 467A68D3275EA98B009B31C5 /* SharedWorkerManager.cpp */,
    21602                                 467A68D2275EA98A009B31C5 /* SharedWorkerManager.h */,
     21608                                46985F2227A4A6860097A32B /* SharedWorkerKey.h */,
    2160321609                                4668A0B327AB600B00C720BC /* SharedWorkerObjectConnection.cpp */,
    2160421610                                4668A0B127AB600B00C720BC /* SharedWorkerObjectConnection.h */,
     21611                                46943DC72763F80E004B610E /* SharedWorkerObjectIdentifier.h */,
    2160521612                                4668A0B427AB600C00C720BC /* SharedWorkerProvider.cpp */,
    2160621613                                4668A0B527AB600C00C720BC /* SharedWorkerProvider.h */,
    … …  
    3722237229                                93309EA3099EB78C0056E581 /* SharedTimer.h in Headers */,
    3722337230                                41DC04FE27A83C93008CF968 /* SharedVideoFrameInfo.h in Headers */,
     37231                                46CF504A27AB1EA40070DBC8 /* SharedWorkerContextManager.h in Headers */,
    3722437232                                46EC444A27AB338900FFCD96 /* SharedWorkerIdentifier.h in Headers */,
    37225                                 467A68DA275EA99C009B31C5 /* SharedWorkerManager.h in Headers */,
     37233                                46985F2327A4A6AD0097A32B /* SharedWorkerKey.h in Headers */,
    3722637234                                4668A0B627AB601B00C720BC /* SharedWorkerObjectConnection.h in Headers */,
     37235                                46943DC92763F817004B610E /* SharedWorkerObjectIdentifier.h in Headers */,
    3722737236                                4668A0B727AB602100C720BC /* SharedWorkerProvider.h in Headers */,
    3722837237                                467A68D8275EA995009B31C5 /* SharedWorkerScriptLoader.h in Headers */,
    … …  
    3808538094                                A5CB05251FB51F3A00089B97 /* WorkerNetworkAgent.h in Headers */,
    3808638095                                2E4346510F546A8200B0F1BA /* WorkerObjectProxy.h in Headers */,
     38096                                46A78B342799BD71001154FE /* WorkerOptions.h in Headers */,
    3808738097                                83D6AAE62524EE1C00428B4B /* WorkerOrWorkletGlobalScope.h in Headers */,
    3808838098                                839A095D2524F37F00EEF328 /* WorkerOrWorkletScriptController.h in Headers */,

  • trunk/Source/WebCore/page/ClientOrigin.h

    r288078 r289247  
    2929#include "SecurityOriginData.h"
    3030#include <wtf/HashTraits.h>
     31#include <wtf/Hasher.h>
    3132#include <wtf/URL.h>
    3233
    … …  
    3637    static ClientOrigin emptyKey() { return { }; }
    3738
    38     unsigned hash() const;
    3939    bool operator==(const ClientOrigin&) const;
    4040    bool operator!=(const ClientOrigin& other) const { return !(*this == other); }
    … …  
    5252};
    5353
    54 inline unsigned ClientOrigin::hash() const
     54inline void add(Hasher& hasher, const ClientOrigin& origin)
    5555{
    56     unsigned hashes[2];
    57     hashes[0] = SecurityOriginDataHash::hash(topOrigin);
    58     hashes[1] = SecurityOriginDataHash::hash(clientOrigin);
    59 
    60     return StringHasher::hashMemory(hashes, sizeof(hashes));
     56    add(hasher, origin.topOrigin, origin.clientOrigin);
    6157}
    6258
    … …  
    9692
    9793struct ClientOriginKeyHash {
    98     static unsigned hash(const WebCore::ClientOrigin& key) { return key.hash(); }
     94    static unsigned hash(const WebCore::ClientOrigin& key) { return computeHash(key); }
    9995    static bool equal(const WebCore::ClientOrigin& a, const WebCore::ClientOrigin& b) { return a == b; }
    10096    static const bool safeToCompareToEmptyOrDeleted = false;

  • trunk/Source/WebCore/page/SecurityOrigin.h

    r288936 r289247  
    151151    bool canAccessPluginStorage(const SecurityOrigin& topOrigin) const { return canAccessStorage(&topOrigin); }
    152152    bool canAccessApplicationCache(const SecurityOrigin& topOrigin) const { return canAccessStorage(&topOrigin); }
    153     bool canAccessSharedWorkers(const SecurityOrigin& topOrigin) const { return canAccessStorage(&topOrigin); }
    154153    bool canAccessCookies() const { return !isUnique(); }
    155154    bool canRequestGeolocation() const { return !isUnique(); }

  • trunk/Source/WebCore/page/SecurityOriginData.h

    r288936 r289247  
    2626#pragma once
    2727
     28#include <wtf/Hasher.h>
    2829#include <wtf/URL.h>
    2930
    … …  
    9899inline bool operator!=(const SecurityOriginData& first, const SecurityOriginData& second) { return !(first == second); }
    99100
     101inline void add(Hasher& hasher, const SecurityOriginData& data)
     102{
     103    add(hasher, data.protocol, data.host, data.port.value_or(0));
     104}
     105
    100106template<class Encoder>
    101107void SecurityOriginData::encode(Encoder& encoder) const
    … …  
    138144
    139145struct SecurityOriginDataHash {
    140     static unsigned hash(const SecurityOriginData& data)
    141     {
    142         unsigned hashCodes[3] = {
    143             data.protocol.impl() ? data.protocol.impl()->hash() : 0,
    144             data.host.impl() ? data.host.impl()->hash() : 0,
    145             data.port.value_or(0)
    146         };
    147         return StringHasher::hashMemory<sizeof(hashCodes)>(hashCodes);
    148     }
     146    static unsigned hash(const SecurityOriginData& data) { return computeHash(data); }
    149147    static bool equal(const SecurityOriginData& a, const SecurityOriginData& b) { return a == b; }
    150148    static const bool safeToCompareToEmptyOrDeleted = false;

  • trunk/Source/WebCore/platform/Logging.h

    r289139 r289247  
    129129    M(WebRTC) \
    130130    M(WebRTCStats) \
     131    M(Worker) \
    131132    M(XR) \
    132133    M(WheelEventTestMonitor) \

  • trunk/Source/WebCore/workers/WorkerThread.cpp

    r289153 r289247  
    3535#include "WorkerScriptFetcher.h"
    3636#include <JavaScriptCore/ScriptCallStack.h>
     37#include <wtf/SetForScope.h>
    3738#include <wtf/Threading.h>
    3839
    … …  
    135136void WorkerThread::evaluateScriptIfNecessary(String& exceptionMessage)
    136137{
     138    SetForScope<bool> isInStaticScriptEvaluation(m_isInStaticScriptEvaluation, true);
     139
    137140    // We are currently holding only the initial script code. If the WorkerType is Module, we should fetch the entire graph before executing the rest of this.
    138141    // We invoke module loader as if we are executing inline module script tag in Document.

  • trunk/Source/WebCore/workers/WorkerThread.h

    r289153 r289247  
    9797   
    9898    JSC::RuntimeFlags runtimeFlags() const { return m_runtimeFlags; }
     99    bool isInStaticScriptEvaluation() const { return m_isInStaticScriptEvaluation; }
    99100
    100101protected:
    … …  
    133134    RefPtr<IDBClient::IDBConnectionProxy> m_idbConnectionProxy;
    134135    RefPtr<SocketProvider> m_socketProvider;
     136    bool m_isInStaticScriptEvaluation { false };
    135137};
    136138

  • trunk/Source/WebCore/workers/shared/SharedWorker.cpp

    r289054 r289247  
    11/*
    2  * Copyright (C) 2021 Apple Inc. All rights reserved.
     2 * Copyright (C) 2021-2022 Apple Inc. All rights reserved.
    33 *
    44 * Redistribution and use in source and binary forms, with or without
    … …  
    2727#include "SharedWorker.h"
    2828
     29#include "ClientOrigin.h"
    2930#include "ContentSecurityPolicy.h"
    3031#include "Document.h"
     32#include "EventNames.h"
     33#include "Logging.h"
    3134#include "MessageChannel.h"
    3235#include "MessagePort.h"
     36#include "ResourceError.h"
    3337#include "SecurityOrigin.h"
    34 #include "SharedWorkerManager.h"
    3538#include "SharedWorkerObjectConnection.h"
    3639#include "SharedWorkerProvider.h"
    37 #include "SharedWorkerThreadProxy.h"
    3840#include "WorkerOptions.h"
    3941#include <JavaScriptCore/IdentifiersFactory.h>
    … …  
    4446WTF_MAKE_ISO_ALLOCATED_IMPL(SharedWorker);
    4547
     48#define SHARED_WORKER_RELEASE_LOG(fmt, ...) RELEASE_LOG(SharedWorker, "%p - [identifier=%{public}s] SharedWorker::" fmt, this, m_identifier.toString().utf8().data(), ##__VA_ARGS__)
     49#define SHARED_WORKER_RELEASE_LOG_ERROR(fmt, ...) RELEASE_LOG_ERROR(SharedWorker, "%p - [identifier=%{public}s] SharedWorker::" fmt, this, m_identifier.toString().utf8().data(), ##__VA_ARGS__)
     50
     51static HashMap<SharedWorkerObjectIdentifier, SharedWorker*>& allSharedWorkers()
     52{
     53    ASSERT(isMainThread());
     54    static NeverDestroyed<HashMap<SharedWorkerObjectIdentifier, SharedWorker*>> allSharedWorkers;
     55    return allSharedWorkers;
     56}
     57
     58SharedWorker* SharedWorker::fromIdentifier(SharedWorkerObjectIdentifier identifier)
     59{
     60    return allSharedWorkers().get(identifier);
     61}
     62
    4663static inline SharedWorkerObjectConnection* mainThreadConnection()
    4764{
    … …  
    4966}
    5067
    51 ExceptionOr<Ref<SharedWorker>> SharedWorker::create(Document& document, JSC::RuntimeFlags runtimeFlags, String&& scriptURLString, std::optional<std::variant<String, WorkerOptions>>&& maybeOptions)
     68ExceptionOr<Ref<SharedWorker>> SharedWorker::create(Document& document, String&& scriptURLString, std::optional<std::variant<String, WorkerOptions>>&& maybeOptions)
    5269{
    5370    if (!mainThreadConnection())
    5471        return Exception { NotSupportedError, "Shared workers are not supported" };
    5572
    56     if (!document.securityOrigin().canAccessSharedWorkers(document.topOrigin()))
    57         return Exception { SecurityError, "This iframe doesn't have storage access"_s };
    58 
    5973    auto url = document.completeURL(scriptURLString);
    6074    if (!url.isValid())
    6175        return Exception { SyntaxError, "Invalid script URL"_s };
     76
     77    if (url.isLocalFile())
     78        return Exception { SecurityError, "Cannot construct a shared worker with a file:// URL"_s };
    6279
    6380    if (auto* contentSecurityPolicy = document.contentSecurityPolicy()) {
    … …  
    7895    auto transferredPort = channel->port2().disentangle();
    7996
    80     auto sharedWorker = adoptRef(*new SharedWorker(document, channel->port1(), runtimeFlags));
     97    ClientOrigin clientOrigin { document.topDocument().securityOrigin().data(), document.securityOrigin().data() };
     98    SharedWorkerKey key { clientOrigin, url, options.name };
     99
     100    auto sharedWorker = adoptRef(*new SharedWorker(document, key, channel->port1()));
    81101    sharedWorker->suspendIfNeeded();
    82102
    83     mainThreadConnection()->requestSharedWorker(url, sharedWorker.get(), WTFMove(transferredPort), WTFMove(options));
     103    mainThreadConnection()->requestSharedWorker(key, sharedWorker->identifier(), WTFMove(transferredPort), options);
    84104    return sharedWorker;
    85105}
    86106
    87 SharedWorker::SharedWorker(Document& document, Ref<MessagePort>&& port, JSC::RuntimeFlags runtimeFlags)
     107SharedWorker::SharedWorker(Document& document, const SharedWorkerKey& key, Ref<MessagePort>&& port)
    88108    : ActiveDOMObject(&document)
     109    , m_key(key)
     110    , m_identifier(SharedWorkerObjectIdentifier::generate())
    89111    , m_port(WTFMove(port))
    90112    , m_identifierForInspector("SharedWorker:" + Inspector::IdentifiersFactory::createIdentifier())
    91     , m_runtimeFlags(runtimeFlags)
    92     , m_creationTime(MonotonicTime::now())
    93     , m_proxy(SharedWorkerThreadProxy::create(*this))
    94113{
     114    SHARED_WORKER_RELEASE_LOG("SharedWorker:");
     115    allSharedWorkers().add(m_identifier, this);
     116
     117    // If the shared worker URL is a blob URL, make sure to keep it alive until the worker has finished loading.
     118    if (m_key.url.protocolIsBlob())
     119        m_blobURLExtension = m_key.url;
    95120}
    96121
    97122SharedWorker::~SharedWorker()
    98123{
    99     m_proxy.workerObjectDestroyed();
     124    ASSERT(allSharedWorkers().get(m_identifier) == this);
     125    SHARED_WORKER_RELEASE_LOG("~SharedWorker:");
     126    allSharedWorkers().remove(m_identifier);
     127    ASSERT(!m_isActive);
    100128}
    101129
    … …  
    115143}
    116144
    117 void SharedWorker::stop()
     145void SharedWorker::didFinishLoading(const ResourceError& error)
    118146{
    119     terminate();
     147    SHARED_WORKER_RELEASE_LOG("finishLoading: success=%d", error.isNull());
     148    if (!error.isNull()) {
     149        queueTaskToDispatchEvent(*this, TaskSource::DOMManipulation, Event::create(eventNames().errorEvent, Event::CanBubble::No, Event::IsCancelable::Yes));
     150        m_isActive = false;
     151    }
     152    m_blobURLExtension.clear();
    120153}
    121154
    122155bool SharedWorker::virtualHasPendingActivity() const
    123156{
    124     return m_proxy.hasPendingActivity() || m_isLoading;
     157    return m_isActive;
    125158}
    126159
    127 void SharedWorker::terminate()
     160void SharedWorker::stop()
    128161{
    129     m_proxy.terminateWorkerGlobalScope();
     162    SHARED_WORKER_RELEASE_LOG("stop:");
     163    m_isActive = false;
     164    mainThreadConnection()->sharedWorkerObjectIsGoingAway(m_key, m_identifier);
    130165}
    131166
     167#undef SHARED_WORKER_RELEASE_LOG
     168#undef SHARED_WORKER_RELEASE_LOG_ERROR
     169
    132170} // namespace WebCore

  • trunk/Source/WebCore/workers/shared/SharedWorker.h

    r288975 r289247  
    11/*
    2  * Copyright (C) 2021 Apple Inc. All rights reserved.
     2 * Copyright (C) 2021-2022 Apple Inc. All rights reserved.
    33 *
    44 * Redistribution and use in source and binary forms, with or without
    … …  
    2828#include "AbstractWorker.h"
    2929#include "ActiveDOMObject.h"
    30 #include <JavaScriptCore/RuntimeFlags.h>
     30#include "BlobURL.h"
     31#include "SharedWorkerKey.h"
     32#include "SharedWorkerObjectIdentifier.h"
    3133#include <wtf/MonotonicTime.h>
    3234
    … …  
    3436
    3537class MessagePort;
    36 class SharedWorkerThreadProxy;
     38class ResourceError;
    3739
    3840struct WorkerOptions;
    … …  
    4143    WTF_MAKE_ISO_ALLOCATED(SharedWorker);
    4244public:
    43     static ExceptionOr<Ref<SharedWorker>> create(Document&, JSC::RuntimeFlags, String&& scriptURL, std::optional<std::variant<String, WorkerOptions>>&&);
     45    static ExceptionOr<Ref<SharedWorker>> create(Document&, String&& scriptURL, std::optional<std::variant<String, WorkerOptions>>&&);
    4446    ~SharedWorker();
    4547
     48    static SharedWorker* fromIdentifier(SharedWorkerObjectIdentifier);
     49    SharedWorkerObjectIdentifier identifier() const { return m_identifier; }
    4650    MessagePort& port() const { return m_port.get(); }
    47     JSC::RuntimeFlags runtimeFlags() { return m_runtimeFlags; }
    4851
    4952    const String& identifierForInspector() const { return m_identifierForInspector; }
    50     MonotonicTime creationTime() const { return m_creationTime; }
    5153
    52     SharedWorkerThreadProxy& proxy() { return m_proxy; }
    53 
    54     void setIsLoading(bool isLoading) { m_isLoading = isLoading; }
     54    void didFinishLoading(const ResourceError&);
    5555
    5656    // EventTarget.
    … …  
    5858
    5959private:
    60     SharedWorker(Document&, Ref<MessagePort>&&, JSC::RuntimeFlags);
    61 
    62     void terminate();
     60    SharedWorker(Document&, const SharedWorkerKey&, Ref<MessagePort>&&);
    6361
    6462    // EventTarget.
    … …  
    7169
    7270
     71    SharedWorkerKey m_key;
     72    SharedWorkerObjectIdentifier m_identifier;
    7373    Ref<MessagePort> m_port;
    7474    String m_identifierForInspector;
    75     JSC::RuntimeFlags m_runtimeFlags;
    76     MonotonicTime m_creationTime;
    77     SharedWorkerThreadProxy& m_proxy; // The proxy outlives the worker to perform thread shutdown.
    78     bool m_isLoading { false };
     75    BlobURLHandle m_blobURLExtension;
     76    bool m_isActive { true };
    7977};
    8078

  • trunk/Source/WebCore/workers/shared/SharedWorker.idl

    r289117 r289247  
    2929]
    3030interface SharedWorker : EventTarget {
    31   [CallWith=CurrentDocument&RuntimeFlags] constructor(USVString scriptURL, optional (DOMString or WorkerOptions) options);
     31  [CallWith=CurrentDocument] constructor(USVString scriptURL, optional (DOMString or WorkerOptions) options);
    3232
    3333  readonly attribute MessagePort port;

  • trunk/Source/WebCore/workers/shared/SharedWorkerObjectConnection.cpp

    r289054 r289247  
    2727#include "SharedWorkerObjectConnection.h"
    2828
     29#include "ActiveDOMObject.h"
     30#include "ErrorEvent.h"
     31#include "Logging.h"
     32#include "ScriptBuffer.h"
     33#include "SharedWorker.h"
     34#include "SharedWorkerScriptLoader.h"
     35#include "WorkerFetchResult.h"
     36
    2937namespace WebCore {
     38
     39#define CONNECTION_RELEASE_LOG(fmt, ...) RELEASE_LOG(SharedWorker, "%p - SharedWorkerObjectConnection::" fmt, this, ##__VA_ARGS__)
     40#define CONNECTION_RELEASE_LOG_ERROR(fmt, ...) RELEASE_LOG_ERROR(SharedWorker, "%p - SharedWorkerObjectConnection::" fmt, this, ##__VA_ARGS__)
     41
     42static uint64_t loaderIdentifierSeed = 0;
    3043
    3144SharedWorkerObjectConnection::SharedWorkerObjectConnection() = default;
    … …  
    3346SharedWorkerObjectConnection::~SharedWorkerObjectConnection() = default;
    3447
     48void SharedWorkerObjectConnection::fetchScriptInClient(URL&& url, WebCore::SharedWorkerObjectIdentifier sharedWorkerObjectIdentifier, WorkerOptions&& workerOptions, CompletionHandler<void(WorkerFetchResult&&)>&& completionHandler)
     49{
     50    ASSERT(isMainThread());
     51
     52    auto* workerObject = SharedWorker::fromIdentifier(sharedWorkerObjectIdentifier);
     53    CONNECTION_RELEASE_LOG("fetchScriptInClient: sharedWorkerObjectIdentifier=%{public}s, worker=%p", sharedWorkerObjectIdentifier.toString().utf8().data(), workerObject);
     54    if (!workerObject)
     55        return completionHandler(workerFetchError(ResourceError { ResourceError::Type::Cancellation }));
     56
     57    auto loaderIdentifier = ++loaderIdentifierSeed;
     58    auto loader = makeUniqueRef<SharedWorkerScriptLoader>(WTFMove(url), *workerObject, WTFMove(workerOptions));
     59    auto loaderPtr = loader.ptr();
     60    m_loaders.add(loaderIdentifier, WTFMove(loader));
     61
     62    loaderPtr->load([this, loaderIdentifier, completionHandler = WTFMove(completionHandler)](WorkerFetchResult&& fetchResult) mutable {
     63        CONNECTION_RELEASE_LOG("fetchScriptInClient: finished script load, success=%d", fetchResult.error.isNull());
     64        auto loader = m_loaders.take(loaderIdentifier);
     65        ASSERT(loader);
     66        completionHandler(WTFMove(fetchResult));
     67    });
     68}
     69
     70void SharedWorkerObjectConnection::notifyWorkerObjectOfLoadCompletion(WebCore::SharedWorkerObjectIdentifier sharedWorkerObjectIdentifier, const ResourceError& error)
     71{
     72    ASSERT(isMainThread());
     73    auto* workerObject = SharedWorker::fromIdentifier(sharedWorkerObjectIdentifier);
     74    CONNECTION_RELEASE_LOG_ERROR("notifyWorkerObjectOfLoadCompletion: sharedWorkerObjectIdentifier=%{public}s, worker=%p, success=%d", sharedWorkerObjectIdentifier.toString().utf8().data(), workerObject, error.isNull());
     75    if (workerObject)
     76        workerObject->didFinishLoading(error);
     77}
     78
     79void SharedWorkerObjectConnection::postExceptionToWorkerObject(SharedWorkerObjectIdentifier sharedWorkerObjectIdentifier, const String& errorMessage, int lineNumber, int columnNumber, const String& sourceURL)
     80{
     81    ASSERT(isMainThread());
     82    auto* workerObject = SharedWorker::fromIdentifier(sharedWorkerObjectIdentifier);
     83    CONNECTION_RELEASE_LOG_ERROR("postExceptionToWorkerObject: sharedWorkerObjectIdentifier=%{public}s, worker=%p", sharedWorkerObjectIdentifier.toString().utf8().data(), workerObject);
     84    if (workerObject)
     85        ActiveDOMObject::queueTaskToDispatchEvent(*workerObject, TaskSource::DOMManipulation, ErrorEvent::create(errorMessage, sourceURL, lineNumber, columnNumber, { }));
     86}
     87
     88#undef CONNECTION_RELEASE_LOG
     89#undef CONNECTION_RELEASE_LOG_ERROR
     90
    3591} // namespace WebCore

  • trunk/Source/WebCore/workers/shared/SharedWorkerObjectConnection.h

    r289054 r289247  
    2626#pragma once
    2727
     28#include "SharedWorkerObjectIdentifier.h"
    2829#include "TransferredMessagePort.h"
     30#include <wtf/Forward.h>
     31#include <wtf/HashMap.h>
    2932#include <wtf/RefCounted.h>
    3033
    3134namespace WebCore {
    3235
    33 class SharedWorker;
     36class MessagePort;
     37class SharedWorkerScriptLoader;
     38
     39struct SharedWorkerKey;
     40struct WorkerFetchResult;
    3441struct WorkerOptions;
    3542
    … …  
    3845    WEBCORE_EXPORT virtual ~SharedWorkerObjectConnection();
    3946
    40     virtual void requestSharedWorker(const URL&, SharedWorker&, TransferredMessagePort&&, WorkerOptions&&) = 0;
     47    virtual void requestSharedWorker(const SharedWorkerKey&, SharedWorkerObjectIdentifier, TransferredMessagePort&&, const WorkerOptions&) = 0;
     48    virtual void sharedWorkerObjectIsGoingAway(const SharedWorkerKey&, SharedWorkerObjectIdentifier) = 0;
    4149
    4250protected:
     51    // IPC messages.
     52    WEBCORE_EXPORT void fetchScriptInClient(URL&&, WebCore::SharedWorkerObjectIdentifier, WorkerOptions&&, CompletionHandler<void(WorkerFetchResult&&)>&&);
     53    WEBCORE_EXPORT void notifyWorkerObjectOfLoadCompletion(WebCore::SharedWorkerObjectIdentifier, const ResourceError&);
     54    WEBCORE_EXPORT void postExceptionToWorkerObject(SharedWorkerObjectIdentifier, const String& errorMessage, int lineNumber, int columnNumber, const String& sourceURL);
     55
    4356    WEBCORE_EXPORT SharedWorkerObjectConnection();
     57
     58private:
     59    HashMap<uint64_t, UniqueRef<SharedWorkerScriptLoader>> m_loaders;
    4460};
    4561

  • trunk/Source/WebCore/workers/shared/SharedWorkerObjectIdentifier.h

    r289246 r289247  
    2424 */
    2525
    26 #include "config.h"
    27 #include "SharedWorkerObjectConnection.h"
     26#pragma once
     27
     28#include "ProcessQualified.h"
     29#include <wtf/ObjectIdentifier.h>
    2830
    2931namespace WebCore {
    3032
    31 SharedWorkerObjectConnection::SharedWorkerObjectConnection() = default;
    32 
    33 SharedWorkerObjectConnection::~SharedWorkerObjectConnection() = default;
     33enum SharedWorkerObjectIdentifierType { };
     34using SharedWorkerObjectIdentifier = ProcessQualified<ObjectIdentifier<SharedWorkerObjectIdentifierType>>;
    3435
    3536} // namespace WebCore

  • trunk/Source/WebCore/workers/shared/SharedWorkerScriptLoader.cpp

    r288701 r289247  
    11/*
    2  * Copyright (C) 2021 Apple Inc. All rights reserved.
     2 * Copyright (C) 2021-2022 Apple Inc. All rights reserved.
    33 *
    44 * Redistribution and use in source and binary forms, with or without
    … …  
    3030#include "InspectorInstrumentation.h"
    3131#include "SharedWorker.h"
    32 #include "SharedWorkerManager.h"
     32#include "WorkerFetchResult.h"
    3333#include "WorkerRunLoop.h"
    3434#include "WorkerScriptLoader.h"
    … …  
    3636namespace WebCore {
    3737
    38 SharedWorkerScriptLoader::SharedWorkerScriptLoader(const URL& url, SharedWorker& worker, TransferredMessagePort&& port, WorkerOptions&& options)
    39     : m_identifier(SharedWorkerScriptLoaderIdentifier::generate())
    40     , m_options(WTFMove(options))
     38SharedWorkerScriptLoader::SharedWorkerScriptLoader(URL&& url, SharedWorker& worker, WorkerOptions&& options)
     39    : m_options(WTFMove(options))
    4140    , m_worker(worker)
    42     , m_port(WTFMove(port))
    4341    , m_loader(WorkerScriptLoader::create())
    44     , m_pendingActivity(worker.makePendingActivity(worker))
    45     , m_url(url)
     42    , m_url(WTFMove(url))
    4643{
    47     m_worker->setIsLoading(true);
    48     m_loader->loadAsynchronously(*worker.scriptExecutionContext(), ResourceRequest(url), worker.workerFetchOptions(options, FetchOptions::Destination::Sharedworker), ContentSecurityPolicyEnforcement::EnforceWorkerSrcDirective, ServiceWorkersMode::All, *this, WorkerRunLoop::defaultMode());
     44}
     45
     46void SharedWorkerScriptLoader::load(CompletionHandler<void(WorkerFetchResult&&)>&& completionHandler)
     47{
     48    ASSERT(!m_completionHandler);
     49    m_completionHandler = WTFMove(completionHandler);
     50
     51    m_loader->loadAsynchronously(*m_worker->scriptExecutionContext(), ResourceRequest(m_url), m_worker->workerFetchOptions(m_options, FetchOptions::Destination::Sharedworker), ContentSecurityPolicyEnforcement::EnforceWorkerSrcDirective, ServiceWorkersMode::All, *this, WorkerRunLoop::defaultMode());
    4952}
    5053
    … …  
    5659void SharedWorkerScriptLoader::notifyFinished()
    5760{
    58     m_worker->setIsLoading(false);
     61    if (m_loader->failed())
     62        return m_completionHandler(workerFetchError(m_loader->error()));
    5963
    60     auto* scriptExecutionContext = m_worker->scriptExecutionContext();
    61     if (m_loader->failed() || !scriptExecutionContext) {
    62         m_worker->dispatchEvent(Event::create(eventNames().errorEvent, Event::CanBubble::No, Event::IsCancelable::Yes));
    63         SharedWorkerManager::singleton().scriptLoadFailed(*this); // deletes this.
    64     } else {
     64    if (auto* scriptExecutionContext = m_worker->scriptExecutionContext())
    6565        InspectorInstrumentation::scriptImported(*scriptExecutionContext, m_loader->identifier(), m_loader->script().toString());
    66         SharedWorkerManager::singleton().scriptLoadedSuccessfully(*this, m_loader->script(), *m_worker->scriptExecutionContext(), m_worker.get(), std::exchange(m_port, { })); // deletes this.
    67     }
     66    m_completionHandler({ m_loader->script(), m_loader->certificateInfo(), m_loader->contentSecurityPolicy(), m_loader->crossOriginEmbedderPolicy(), m_loader->referrerPolicy(), { } }); // deletes this.
    6867}
    6968

  • trunk/Source/WebCore/workers/shared/SharedWorkerScriptLoader.h

    r289107 r289247  
    11/*
    2  * Copyright (C) 2021 Apple Inc. All rights reserved.
     2 * Copyright (C) 2021-2022 Apple Inc. All rights reserved.
    33 *
    44 * Redistribution and use in source and binary forms, with or without
    … …  
    2626#pragma once
    2727
    28 #include "ActiveDOMObject.h"
    2928#include "MessagePortIdentifier.h"
    3029#include "ResourceLoaderIdentifier.h"
    3130#include "ResourceResponse.h"
    32 #include "SharedWorkerManager.h"
    3331#include "WorkerOptions.h"
    3432#include "WorkerScriptLoaderClient.h"
    … …  
    4038class SharedWorker;
    4139class WorkerScriptLoader;
    42 
    43 class SharedWorkerScriptLoader;
    44 
    45 using TransferredMessagePort = std::pair<WebCore::MessagePortIdentifier, WebCore::MessagePortIdentifier>;
     40struct WorkerFetchResult;
    4641
    4742class SharedWorkerScriptLoader : private WorkerScriptLoaderClient {
    4843    WTF_MAKE_FAST_ALLOCATED;
    4944public:
    50     SharedWorkerScriptLoader(const URL&, SharedWorker&, TransferredMessagePort&&, WorkerOptions&&);
     45    SharedWorkerScriptLoader(URL&&, SharedWorker&, WorkerOptions&&);
    5146
    52     SharedWorkerScriptLoaderIdentifier identifier() const { return m_identifier; }
     47    void load(CompletionHandler<void(WorkerFetchResult&&)>&&);
     48
    5349    const URL& url() const { return m_url; }
    5450    SharedWorker& worker() { return m_worker.get(); }
    55     const WorkerOptions& options() { return m_options; }
     51    const WorkerOptions& options() const { return m_options; }
    5652
    5753private:
    … …  
    5955    void notifyFinished() final;
    6056
    61     const SharedWorkerScriptLoaderIdentifier m_identifier;
    6257    const WorkerOptions m_options;
    6358    const Ref<SharedWorker> m_worker;
    64     TransferredMessagePort m_port;
    6559    const Ref<WorkerScriptLoader> m_loader;
    66     const Ref<ActiveDOMObject::PendingActivity<SharedWorker>> m_pendingActivity;
    6760    const URL m_url;
     61    CompletionHandler<void(WorkerFetchResult&&)> m_completionHandler;
    6862};
    6963

  • trunk/Source/WebCore/workers/shared/context/SharedWorkerThreadProxy.cpp

    r289023 r289247  
    11/*
    2  * Copyright (C) 2021 Apple Inc. All rights reserved.
     2 * Copyright (C) 2021-2022 Apple Inc. All rights reserved.
    33 *
    44 * Redistribution and use in source and binary forms, with or without
    … …  
    2929#include "CacheStorageProvider.h"
    3030#include "ErrorEvent.h"
     31#include "EventLoop.h"
    3132#include "EventNames.h"
     33#include "Frame.h"
     34#include "FrameLoader.h"
    3235#include "LibWebRTCProvider.h"
     36#include "LoaderStrategy.h"
    3337#include "MessageEvent.h"
    3438#include "MessagePort.h"
    3539#include "Page.h"
     40#include "PlatformStrategies.h"
    3641#include "RTCDataChannelRemoteHandlerConnection.h"
    3742#include "SharedWorker.h"
     43#include "SharedWorkerContextManager.h"
    3844#include "SharedWorkerGlobalScope.h"
    3945#include "SharedWorkerThread.h"
     46#include "WorkerFetchResult.h"
     47#include "WorkerThread.h"
     48#include <JavaScriptCore/IdentifiersFactory.h>
    4049
    4150namespace WebCore {
    4251
    43 SharedWorkerThreadProxy::SharedWorkerThreadProxy(SharedWorker& sharedWorker)
    44     : m_sharedWorker(sharedWorker)
    45     , m_scriptExecutionContext(sharedWorker.scriptExecutionContext())
    46     , m_identifierForInspector(sharedWorker.identifierForInspector())
     52static HashSet<SharedWorkerThreadProxy*>& allSharedWorkerThreadProxies()
    4753{
     54    static NeverDestroyed<HashSet<SharedWorkerThreadProxy*>> set;
     55    return set;
    4856}
    4957
    50 void SharedWorkerThreadProxy::startWorkerGlobalScope(const URL& scriptURL, const String& name, const String& userAgent, bool isOnline, const ScriptBuffer& scriptBuffer, const ContentSecurityPolicyResponseHeaders& contentSecurityPolicyResponseHeaders, bool shouldBypassMainWorldContentSecurityPolicy, const CrossOriginEmbedderPolicy& crossOriginEmbedderPolicy, MonotonicTime timeOrigin, ReferrerPolicy referrerPolicy, WorkerType workerType, FetchRequestCredentials credentials, JSC::RuntimeFlags runtimeFlags)
     58static WorkerParameters generateWorkerParameters(const URL& scriptURL, const WorkerFetchResult& workerFetchResult, WorkerOptions&& workerOptions, const String& userAgent, Document& document)
    5159{
    52     if (m_askedToTerminate)
    53         return;
     60    return WorkerParameters {
     61        scriptURL,
     62        workerOptions.name,
     63        "sharedworker:" + Inspector::IdentifiersFactory::createIdentifier(),
     64        userAgent,
     65        platformStrategies()->loaderStrategy()->isOnLine(),
     66        workerFetchResult.contentSecurityPolicy,
     67        false,
     68        workerFetchResult.crossOriginEmbedderPolicy,
     69        MonotonicTime::now(),
     70        parseReferrerPolicy(workerFetchResult.referrerPolicy, ReferrerPolicySource::HTTPHeader).value_or(ReferrerPolicy::EmptyString),
     71        workerOptions.type,
     72        workerOptions.credentials,
     73        document.settingsValues()
     74    };
     75}
    5476
    55     auto parameters = WorkerParameters {
    56         scriptURL,
    57         name,
    58         m_identifierForInspector,
    59         userAgent,
    60         isOnline,
    61         contentSecurityPolicyResponseHeaders,
    62         shouldBypassMainWorldContentSecurityPolicy,
    63         crossOriginEmbedderPolicy,
    64         timeOrigin,
    65         referrerPolicy,
    66         workerType,
    67         credentials,
    68         m_scriptExecutionContext->settingsValues()
    69     };
     77SharedWorkerThreadProxy::SharedWorkerThreadProxy(UniqueRef<Page>&& page, SharedWorkerIdentifier sharedWorkerIdentifier, const ClientOrigin& clientOrigin, const URL& scriptURL, WorkerFetchResult&& workerFetchResult, WorkerOptions&& workerOptions, const String& userAgent, CacheStorageProvider& cacheStorageProvider)
     78    : m_page(WTFMove(page))
     79    , m_document(*m_page->mainFrame().document())
     80    , m_workerThread(SharedWorkerThread::create(sharedWorkerIdentifier, generateWorkerParameters(scriptURL, workerFetchResult, WTFMove(workerOptions), userAgent, m_document), WTFMove(workerFetchResult.script), *this, *this, *this, WorkerThreadStartMode::Normal, clientOrigin.topOrigin.securityOrigin(), m_document->idbConnectionProxy(), m_document->socketProvider(), JSC::RuntimeFlags::createAllEnabled()))
     81    , m_cacheStorageProvider(cacheStorageProvider)
     82{
     83    ASSERT(!allSharedWorkerThreadProxies().contains(this));
     84    allSharedWorkerThreadProxies().add(this);
    7085
    71     if (!m_workerThread) {
    72         m_workerThread = SharedWorkerThread::create(SharedWorkerIdentifier::generate(), parameters, scriptBuffer, *this, *this, *this, WorkerThreadStartMode::Normal, m_scriptExecutionContext->topOrigin(), m_scriptExecutionContext->idbConnectionProxy(), m_scriptExecutionContext->socketProvider(), runtimeFlags);
    73         m_workerThread->start();
     86    static bool addedListener;
     87    if (!addedListener) {
     88        platformStrategies()->loaderStrategy()->addOnlineStateChangeListener(&networkStateChanged);
     89        addedListener = true;
    7490    }
    7591}
    7692
    77 void SharedWorkerThreadProxy::terminateWorkerGlobalScope()
     93SharedWorkerThreadProxy::~SharedWorkerThreadProxy()
    7894{
    79     if (m_askedToTerminate)
    80         return;
    81 
    82     m_askedToTerminate = true;
    83     if (m_workerThread)
    84         m_workerThread->stop(nullptr);
    85 }
    86 
    87 void SharedWorkerThreadProxy::postMessageToWorkerGlobalScope(MessageWithMessagePorts&& message)
    88 {
    89     // FIXME: SharedWorker doesn't have postMessage, so this might not be necessary.
    90     postTaskToWorkerGlobalScope([message = WTFMove(message)](auto& scriptContext) mutable {
    91         auto& context = downcast<SharedWorkerGlobalScope>(scriptContext);
    92         auto ports = MessagePort::entanglePorts(scriptContext, WTFMove(message.transferredPorts));
    93         context.dispatchEvent(MessageEvent::create(WTFMove(ports), message.message.releaseNonNull()));
    94     });
    95 }
    96 
    97 void SharedWorkerThreadProxy::postTaskToWorkerGlobalScope(Function<void(ScriptExecutionContext&)>&& task)
    98 {
    99     if (m_askedToTerminate)
    100         return;
    101     m_workerThread->runLoop().postTask(WTFMove(task));
    102 }
    103 
    104 bool SharedWorkerThreadProxy::hasPendingActivity() const
    105 {
    106     return m_hasPendingActivity && !m_askedToTerminate;
    107 }
    108 
    109 void SharedWorkerThreadProxy::workerObjectDestroyed()
    110 {
    111     m_sharedWorker = nullptr;
    112     m_scriptExecutionContext->postTask([this] (auto&) {
    113         m_mayBeDestroyed = true;
    114         if (m_workerThread)
    115             terminateWorkerGlobalScope();
    116         else
    117             workerGlobalScopeDestroyedInternal();
    118     });
     95    ASSERT(allSharedWorkerThreadProxies().contains(this));
     96    allSharedWorkerThreadProxies().remove(this);
    11997}
    12098
    … …  
    126104void SharedWorkerThreadProxy::notifyNetworkStateChange(bool isOnline)
    127105{
    128     if (m_askedToTerminate)
     106    if (m_isTerminatingOrTerminated)
    129107        return;
    130108
    131     if (!m_workerThread)
    132         return;
    133 
    134     m_workerThread->runLoop().postTask([isOnline] (ScriptExecutionContext& context) {
     109    postTaskForModeToWorkerOrWorkletGlobalScope([isOnline] (ScriptExecutionContext& context) {
    135110        auto& globalScope = downcast<WorkerGlobalScope>(context);
    136111        globalScope.setIsOnline(isOnline);
    137         globalScope.dispatchEvent(Event::create(isOnline ? eventNames().onlineEvent : eventNames().offlineEvent, Event::CanBubble::No, Event::IsCancelable::No));
    138     });
    139 }
    140 
    141 void SharedWorkerThreadProxy::suspendForBackForwardCache()
    142 {
    143 
    144 }
    145 
    146 void SharedWorkerThreadProxy::resumeForBackForwardCache()
    147 {
    148 
     112        globalScope.eventLoop().queueTask(TaskSource::DOMManipulation, [globalScope = Ref { globalScope }, isOnline] {
     113            globalScope->dispatchEvent(Event::create(isOnline ? eventNames().onlineEvent : eventNames().offlineEvent, Event::CanBubble::No, Event::IsCancelable::No));
     114        });
     115    }, WorkerRunLoop::defaultMode());
    149116}
    150117
    151118void SharedWorkerThreadProxy::postExceptionToWorkerObject(const String& errorMessage, int lineNumber, int columnNumber, const String& sourceURL)
    152119{
    153     m_scriptExecutionContext->postTask([this, errorMessage = errorMessage.isolatedCopy(), sourceURL = sourceURL.isolatedCopy(), lineNumber, columnNumber] (ScriptExecutionContext&) {
    154         if (!m_sharedWorker)
    155             return;
     120    ASSERT(!isMainThread());
     121    if (!m_workerThread->isInStaticScriptEvaluation())
     122        return;
    156123
    157         // We don't bother checking the askedToTerminate() flag here, because exceptions should *always* be reported even if the thread is terminated.
    158         // This is intentionally different than the behavior in MessageWorkerTask, because terminated workers no longer deliver messages (section 4.6 of the WebWorker spec), but they do report exceptions.
    159         ActiveDOMObject::queueTaskToDispatchEvent(*m_sharedWorker, TaskSource::DOMManipulation, ErrorEvent::create(errorMessage, sourceURL, lineNumber, columnNumber, { }));
    160     });
    161 }
    162 
    163 void SharedWorkerThreadProxy::workerGlobalScopeDestroyed()
    164 {
    165     m_scriptExecutionContext->postTask([this] (ScriptExecutionContext&) {
    166         workerGlobalScopeDestroyedInternal();
    167     });
    168 }
    169 
    170 void SharedWorkerThreadProxy::postMessageToWorkerObject(MessageWithMessagePorts&&)
    171 {
    172 
    173 }
    174 
    175 void SharedWorkerThreadProxy::confirmMessageFromWorkerObject(bool)
    176 {
    177 }
    178 
    179 void SharedWorkerThreadProxy::reportPendingActivity(bool hasPendingActivity)
    180 {
    181     m_scriptExecutionContext->postTask([this, hasPendingActivity] (ScriptExecutionContext&) {
    182         m_hasPendingActivity = hasPendingActivity;
     124    callOnMainThread([sharedWorkerIdentifier = m_workerThread->identifier(), errorMessage = errorMessage.isolatedCopy(), lineNumber, columnNumber, sourceURL = sourceURL.isolatedCopy()] {
     125        if (auto* connection = SharedWorkerContextManager::singleton().connection())
     126            connection->postExceptionToWorkerObject(sharedWorkerIdentifier, errorMessage, lineNumber, columnNumber, sourceURL);
    183127    });
    184128}
    … …  
    187131{
    188132    ASSERT(isMainThread());
    189     auto& document = downcast<Document>(*m_scriptExecutionContext);
    190     return document.page()->cacheStorageProvider().createCacheStorageConnection();
     133    if (!m_cacheStorageConnection)
     134        m_cacheStorageConnection = m_cacheStorageProvider.createCacheStorageConnection();
     135    return m_cacheStorageConnection;
    191136}
    192137
    … …  
    194139{
    195140    ASSERT(isMainThread());
    196     auto& document = downcast<Document>(*m_scriptExecutionContext);
    197     if (!document.page())
    198         return nullptr;
    199     return document.page()->libWebRTCProvider().createRTCDataChannelRemoteHandlerConnection();
     141    return m_page->libWebRTCProvider().createRTCDataChannelRemoteHandlerConnection();
    200142}
    201143
    202144void SharedWorkerThreadProxy::postTaskToLoader(ScriptExecutionContext::Task&& task)
    203145{
    204     m_scriptExecutionContext->postTask(WTFMove(task));
     146    callOnMainThread([task = WTFMove(task), protectedThis = Ref { *this }] () mutable {
     147        task.performTask(protectedThis->m_document.get());
     148    });
    205149}
    206150
    207151bool SharedWorkerThreadProxy::postTaskForModeToWorkerOrWorkletGlobalScope(ScriptExecutionContext::Task&& task, const String& mode)
    208152{
    209     if (m_askedToTerminate)
     153    if (m_isTerminatingOrTerminated)
    210154        return false;
    211155
    … …  
    224168}
    225169
    226 void SharedWorkerThreadProxy::workerGlobalScopeDestroyedInternal()
     170void SharedWorkerThreadProxy::networkStateChanged(bool isOnLine)
    227171{
    228     // This is always the last task to be performed, so the proxy is not needed for communication
    229     // in either side any more. However, the Worker object may still exist, and it assumes that the proxy exists, too.
    230     m_askedToTerminate = true;
    231     m_workerThread = nullptr;
    232 
    233     // This balances the original ref in construction.
    234     if (m_mayBeDestroyed)
    235         deref();
     172    for (auto* proxy : allSharedWorkerThreadProxies())
     173        proxy->notifyNetworkStateChange(isOnLine);
    236174}
    237175

  • trunk/Source/WebCore/workers/shared/context/SharedWorkerThreadProxy.h

    r289023 r289247  
    11/*
    2  * Copyright (C) 2021 Apple Inc. All rights reserved.
     2 * Copyright (C) 2021-2022 Apple Inc. All rights reserved.
    33 *
    44 * Redistribution and use in source and binary forms, with or without
    … …  
    2828#include "SharedWorkerIdentifier.h"
    2929#include "WorkerDebuggerProxy.h"
    30 #include "WorkerGlobalScopeProxy.h"
    3130#include "WorkerLoaderProxy.h"
    3231#include "WorkerObjectProxy.h"
    … …  
    3635namespace WebCore {
    3736
     37class CacheStorageProvider;
     38class Page;
    3839class SharedWorker;
    3940class SharedWorkerThread;
    4041
    41 class SharedWorkerThreadProxy final : public ThreadSafeRefCounted<SharedWorkerThreadProxy>, public WorkerGlobalScopeProxy, public WorkerObjectProxy, public WorkerLoaderProxy, public WorkerDebuggerProxy {
     42struct ClientOrigin;
     43struct WorkerFetchResult;
     44
     45class SharedWorkerThreadProxy final : public ThreadSafeRefCounted<SharedWorkerThreadProxy>, public WorkerObjectProxy, public WorkerLoaderProxy, public WorkerDebuggerProxy {
    4246public:
    43     template<typename... Args> static SharedWorkerThreadProxy& create(Args&&... args) { return *new SharedWorkerThreadProxy(std::forward<Args>(args)...); }
     47    template<typename... Args> static Ref<SharedWorkerThreadProxy> create(Args&&... args) { return adoptRef(*new SharedWorkerThreadProxy(std::forward<Args>(args)...)); }
     48    WEBCORE_EXPORT ~SharedWorkerThreadProxy();
    4449
    4550    SharedWorkerIdentifier identifier() const;
    46     SharedWorkerThread* thread() { return m_workerThread.get(); }
     51    SharedWorkerThread& thread() { return m_workerThread; }
    4752
    48     void startWorkerGlobalScope(const URL& scriptURL, const String& name, const String& userAgent, bool isOnline, const ScriptBuffer& sourceCode, const ContentSecurityPolicyResponseHeaders&, bool shouldBypassMainWorldContentSecurityPolicy, const CrossOriginEmbedderPolicy&, MonotonicTime timeOrigin, ReferrerPolicy, WorkerType, FetchRequestCredentials, JSC::RuntimeFlags) final;
    49     void workerObjectDestroyed() final;
    50     bool hasPendingActivity() const final;
    51     void terminateWorkerGlobalScope() final;
     53    bool isTerminatingOrTerminated() const { return m_isTerminatingOrTerminated; }
     54    void setAsTerminatingOrTerminated() { m_isTerminatingOrTerminated = true; }
    5255
    5356private:
    54     explicit SharedWorkerThreadProxy(SharedWorker&);
     57    WEBCORE_EXPORT SharedWorkerThreadProxy(UniqueRef<Page>&&, SharedWorkerIdentifier, const ClientOrigin&, const URL& scriptURL, WorkerFetchResult&&, WorkerOptions&&, const String& userAgent, CacheStorageProvider&);
    5558
    56     void workerGlobalScopeDestroyedInternal();
     59    // WorkerObjectProxy.
     60    void postExceptionToWorkerObject(const String& errorMessage, int lineNumber, int columnNumber, const String& sourceURL) final;
     61    void postMessageToWorkerObject(MessageWithMessagePorts&&) final { }
     62    void workerGlobalScopeDestroyed() final { }
     63    void confirmMessageFromWorkerObject(bool) final { }
     64    void reportPendingActivity(bool) final { }
    5765
    58     void postMessageToWorkerGlobalScope(MessageWithMessagePorts&&) final;
    59     void postTaskToWorkerGlobalScope(Function<void(ScriptExecutionContext&)>&&) final;
    60     void notifyNetworkStateChange(bool isOnline) final;
    61     void suspendForBackForwardCache() final;
    62     void resumeForBackForwardCache() final;
    63     void postExceptionToWorkerObject(const String& errorMessage, int lineNumber, int columnNumber, const String& sourceURL) final;
    64     void workerGlobalScopeDestroyed() final;
    65     void postMessageToWorkerObject(MessageWithMessagePorts&&) final;
    66     void confirmMessageFromWorkerObject(bool hasPendingActivity) final;
    67     void reportPendingActivity(bool hasPendingActivity) final;
     66    // WorkerLoaderProxy.
    6867    RefPtr<CacheStorageConnection> createCacheStorageConnection() final;
    6968    RefPtr<RTCDataChannelRemoteHandlerConnection> createRTCDataChannelRemoteHandlerConnection() final;
    7069    void postTaskToLoader(ScriptExecutionContext::Task&&) final;
    7170    bool postTaskForModeToWorkerOrWorkletGlobalScope(ScriptExecutionContext::Task&&, const String& mode) final;
     71
     72    // WorkerDebuggerProxy.
    7273    void postMessageToDebugger(const String&) final;
    7374    void setResourceCachingDisabledByWebInspector(bool) final;
    7475
    75     WeakPtr<SharedWorker> m_sharedWorker;
    76     RefPtr<SharedWorkerThread> m_workerThread;
    77     const RefPtr<ScriptExecutionContext> m_scriptExecutionContext;
    78     const String m_identifierForInspector;
    79     bool m_askedToTerminate { false };
    80     bool m_hasPendingActivity { false };
    81     bool m_mayBeDestroyed { false };
     76    static void networkStateChanged(bool isOnLine);
     77    void notifyNetworkStateChange(bool isOnline);
     78
     79    UniqueRef<Page> m_page;
     80    Ref<Document> m_document;
     81    Ref<SharedWorkerThread> m_workerThread;
     82    CacheStorageProvider& m_cacheStorageProvider;
     83    RefPtr<CacheStorageConnection> m_cacheStorageConnection;
     84    bool m_isTerminatingOrTerminated { false };
    8285};
    8386

  • trunk/Source/WebKit/CMakeLists.txt

    r288354 r289247  
    2929    "${WEBKIT_DIR}/NetworkProcess/PrivateClickMeasurement"
    3030    "${WEBKIT_DIR}/NetworkProcess/ServiceWorker"
     31    "${WEBKIT_DIR}/NetworkProcess/SharedWorker"
    3132    "${WEBKIT_DIR}/NetworkProcess/WebStorage"
    3233    "${WEBKIT_DIR}/NetworkProcess/cache"
    … …  
    203204    NetworkProcess/ServiceWorker/WebSWServerToContextConnection
    204205
     206    NetworkProcess/SharedWorker/WebSharedWorkerServerConnection
     207    NetworkProcess/SharedWorker/WebSharedWorkerServerToContextConnection
     208
    205209    NetworkProcess/WebStorage/StorageManagerSet
    206210
    … …  
    306310    WebProcess/Speech/SpeechRecognitionRealtimeMediaSourceManager
    307311
     312    WebProcess/Storage/WebSharedWorkerContextManagerConnection
     313    WebProcess/Storage/WebSharedWorkerObjectConnection
    308314    WebProcess/Storage/WebSWClientConnection
    309315    WebProcess/Storage/WebSWContextManagerConnection

  • trunk/Source/WebKit/ChangeLog

    r289246 r289247  
     12022-02-07  Chris Dumez  <cdumez@apple.com>
     2
     3        Add support for sharing Shared Workers (including across WebProcesses)
     4        https://bugs.webkit.org/show_bug.cgi?id=235958
     5        <rdar://problem/88330666>
     6
     7        Reviewed by Darin Adler.
     8
     9        Add support for sharing Shared Workers, including across WebProcesses. The architecture
     10        is modeled after the one we use for Service Workers since they are very similar. I tried
     11        sharing as much code as possible with Service Workers but some more work can probably be
     12        done in this area.
     13
     14        With this change, shared workers should be mostly functional and spec compliant. However,
     15        the feature remains disabled by default for now as there are still WPT tests failures I
     16        need to investigate. Also, I need to implement a better process suspension logic on iOS
     17        to replace the hack I added in this patch (to make the tests run reliably on iOS).
     18
     19        As with Service Workers, Shared Workers are partitioned by (Top Origin + Frame Origin)
     20        for privacy reasons. This is achieved via the SharedWorkerKey object that we use as
     21        HashMap key.
     22
     23        * CMakeLists.txt:
     24        * DerivedSources-input.xcfilelist:
     25        * DerivedSources-output.xcfilelist:
     26        * DerivedSources.make:
     27        * NetworkProcess/NetworkConnectionToWebProcess.cpp:
     28        (WebKit::m_schemeRegistry):
     29        (WebKit::NetworkConnectionToWebProcess::~NetworkConnectionToWebProcess):
     30        (WebKit::NetworkConnectionToWebProcess::didReceiveMessage):
     31        (WebKit::NetworkConnectionToWebProcess::didClose):
     32        (WebKit::NetworkConnectionToWebProcess::establishSharedWorkerContextConnection):
     33        (WebKit::NetworkConnectionToWebProcess::establishSharedWorkerServerConnection):
     34        (WebKit::NetworkConnectionToWebProcess::closeSharedWorkerContextConnection):
     35        (WebKit::NetworkConnectionToWebProcess::unregisterSharedWorkerConnection):
     36        (WebKit::NetworkConnectionToWebProcess::sharedWorkerServerToContextConnectionIsNoLongerNeeded):
     37        (WebKit::NetworkConnectionToWebProcess::sharedWorkerConnection):
     38        * NetworkProcess/NetworkConnectionToWebProcess.h:
     39        * NetworkProcess/NetworkConnectionToWebProcess.messages.in:
     40        * NetworkProcess/NetworkSession.cpp:
     41        (WebKit::NetworkSession::ensureSharedWorkerServer):
     42        * NetworkProcess/NetworkSession.h:
     43        (WebKit::NetworkSession::sharedWorkerServer):
     44        * NetworkProcess/SharedWorker/WebSharedWorker.cpp: Copied from Source/WebKit/WebProcess/Storage/WebSharedWorkerObjectConnection.cpp.
     45        (WebKit::WebSharedWorker::WebSharedWorker):
     46        (WebKit::WebSharedWorker::~WebSharedWorker):
     47        (WebKit::WebSharedWorker::fromIdentifier):
     48        (WebKit::WebSharedWorker::registrableDomain const):
     49        * NetworkProcess/SharedWorker/WebSharedWorker.h: Added.
     50        (WebKit::WebSharedWorker::identifier const):
     51        (WebKit::WebSharedWorker::key const):
     52        (WebKit::WebSharedWorker::workerOptions const):
     53        (WebKit::WebSharedWorker::origin const):
     54        (WebKit::WebSharedWorker::url const):
     55        (WebKit::WebSharedWorker::sharedWorkerObjects):
     56        (WebKit::WebSharedWorker::isRunning const):
     57        (WebKit::WebSharedWorker::markAsRunning):
     58        (WebKit::WebSharedWorker::fetchResult const):
     59        (WebKit::WebSharedWorker::setFetchResult):
     60        (WebKit::WebSharedWorker::didFinishFetching const):
     61        * NetworkProcess/SharedWorker/WebSharedWorkerServer.cpp: Added.
     62        (WebKit::WebSharedWorkerServer::WebSharedWorkerServer):
     63        (WebKit::WebSharedWorkerServer::sessionID):
     64        (WebKit::WebSharedWorkerServer::requestSharedWorker):
     65        (WebKit::WebSharedWorkerServer::didFinishFetchingSharedWorkerScript):
     66        (WebKit::WebSharedWorkerServer::needsContextConnectionForRegistrableDomain const):
     67        (WebKit::WebSharedWorkerServer::createContextConnection):
     68        (WebKit::WebSharedWorkerServer::addContextConnection):
     69        (WebKit::WebSharedWorkerServer::removeContextConnection):
     70        (WebKit::WebSharedWorkerServer::contextConnectionCreated):
     71        (WebKit::WebSharedWorkerServer::sharedWorkerObjectIsGoingAway):
     72        (WebKit::WebSharedWorkerServer::shutDownSharedWorker):
     73        (WebKit::WebSharedWorkerServer::addConnection):
     74        (WebKit::WebSharedWorkerServer::removeConnection):
     75        (WebKit::WebSharedWorkerServer::contextConnectionForRegistrableDomain const):
     76        (WebKit::WebSharedWorkerServer::postExceptionToWorkerObject):
     77        * NetworkProcess/SharedWorker/WebSharedWorkerServer.h: Added.
     78        * NetworkProcess/SharedWorker/WebSharedWorkerServerConnection.cpp: Added.
     79        (WebKit::WebSharedWorkerServerConnection::WebSharedWorkerServerConnection):
     80        (WebKit::WebSharedWorkerServerConnection::~WebSharedWorkerServerConnection):
     81        (WebKit::WebSharedWorkerServerConnection::messageSenderConnection const):
     82        (WebKit::WebSharedWorkerServerConnection::sessionID):
     83        (WebKit::WebSharedWorkerServerConnection::session):
     84        (WebKit::WebSharedWorkerServerConnection::requestSharedWorker):
     85        (WebKit::WebSharedWorkerServerConnection::sharedWorkerObjectIsGoingAway):
     86        (WebKit::WebSharedWorkerServerConnection::fetchScriptInClient):
     87        (WebKit::WebSharedWorkerServerConnection::notifyWorkerObjectOfLoadCompletion):
     88        (WebKit::WebSharedWorkerServerConnection::postExceptionToWorkerObject):
     89        * NetworkProcess/SharedWorker/WebSharedWorkerServerConnection.h: Added.
     90        (WebKit::WebSharedWorkerServerConnection::server):
     91        (WebKit::WebSharedWorkerServerConnection::server const):
     92        (WebKit::WebSharedWorkerServerConnection::webProcessIdentifier const):
     93        * NetworkProcess/SharedWorker/WebSharedWorkerServerConnection.messages.in: Added.
     94        * NetworkProcess/SharedWorker/WebSharedWorkerServerToContextConnection.cpp: Added.
     95        (WebKit::WebSharedWorkerServerToContextConnection::WebSharedWorkerServerToContextConnection):
     96        (WebKit::WebSharedWorkerServerToContextConnection::~WebSharedWorkerServerToContextConnection):
     97        (WebKit::WebSharedWorkerServerToContextConnection::webProcessIdentifier const):
     98        (WebKit::WebSharedWorkerServerToContextConnection::ipcConnection const):
     99        (WebKit::WebSharedWorkerServerToContextConnection::messageSenderConnection const):
     100        (WebKit::WebSharedWorkerServerToContextConnection::messageSenderDestinationID const):
     101        (WebKit::WebSharedWorkerServerToContextConnection::connectionIsNoLongerNeeded):
     102        (WebKit::WebSharedWorkerServerToContextConnection::postExceptionToWorkerObject):
     103        (WebKit::WebSharedWorkerServerToContextConnection::launchSharedWorker):
     104        (WebKit::WebSharedWorkerServerToContextConnection::postConnectEvent):
     105        (WebKit::WebSharedWorkerServerToContextConnection::terminateSharedWorker):
     106        * NetworkProcess/SharedWorker/WebSharedWorkerServerToContextConnection.h: Added.
     107        * NetworkProcess/SharedWorker/WebSharedWorkerServerToContextConnection.messages.in: Added.
     108        * Platform/Logging.h:
     109        * Scripts/webkit/messages.py:
     110        (types_that_cannot_be_forward_declared):
     111        * Sources.txt:
     112        * UIProcess/Network/NetworkProcessProxy.cpp:
     113        (WebKit::NetworkProcessProxy::terminateUnresponsiveServiceWorkerProcesses):
     114        (WebKit::NetworkProcessProxy::establishSharedWorkerContextConnectionToNetworkProcess):
     115        (WebKit::NetworkProcessProxy::establishServiceWorkerContextConnectionToNetworkProcess):
     116        (WebKit::NetworkProcessProxy::serviceWorkerContextConnectionNoLongerNeeded):
     117        (WebKit::NetworkProcessProxy::sharedWorkerContextConnectionNoLongerNeeded):
     118        * UIProcess/Network/NetworkProcessProxy.h:
     119        * UIProcess/Network/NetworkProcessProxy.messages.in:
     120        * UIProcess/WebPageProxy.cpp:
     121        (WebKit::WebPageProxy::setUserAgent):
     122        * UIProcess/WebProcessPool.cpp:
     123        (WebKit::WebProcessPool::establishServiceWorkerContextConnectionToNetworkProcess):
     124        (WebKit::WebProcessPool::removeFromWorkerProcesses):
     125        (WebKit::WebProcessPool::establishSharedWorkerContextConnectionToNetworkProcess):
     126        (WebKit::WebProcessPool::disconnectProcess):
     127        (WebKit::WebProcessPool::userContentControllerIdentifierForWorkers):
     128        (WebKit::WebProcessPool::createWebPage):
     129        (WebKit::WebProcessPool::updateWorkerUserAgent):
     130        (WebKit::WebProcessPool::terminateServiceWorkers):
     131        (WebKit::WebProcessPool::workerProcesses):
     132        (WebKit::WebProcessPool::updateProcessAssertions):
     133        (WebKit::WebProcessPool::isServiceWorkerPageID const):
     134        (WebKit::WebProcessPool::serviceWorkerProxiesCount const):
     135        (WebKit::WebProcessPool::hasServiceWorkerForegroundActivityForTesting const):
     136        (WebKit::WebProcessPool::hasServiceWorkerBackgroundActivityForTesting const):
     137        (WebKit::WebProcessPool::removeFromServiceWorkerProcesses): Deleted.
     138        (WebKit::WebProcessPool::userContentControllerIdentifierForServiceWorkers): Deleted.
     139        (WebKit::WebProcessPool::updateServiceWorkerUserAgent): Deleted.
     140        (WebKit::WebProcessPool::serviceWorkerProcesses): Deleted.
     141        * UIProcess/WebProcessPool.h:
     142        * UIProcess/WebProcessProxy.cpp:
     143        (WebKit::WebProcessProxy::createForWorkers):
     144        (WebKit::WebProcessProxy::didBecomeUnresponsive):
     145        (WebKit::WebProcessProxy::didStartProvisionalLoadForMainFrame):
     146        (WebKit::WebProcessProxy::setWorkerUserAgent):
     147        (WebKit::WebProcessProxy::updateWorkerPreferencesStore):
     148        (WebKit::WebProcessProxy::updateWorkerProcessAssertion):
     149        (WebKit::WebProcessProxy::establishSharedWorkerContext):
     150        (WebKit::WebProcessProxy::registerServiceWorkerClientProcess):
     151        (WebKit::WebProcessProxy::unregisterServiceWorkerClientProcess):
     152        (WebKit::WebProcessProxy::startServiceWorkerBackgroundProcessing):
     153        (WebKit::WebProcessProxy::endServiceWorkerBackgroundProcessing):
     154        (WebKit::WebProcessProxy::disableWorkers):
     155        (WebKit::WebProcessProxy::enableWorkers):
     156        (WebKit::WebProcessProxy::createForServiceWorkers): Deleted.
     157        (WebKit::WebProcessProxy::setServiceWorkerUserAgent): Deleted.
     158        (WebKit::WebProcessProxy::updateServiceWorkerPreferencesStore): Deleted.
     159        (WebKit::WebProcessProxy::updateServiceWorkerProcessAssertion): Deleted.
     160        (WebKit::WebProcessProxy::disableServiceWorkers): Deleted.
     161        (WebKit::WebProcessProxy::enableServiceWorkers): Deleted.
     162        * UIProcess/WebProcessProxy.h:
     163        (WebKit::WebProcessProxy::isRunningSharedWorkers const):
     164        (WebKit::WebProcessProxy::isStandaloneSharedWorkerProcess const):
     165        (WebKit::WebProcessProxy::isRunningWorkers const):
     166        (WebKit::WebProcessProxy::hasServiceWorkerPageProxy):
     167        * WebKit.xcodeproj/project.pbxproj:
     168        * WebProcess/Network/NetworkProcessConnection.cpp:
     169        (WebKit::NetworkProcessConnection::didReceiveMessage):
     170        * WebProcess/Network/NetworkProcessConnection.h:
     171        * WebProcess/Storage/WebSharedWorkerContextManagerConnection.cpp: Added.
     172        (WebKit::WebSharedWorkerContextManagerConnection::WebSharedWorkerContextManagerConnection):
     173        (WebKit::m_userContentController):
     174        (WebKit::WebSharedWorkerContextManagerConnection::establishConnection):
     175        (WebKit::WebSharedWorkerContextManagerConnection::postExceptionToWorkerObject):
     176        (WebKit::WebSharedWorkerContextManagerConnection::updatePreferencesStore):
     177        (WebKit::WebSharedWorkerContextManagerConnection::launchSharedWorker):
     178        (WebKit::WebSharedWorkerContextManagerConnection::close):
     179        * WebProcess/Storage/WebSharedWorkerContextManagerConnection.h: Added.
     180        * WebProcess/Storage/WebSharedWorkerContextManagerConnection.messages.in: Added.
     181        * WebProcess/Storage/WebSharedWorkerObjectConnection.cpp:
     182        (WebKit::WebSharedWorkerObjectConnection::WebSharedWorkerObjectConnection):
     183        (WebKit::WebSharedWorkerObjectConnection::~WebSharedWorkerObjectConnection):
     184        (WebKit::WebSharedWorkerObjectConnection::requestSharedWorker):
     185        (WebKit::WebSharedWorkerObjectConnection::sharedWorkerObjectIsGoingAway):
     186        * WebProcess/Storage/WebSharedWorkerObjectConnection.h:
     187        * WebProcess/Storage/WebSharedWorkerObjectConnection.messages.in: Added.
     188        * WebProcess/WebProcess.cpp:
     189        (WebKit::WebProcess::didReceiveMessage):
     190        (WebKit::WebProcess::establishSharedWorkerContextConnectionToNetworkProcess):
     191        * WebProcess/WebProcess.h:
     192        * WebProcess/WebProcess.messages.in:
     193
    11942022-02-07  Megan Gardner  <megan_gardner@apple.com>
    2195

  • trunk/Source/WebKit/DerivedSources-input.xcfilelist

    r288354 r289247  
    9292$(PROJECT_DIR)/NetworkProcess/ServiceWorker/WebSWServerConnection.messages.in
    9393$(PROJECT_DIR)/NetworkProcess/ServiceWorker/WebSWServerToContextConnection.messages.in
     94$(PROJECT_DIR)/NetworkProcess/SharedWorker/WebSharedWorkerServerConnection.messages.in
     95$(PROJECT_DIR)/NetworkProcess/SharedWorker/WebSharedWorkerServerToContextConnection.messages.in
    9496$(PROJECT_DIR)/NetworkProcess/WebStorage/StorageManagerSet.messages.in
    9597$(PROJECT_DIR)/NetworkProcess/cache/CacheStorageEngineConnection.messages.in
    … …  
    218220$(PROJECT_DIR)/WebProcess/Storage/WebSWClientConnection.messages.in
    219221$(PROJECT_DIR)/WebProcess/Storage/WebSWContextManagerConnection.messages.in
     222$(PROJECT_DIR)/WebProcess/Storage/WebSharedWorkerContextManagerConnection.messages.in
     223$(PROJECT_DIR)/WebProcess/Storage/WebSharedWorkerObjectConnection.messages.in
    220224$(PROJECT_DIR)/WebProcess/UserContent/WebUserContentController.messages.in
    221225$(PROJECT_DIR)/WebProcess/WebAuthentication/WebAuthenticatorCoordinator.messages.in

  • trunk/Source/WebKit/DerivedSources-output.xcfilelist

    r288354 r289247  
    608608$(BUILT_PRODUCTS_DIR)/DerivedSources/WebKit/WebSWServerToContextConnectionMessages.h
    609609$(BUILT_PRODUCTS_DIR)/DerivedSources/WebKit/WebSWServerToContextConnectionMessagesReplies.h
     610$(BUILT_PRODUCTS_DIR)/DerivedSources/WebKit/WebSharedWorkerContextManagerConnectionMessageReceiver.cpp
     611$(BUILT_PRODUCTS_DIR)/DerivedSources/WebKit/WebSharedWorkerContextManagerConnectionMessages.h
     612$(BUILT_PRODUCTS_DIR)/DerivedSources/WebKit/WebSharedWorkerContextManagerConnectionMessagesReplies.h
     613$(BUILT_PRODUCTS_DIR)/DerivedSources/WebKit/WebSharedWorkerObjectConnectionMessageReceiver.cpp
     614$(BUILT_PRODUCTS_DIR)/DerivedSources/WebKit/WebSharedWorkerObjectConnectionMessages.h
     615$(BUILT_PRODUCTS_DIR)/DerivedSources/WebKit/WebSharedWorkerObjectConnectionMessagesReplies.h
     616$(BUILT_PRODUCTS_DIR)/DerivedSources/WebKit/WebSharedWorkerServerConnectionMessageReceiver.cpp
     617$(BUILT_PRODUCTS_DIR)/DerivedSources/WebKit/WebSharedWorkerServerConnectionMessages.h
     618$(BUILT_PRODUCTS_DIR)/DerivedSources/WebKit/WebSharedWorkerServerConnectionMessagesReplies.h
     619$(BUILT_PRODUCTS_DIR)/DerivedSources/WebKit/WebSharedWorkerServerToContextConnectionMessageReceiver.cpp
     620$(BUILT_PRODUCTS_DIR)/DerivedSources/WebKit/WebSharedWorkerServerToContextConnectionMessages.h
     621$(BUILT_PRODUCTS_DIR)/DerivedSources/WebKit/WebSharedWorkerServerToContextConnectionMessagesReplies.h
    610622$(BUILT_PRODUCTS_DIR)/DerivedSources/WebKit/WebSocketChannelMessageReceiver.cpp
    611623$(BUILT_PRODUCTS_DIR)/DerivedSources/WebKit/WebSocketChannelMessages.h

  • trunk/Source/WebKit/DerivedSources.make

    r288354 r289247  
    134134        NetworkProcess/ServiceWorker/ServiceWorkerFetchTask \
    135135        NetworkProcess/ServiceWorker/WebSWServerToContextConnection \
     136        NetworkProcess/SharedWorker/WebSharedWorkerServerConnection \
     137        NetworkProcess/SharedWorker/WebSharedWorkerServerToContextConnection \
    136138        NetworkProcess/NetworkSocketStream \
    137139        NetworkProcess/NetworkProcess \
    … …  
    226228        WebProcess/WebCoreSupport/WebSpeechRecognitionConnection \
    227229        WebProcess/Speech/SpeechRecognitionRealtimeMediaSourceManager \
     230        WebProcess/Storage/WebSharedWorkerContextManagerConnection \
     231        WebProcess/Storage/WebSharedWorkerObjectConnection \
    228232        WebProcess/Storage/WebSWContextManagerConnection \
    229233        WebProcess/Storage/WebSWClientConnection \

  • trunk/Source/WebKit/NetworkProcess/NetworkConnectionToWebProcess.cpp

    r289065 r289247  
    6767#include "WebSWServerToContextConnection.h"
    6868#include "WebSWServerToContextConnectionMessages.h"
     69#include "WebSharedWorkerServer.h"
     70#include "WebSharedWorkerServerConnection.h"
     71#include "WebSharedWorkerServerConnectionMessages.h"
     72#include "WebSharedWorkerServerToContextConnection.h"
     73#include "WebSharedWorkerServerToContextConnectionMessages.h"
    6974#include "WebsiteDataStoreParameters.h"
    7075#include <WebCore/DocumentStorageAccess.h>
    … …  
    133138    establishSWServerConnection();
    134139#endif
     140    establishSharedWorkerServerConnection();
    135141}
    136142
    … …  
    167173    unregisterSWConnection();
    168174#endif
     175    unregisterSharedWorkerConnection();
    169176}
    170177
    … …  
    276283#endif
    277284
     285    if (decoder.messageReceiverName() == Messages::WebSharedWorkerServerConnection::messageReceiverName()) {
     286        if (m_sharedWorkerConnection)
     287            m_sharedWorkerConnection->didReceiveMessage(connection, decoder);
     288        return;
     289    }
     290    if (decoder.messageReceiverName() == Messages::WebSharedWorkerServerToContextConnection::messageReceiverName()) {
     291        if (m_sharedWorkerContextConnection)
     292            m_sharedWorkerContextConnection->didReceiveMessage(connection, decoder);
     293        return;
     294    }
     295
    278296#if ENABLE(APPLE_PAY_REMOTE_UI)
    279297    if (decoder.messageReceiverName() == Messages::WebPaymentCoordinatorProxy::messageReceiverName())
    … …  
    399417#if ENABLE(SERVICE_WORKER)
    400418    m_swContextConnection = nullptr;
    401 #else
    402     UNUSED_PARAM(connection);
    403 #endif
     419#endif
     420    m_sharedWorkerContextConnection = nullptr;
    404421
    405422    // Protect ourself as we might be otherwise be deleted during this function.
    … …  
    442459    unregisterSWConnection();
    443460#endif
     461    unregisterSharedWorkerConnection();
    444462
    445463#if ENABLE(APPLE_PAY_REMOTE_UI)
    … …  
    11871205    });
    11881206}
     1207
     1208void NetworkConnectionToWebProcess::establishSharedWorkerContextConnection(WebPageProxyIdentifier, WebCore::RegistrableDomain&& registrableDomain, CompletionHandler<void()>&& completionHandler)
     1209{
     1210    CONNECTION_RELEASE_LOG(SharedWorker, "establishSharedWorkerContextConnection:");
     1211    auto* session = networkSession();
     1212    if (auto* swServer = session ? session->sharedWorkerServer() : nullptr)
     1213        m_sharedWorkerContextConnection = makeUnique<WebSharedWorkerServerToContextConnection>(*this, WTFMove(registrableDomain), *swServer);
     1214    completionHandler();
     1215}
     1216
     1217void NetworkConnectionToWebProcess::establishSharedWorkerServerConnection()
     1218{
     1219    if (m_sharedWorkerConnection)
     1220        return;
     1221
     1222    auto* session = networkSession();
     1223    if (!session)
     1224        return;
     1225
     1226    CONNECTION_RELEASE_LOG(SharedWorker, "establishSharedWorkerServerConnection:");
     1227
     1228    auto& server = session->ensureSharedWorkerServer();
     1229    auto connection = makeUnique<WebSharedWorkerServerConnection>(m_networkProcess, server, m_connection.get(), m_webProcessIdentifier);
     1230
     1231    m_sharedWorkerConnection = *connection;
     1232    server.addConnection(WTFMove(connection));
     1233}
     1234
     1235void NetworkConnectionToWebProcess::closeSharedWorkerContextConnection()
     1236{
     1237    CONNECTION_RELEASE_LOG(SharedWorker, "closeSharedWorkerContextConnection:");
     1238    m_sharedWorkerContextConnection = nullptr;
     1239}
     1240
     1241void NetworkConnectionToWebProcess::unregisterSharedWorkerConnection()
     1242{
     1243    CONNECTION_RELEASE_LOG(SharedWorker, "unregisterSharedWorkerConnection:");
     1244    if (m_sharedWorkerConnection)
     1245        m_sharedWorkerConnection->server().removeConnection(m_sharedWorkerConnection->webProcessIdentifier());
     1246}
     1247
     1248void NetworkConnectionToWebProcess::sharedWorkerServerToContextConnectionIsNoLongerNeeded()
     1249{
     1250    CONNECTION_RELEASE_LOG(SharedWorker, "sharedWorkerServerToContextConnectionIsNoLongerNeeded:");
     1251    m_networkProcess->parentProcessConnection()->send(Messages::NetworkProcessProxy::SharedWorkerContextConnectionNoLongerNeeded { webProcessIdentifier() }, 0);
     1252
     1253    m_sharedWorkerContextConnection = nullptr;
     1254}
     1255
     1256WebSharedWorkerServerConnection* NetworkConnectionToWebProcess::sharedWorkerConnection()
     1257{
     1258    if (!m_sharedWorkerConnection)
     1259        establishSharedWorkerServerConnection();
     1260    return m_sharedWorkerConnection.get();
     1261}
    11891262   
    11901263#if ENABLE(SERVICE_WORKER)

  • trunk/Source/WebKit/NetworkProcess/NetworkConnectionToWebProcess.h

    r289065 r289247  
    9393class WebSWServerConnection;
    9494class WebSWServerToContextConnection;
     95class WebSharedWorkerServerConnection;
     96class WebSharedWorkerServerToContextConnection;
    9597
    9698namespace NetworkCache {
    … …  
    186188    std::unique_ptr<ServiceWorkerFetchTask> createFetchTask(NetworkResourceLoader&, const WebCore::ResourceRequest&);
    187189#endif
     190    void sharedWorkerServerToContextConnectionIsNoLongerNeeded();
     191
     192    WebSharedWorkerServerConnection* sharedWorkerConnection();
    188193
    189194    NetworkSchemeRegistry& schemeRegistry() { return m_schemeRegistry.get(); }
    … …  
    254259    void updateQuotaBasedOnSpaceUsageForTesting(const WebCore::ClientOrigin&);
    255260
     261    void establishSharedWorkerServerConnection();
     262    void unregisterSharedWorkerConnection();
     263
    256264#if ENABLE(SERVICE_WORKER)
    257265    void establishSWServerConnection();
    … …  
    260268    void unregisterSWConnection();
    261269#endif
     270
     271    void establishSharedWorkerContextConnection(WebPageProxyIdentifier, WebCore::RegistrableDomain&&, CompletionHandler<void()>&&);
     272    void closeSharedWorkerContextConnection();
    262273
    263274    void createRTCProvider(CompletionHandler<void()>&&);
    … …  
    405416    std::unique_ptr<WebSWServerToContextConnection> m_swContextConnection;
    406417#endif
     418    WeakPtr<WebSharedWorkerServerConnection> m_sharedWorkerConnection;
     419    std::unique_ptr<WebSharedWorkerServerToContextConnection> m_sharedWorkerContextConnection;
    407420
    408421#if ENABLE(WEB_RTC)

  • trunk/Source/WebKit/NetworkProcess/NetworkConnectionToWebProcess.messages.in

    r288540 r289247  
    8989#endif
    9090
     91    EstablishSharedWorkerContextConnection(WebKit::WebPageProxyIdentifier webPageProxyID, WebCore::RegistrableDomain domain) -> () Async
     92    CloseSharedWorkerContextConnection()
     93
    9194    CreateRTCProvider() -> () Async
    9295#if ENABLE(WEB_RTC)

  • trunk/Source/WebKit/NetworkProcess/NetworkSession.cpp

    r288935 r289247  
    4848#include "WebProcessProxy.h"
    4949#include "WebSWOriginStore.h"
     50#include "WebSharedWorkerServer.h"
    5051#include "WebSocketTask.h"
    5152#include <WebCore/CookieJar.h>
    … …  
    654655#endif // ENABLE(SERVICE_WORKER)
    655656
     657WebSharedWorkerServer& NetworkSession::ensureSharedWorkerServer()
     658{
     659    if (!m_sharedWorkerServer)
     660        m_sharedWorkerServer = makeUnique<WebSharedWorkerServer>(*this);
     661    return *m_sharedWorkerServer;
     662}
     663
    656664WebIDBServer& NetworkSession::ensureWebIDBServer()
    657665{

  • trunk/Source/WebKit/NetworkProcess/NetworkSession.h

    r287781 r289247  
    8080class WebPageNetworkParameters;
    8181class WebResourceLoadStatisticsStore;
     82class WebSharedWorkerServer;
    8283class WebSocketTask;
    8384class WebSWOriginStore;
    … …  
    211212#endif
    212213
     214    WebSharedWorkerServer* sharedWorkerServer() { return m_sharedWorkerServer.get(); }
     215    WebSharedWorkerServer& ensureSharedWorkerServer();
     216
    213217    WebIDBServer* webIDBServer() { return m_webIDBServer.get(); }
    214218    WebIDBServer& ensureWebIDBServer();
    … …  
    319323    std::unique_ptr<WebCore::SWServer> m_swServer;
    320324#endif
     325    std::unique_ptr<WebSharedWorkerServer> m_sharedWorkerServer;
    321326
    322327    String m_idbDatabasePath;

  • trunk/Source/WebKit/NetworkProcess/SharedWorker/WebSharedWorker.cpp

    r289246 r289247  
    2525
    2626#include "config.h"
    27 #include "WebSharedWorkerObjectConnection.h"
     27#include "WebSharedWorker.h"
    2828
    29 #include "NetworkProcessConnection.h"
    30 #include "WebProcess.h"
    31 #include <WebCore/SharedWorkerManager.h>
     29#include <wtf/HashMap.h>
     30#include <wtf/NeverDestroyed.h>
     31#include <wtf/RunLoop.h>
    3232
    3333namespace WebKit {
    3434
    35 WebSharedWorkerObjectConnection::WebSharedWorkerObjectConnection() = default;
    36 
    37 IPC::Connection* WebSharedWorkerObjectConnection::messageSenderConnection() const
     35static HashMap<WebCore::SharedWorkerIdentifier, WebSharedWorker*>& allWorkers()
    3836{
    39     return &WebProcess::singleton().ensureNetworkProcessConnection().connection();
     37    ASSERT(RunLoop::isMain());
     38    static NeverDestroyed<HashMap<WebCore::SharedWorkerIdentifier, WebSharedWorker*>> allWorkers;
     39    return allWorkers;
    4040}
    4141
    42 void WebSharedWorkerObjectConnection::requestSharedWorker(const URL& url, WebCore::SharedWorker& sharedWorker, WebCore::TransferredMessagePort&& port, WebCore::WorkerOptions&& workerOptions)
     42WebSharedWorker::WebSharedWorker(const WebCore::SharedWorkerKey& key, const WebCore::WorkerOptions& workerOptions)
     43    : m_identifier(WebCore::SharedWorkerIdentifier::generate())
     44    , m_key(key)
     45    , m_workerOptions(workerOptions)
    4346{
    44     // FIXME: Should send IPC to the network process.
    45     WebCore::SharedWorkerManager::singleton().connect(url, sharedWorker, WTFMove(port), WTFMove(workerOptions));
     47    ASSERT(!allWorkers().contains(m_identifier));
     48    allWorkers().add(m_identifier, this);
     49}
     50
     51WebSharedWorker::~WebSharedWorker()
     52{
     53    ASSERT(allWorkers().get(m_identifier) == this);
     54    allWorkers().remove(m_identifier);
     55}
     56
     57WebSharedWorker* WebSharedWorker::fromIdentifier(WebCore::SharedWorkerIdentifier identifier)
     58{
     59    return allWorkers().get(identifier);
     60}
     61
     62WebCore::RegistrableDomain WebSharedWorker::registrableDomain() const
     63{
     64    return WebCore::RegistrableDomain { url() };
    4665}
    4766

  • trunk/Source/WebKit/Platform/Logging.h

    r288972 r289247  
    9898    M(SessionState) \
    9999    M(SharedDisplayLists) \
     100    M(SharedWorker) \
    100101    M(Storage) \
    101102    M(StorageAPI) \

  • trunk/Source/WebKit/Scripts/webkit/messages.py

    r289223 r289247  
    305305        'WebCore::ServiceWorkerRegistrationIdentifier',
    306306        'WebCore::SharedStringHash',
     307        'WebCore::SharedWorkerIdentifier',
     308        'WebCore::SharedWorkerObjectIdentifier',
    307309        'WebCore::SleepDisablerIdentifier',
    308310        'WebCore::SourceBufferAppendMode',
    309311        'WebCore::SpeechRecognitionConnectionClientIdentifier',
    310312        'WebCore::StorageType',
     313        'WebCore::TransferredMessagePort',
    311314        'WebCore::UserMediaRequestIdentifier',
    312315        'WebCore::WebLockIdentifier',

  • trunk/Source/WebKit/Sources.txt

    r289063 r289247  
    141141NetworkProcess/ServiceWorker/WebSWServerConnection.cpp @no-unify
    142142NetworkProcess/ServiceWorker/WebSWServerToContextConnection.cpp @no-unify
     143
     144NetworkProcess/SharedWorker/WebSharedWorker.cpp
     145NetworkProcess/SharedWorker/WebSharedWorkerServer.cpp
     146NetworkProcess/SharedWorker/WebSharedWorkerServerConnection.cpp
     147NetworkProcess/SharedWorker/WebSharedWorkerServerToContextConnection.cpp
    143148
    144149NetworkProcess/storage/FileSystemStorageManager.cpp
    … …  
    784789WebProcess/Storage/WebServiceWorkerFetchTaskClient.cpp
    785790WebProcess/Storage/WebServiceWorkerProvider.cpp
     791WebProcess/Storage/WebSharedWorkerContextManagerConnection.cpp
     792WebProcess/Storage/WebSharedWorkerObjectConnection.cpp
    786793WebProcess/Storage/WebSharedWorkerProvider.cpp
    787 WebProcess/Storage/WebSharedWorkerObjectConnection.cpp
    788794
    789795WebProcess/UserContent/WebUserContentController.cpp
    … …  
    888894WebBroadcastChannelRegistryMessageReceiver.cpp
    889895WebLockRegistryProxyMessageReceiver.cpp
     896WebSharedWorkerContextManagerConnectionMessageReceiver.cpp
     897WebSharedWorkerObjectConnectionMessageReceiver.cpp
     898WebSharedWorkerServerConnectionMessageReceiver.cpp
     899WebSharedWorkerServerToContextConnectionMessageReceiver.cpp

  • trunk/Source/WebKit/UIProcess/Network/NetworkProcessProxy.cpp

    r288935 r289247  
    530530{
    531531    if (RefPtr process = WebProcessProxy::processForIdentifier(processIdentifier)) {
    532         process->disableServiceWorkers();
     532        process->disableWorkers(WebProcessProxy::WorkerType::ServiceWorker);
    533533        process->requestTermination(ProcessTerminationReason::ExceededCPULimit);
    534534    }
    … …  
    14161416#endif
    14171417
     1418void NetworkProcessProxy::establishSharedWorkerContextConnectionToNetworkProcess(WebCore::RegistrableDomain&& registrableDomain, PAL::SessionID sessionID, CompletionHandler<void()>&& completionHandler)
     1419{
     1420    WebProcessPool::establishSharedWorkerContextConnectionToNetworkProcess(WTFMove(registrableDomain), sessionID, WTFMove(completionHandler));
     1421}
     1422
    14181423#if ENABLE(SERVICE_WORKER)
    14191424void NetworkProcessProxy::establishServiceWorkerContextConnectionToNetworkProcess(RegistrableDomain&& registrableDomain, std::optional<ScriptExecutionContextIdentifier> serviceWorkerPageIdentifier, PAL::SessionID sessionID, CompletionHandler<void()>&& completionHandler)
    14201425{
    1421     WebProcessPool::establishServiceWorkerContextConnectionToNetworkProcess(*this, WTFMove(registrableDomain), serviceWorkerPageIdentifier, sessionID, WTFMove(completionHandler));
     1426    WebProcessPool::establishServiceWorkerContextConnectionToNetworkProcess(WTFMove(registrableDomain), serviceWorkerPageIdentifier, sessionID, WTFMove(completionHandler));
    14221427}
    14231428
    … …  
    14251430{
    14261431    if (auto* process = WebProcessProxy::processForIdentifier(identifier))
    1427         process->disableServiceWorkers();
     1432        process->disableWorkers(WebProcessProxy::WorkerType::ServiceWorker);
    14281433}
    14291434
    … …  
    14601465}
    14611466#endif
     1467
     1468void NetworkProcessProxy::sharedWorkerContextConnectionNoLongerNeeded(WebCore::ProcessIdentifier identifier)
     1469{
     1470    if (auto* process = WebProcessProxy::processForIdentifier(identifier))
     1471        process->disableWorkers(WebProcessProxy::WorkerType::SharedWorker);
     1472}
    14621473
    14631474void NetworkProcessProxy::requestStorageSpace(PAL::SessionID sessionID, const WebCore::ClientOrigin& origin, uint64_t currentQuota, uint64_t currentSize, uint64_t spaceRequired, CompletionHandler<void(std::optional<uint64_t> quota)>&& completionHandler)

  • trunk/Source/WebKit/UIProcess/Network/NetworkProcessProxy.h

    r288935 r289247  
    335335    void endServiceWorkerBackgroundProcessing(WebCore::ProcessIdentifier serviceWorkerProcessIdentifier);
    336336#endif
     337    void sharedWorkerContextConnectionNoLongerNeeded(WebCore::ProcessIdentifier);
     338    void establishSharedWorkerContextConnectionToNetworkProcess(WebCore::RegistrableDomain&&, PAL::SessionID, CompletionHandler<void()>&&);
    337339
    338340    void terminateWebProcess(WebCore::ProcessIdentifier);

  • trunk/Source/WebKit/UIProcess/Network/NetworkProcessProxy.messages.in

    r288935 r289247  
    6161    EndServiceWorkerBackgroundProcessing(WebCore::ProcessIdentifier serviceWorkerProcessIdentifier)
    6262#endif
     63    EstablishSharedWorkerContextConnectionToNetworkProcess(WebCore::RegistrableDomain registrableDomain, PAL::SessionID sessionID) -> () Async
     64    SharedWorkerContextConnectionNoLongerNeeded(WebCore::ProcessIdentifier identifier)
    6365
    6466    SetWebProcessHasUploads(WebCore::ProcessIdentifier processID, bool hasUpload)

  • trunk/Source/WebKit/UIProcess/WebPageProxy.cpp

    r289140 r289247  
    36953695    m_userAgent = WTFMove(userAgent);
    36963696
    3697 #if ENABLE(SERVICE_WORKER)
    36983697    // We update the service worker there at the moment to be sure we use values used by actual web pages.
    36993698    // FIXME: Refactor this when we have a better User-Agent story.
    3700     process().processPool().updateServiceWorkerUserAgent(m_userAgent);
    3701 #endif
     3699    process().processPool().updateWorkerUserAgent(m_userAgent);
    37023700
    37033701    if (!hasRunningProcess())

  • trunk/Source/WebKit/UIProcess/WebProcessPool.cpp

    r288935 r289247  
    530530
    531531#if ENABLE(SERVICE_WORKER)
    532 void WebProcessPool::establishServiceWorkerContextConnectionToNetworkProcess(NetworkProcessProxy& proxy, RegistrableDomain&& registrableDomain, std::optional<ScriptExecutionContextIdentifier> serviceWorkerPageIdentifier, PAL::SessionID sessionID, CompletionHandler<void()>&& completionHandler)
     532void WebProcessPool::establishServiceWorkerContextConnectionToNetworkProcess(RegistrableDomain&& registrableDomain, std::optional<ScriptExecutionContextIdentifier> serviceWorkerPageIdentifier, PAL::SessionID sessionID, CompletionHandler<void()>&& completionHandler)
    533533{
    534534    auto* websiteDataStore = WebsiteDataStore::existingDataStoreForSessionID(sessionID);
    … …  
    547547        // This is a service worker for a service worker page so we need to make sure we use use the page's WebProcess for the service worker.
    548548        if ((serviceWorkerProcessProxy = WebProcessProxy::processForIdentifier(serviceWorkerPageIdentifier->processIdentifier()))) {
    549             serviceWorkerProcessProxy->enableServiceWorkers(processPool->userContentControllerIdentifierForServiceWorkers());
     549            serviceWorkerProcessProxy->enableWorkers(WebProcessProxy::WorkerType::ServiceWorker, processPool->userContentControllerIdentifierForWorkers());
    550550            if (serviceWorkerProcessProxy->isInProcessCache()) {
    551551                processPool->webProcessCache().removeProcess(*serviceWorkerProcessProxy, WebProcessCache::ShouldShutDownProcess::No);
    … …  
    565565
    566566            serviceWorkerProcessProxy = process.ptr();
    567             serviceWorkerProcessProxy->enableServiceWorkers(processPool->userContentControllerIdentifierForServiceWorkers());
     567            serviceWorkerProcessProxy->enableWorkers(WebProcessProxy::WorkerType::ServiceWorker, processPool->userContentControllerIdentifierForWorkers());
    568568
    569569            if (serviceWorkerProcessProxy->isInProcessCache()) {
    … …  
    578578
    579579    if (!serviceWorkerProcessProxy) {
    580         auto newProcessProxy = WebProcessProxy::createForServiceWorkers(*processPool, RegistrableDomain  { registrableDomain }, *websiteDataStore);
     580        auto newProcessProxy = WebProcessProxy::createForWorkers(WebProcessProxy::WorkerType::ServiceWorker, *processPool, RegistrableDomain  { registrableDomain }, *websiteDataStore);
    581581        serviceWorkerProcessProxy = newProcessProxy.ptr();
    582582
    … …  
    587587    }
    588588
    589     ASSERT(!serviceWorkerProcesses().contains(*serviceWorkerProcessProxy));
    590     serviceWorkerProcesses().add(*serviceWorkerProcessProxy);
    591 
    592     serviceWorkerProcessProxy->establishServiceWorkerContext(processPool->m_serviceWorkerPreferences ? processPool->m_serviceWorkerPreferences.value() : processPool->m_defaultPageGroup->preferences().store(), registrableDomain, serviceWorkerPageIdentifier, WTFMove(completionHandler));
    593     if (!processPool->m_serviceWorkerUserAgent.isNull())
    594         serviceWorkerProcessProxy->setServiceWorkerUserAgent(processPool->m_serviceWorkerUserAgent);
    595 }
    596 
    597 void WebProcessPool::removeFromServiceWorkerProcesses(WebProcessProxy& process)
    598 {
    599     ASSERT(serviceWorkerProcesses().contains(process));
    600     serviceWorkerProcesses().remove(process);
    601 }
    602 #endif
     589    workerProcesses().add(*serviceWorkerProcessProxy);
     590
     591    serviceWorkerProcessProxy->establishServiceWorkerContext(processPool->m_workerPreferences ? processPool->m_workerPreferences.value() : processPool->m_defaultPageGroup->preferences().store(), registrableDomain, serviceWorkerPageIdentifier, WTFMove(completionHandler));
     592    if (!processPool->m_workerUserAgent.isNull())
     593        serviceWorkerProcessProxy->setWorkerUserAgent(processPool->m_workerUserAgent);
     594}
     595#endif
     596
     597void WebProcessPool::removeFromWorkerProcesses(WebProcessProxy& process)
     598{
     599    ASSERT(workerProcesses().contains(process));
     600    workerProcesses().remove(process);
     601}
     602
     603void WebProcessPool::establishSharedWorkerContextConnectionToNetworkProcess(WebCore::RegistrableDomain&& registrableDomain, PAL::SessionID sessionID, CompletionHandler<void()>&& completionHandler)
     604{
     605    auto* websiteDataStore = WebsiteDataStore::existingDataStoreForSessionID(sessionID);
     606    if (!websiteDataStore)
     607        websiteDataStore = WebsiteDataStore::defaultDataStore().ptr();
     608    if (!processPools().size())
     609        static NeverDestroyed<Ref<WebProcessPool>> sharedWorkerProcessPool(WebProcessPool::create(API::ProcessPoolConfiguration::create().get()));
     610
     611    // Arbitrarily choose the first process pool to host the shared worker process.
     612    auto* processPool = processPools()[0];
     613    ASSERT(processPool);
     614
     615    WebProcessProxy* sharedWorkerProcessProxy { nullptr };
     616
     617    for (auto& process : processPool->m_processes) {
     618        if (process.ptr() == processPool->m_prewarmedProcess.get() || process->isDummyProcessProxy())
     619            continue;
     620        if (&process->websiteDataStore() != websiteDataStore)
     621            continue;
     622        if (!process->isMatchingRegistrableDomain(registrableDomain))
     623            continue;
     624
     625        sharedWorkerProcessProxy = process.ptr();
     626        sharedWorkerProcessProxy->enableWorkers(WebProcessProxy::WorkerType::SharedWorker, processPool->userContentControllerIdentifierForWorkers());
     627
     628        if (sharedWorkerProcessProxy->isInProcessCache()) {
     629            processPool->webProcessCache().removeProcess(*sharedWorkerProcessProxy, WebProcessCache::ShouldShutDownProcess::No);
     630            ASSERT(!sharedWorkerProcessProxy->isInProcessCache());
     631        }
     632
     633        WEBPROCESSPOOL_RELEASE_LOG_STATIC(SharedWorker, "establishSharedWorkerContextConnectionToNetworkProcess reusing an existing web process (process=%p, PID=%d)", sharedWorkerProcessProxy, sharedWorkerProcessProxy->processIdentifier());
     634        break;
     635    }
     636
     637    if (!sharedWorkerProcessProxy) {
     638        auto newProcessProxy = WebProcessProxy::createForWorkers(WebProcessProxy::WorkerType::SharedWorker, *processPool, RegistrableDomain  { registrableDomain }, *websiteDataStore);
     639        sharedWorkerProcessProxy = newProcessProxy.ptr();
     640
     641        WEBPROCESSPOOL_RELEASE_LOG_STATIC(SharedWorker, "establishSharedWorkerContextConnectionToNetworkProcess creating a new service worker process (process=%p, PID=%d)", sharedWorkerProcessProxy, sharedWorkerProcessProxy->processIdentifier());
     642
     643        processPool->initializeNewWebProcess(newProcessProxy, websiteDataStore);
     644        processPool->m_processes.append(WTFMove(newProcessProxy));
     645    }
     646
     647    workerProcesses().add(*sharedWorkerProcessProxy);
     648
     649    sharedWorkerProcessProxy->establishSharedWorkerContext(processPool->m_workerPreferences ? processPool->m_workerPreferences.value() : processPool->m_defaultPageGroup->preferences().store(), registrableDomain, WTFMove(completionHandler));
     650    if (!processPool->m_workerUserAgent.isNull())
     651        sharedWorkerProcessProxy->setWorkerUserAgent(processPool->m_workerUserAgent);
     652}
    603653
    604654void WebProcessPool::windowServerConnectionStateChanged()
    … …  
    10041054    m_backForwardCache->removeEntriesForProcess(process);
    10051055
    1006 #if ENABLE(SERVICE_WORKER)
    1007     if (process.isRunningServiceWorkers())
    1008         removeFromServiceWorkerProcesses(process);
    1009 #endif
     1056    if (process.isRunningWorkers())
     1057        removeFromWorkerProcesses(process);
    10101058
    10111059    static_cast<WebContextSupplement*>(supplement<WebGeolocationManagerProxy>())->processDidClose(&process);
    … …  
    10681116
    10691117#if ENABLE(SERVICE_WORKER)
    1070 UserContentControllerIdentifier WebProcessPool::userContentControllerIdentifierForServiceWorkers()
    1071 {
    1072     if (!m_userContentControllerForServiceWorker)
    1073         m_userContentControllerForServiceWorker = WebUserContentControllerProxy::create();
    1074 
    1075     return m_userContentControllerForServiceWorker->identifier();
     1118UserContentControllerIdentifier WebProcessPool::userContentControllerIdentifierForWorkers()
     1119{
     1120    if (!m_userContentControllerForWorkers)
     1121        m_userContentControllerForWorkers = WebUserContentControllerProxy::create();
     1122
     1123    return m_userContentControllerForWorkers->identifier();
    10761124}
    10771125#endif
    … …  
    11201168    auto page = process->createWebPage(pageClient, WTFMove(pageConfiguration));
    11211169
    1122 #if ENABLE(SERVICE_WORKER)
    1123     if (!m_serviceWorkerPreferences) {
    1124         m_serviceWorkerPreferences = page->preferencesStore();
    1125         for (auto& serviceWorkerProcess : serviceWorkerProcesses())
    1126             serviceWorkerProcess.updateServiceWorkerPreferencesStore(*m_serviceWorkerPreferences);
     1170    if (!m_workerPreferences) {
     1171        m_workerPreferences = page->preferencesStore();
     1172        for (auto& workerProcess : workerProcesses())
     1173            workerProcess.updateWorkerPreferencesStore(*m_workerPreferences);
    11271174    }
    11281175    if (userContentController)
    1129         m_userContentControllerForServiceWorker = userContentController;
    1130 #endif
     1176        m_userContentControllerForWorkers = userContentController;
    11311177
    11321178    bool enableProcessSwapOnCrossSiteNavigation = page->preferences().processSwapOnCrossSiteNavigationEnabled();
    … …  
    11511197}
    11521198
    1153 #if ENABLE(SERVICE_WORKER)
    1154 void WebProcessPool::updateServiceWorkerUserAgent(const String& userAgent)
    1155 {
    1156     if (m_serviceWorkerUserAgent == userAgent)
     1199void WebProcessPool::updateWorkerUserAgent(const String& userAgent)
     1200{
     1201    if (m_workerUserAgent == userAgent)
    11571202        return;
    1158     m_serviceWorkerUserAgent = userAgent;
    1159     for (auto& serviceWorkerProcess : serviceWorkerProcesses())
    1160         serviceWorkerProcess.setServiceWorkerUserAgent(m_serviceWorkerUserAgent);
    1161 }
    1162 #endif
     1203    m_workerUserAgent = userAgent;
     1204    for (auto& workerProcess : workerProcesses())
     1205        workerProcess.setWorkerUserAgent(m_workerUserAgent);
     1206}
    11631207
    11641208void WebProcessPool::pageBeginUsingWebsiteDataStore(WebPageProxyIdentifier pageID, WebsiteDataStore& dataStore)
    … …  
    15391583#if ENABLE(SERVICE_WORKER)
    15401584    Ref protectedThis { *this };
    1541     while (serviceWorkerProcesses().computeSize())
    1542         serviceWorkerProcesses().begin()->disableServiceWorkers();
     1585    Vector<Ref<WebProcessProxy>> serviceWorkerProcesses;
     1586    workerProcesses().forEach([&](auto& process) {
     1587        if (process.isRunningServiceWorkers())
     1588            serviceWorkerProcesses.append(process);
     1589    });
     1590    for (auto& serviceWorkerProcess : serviceWorkerProcesses)
     1591        serviceWorkerProcess->disableWorkers(WebProcessProxy::WorkerType::ServiceWorker);
    15431592#endif
    15441593}
    … …  
    17681817}
    17691818
    1770 #if ENABLE(SERVICE_WORKER)
    1771 WeakHashSet<WebProcessProxy>& WebProcessPool::serviceWorkerProcesses()
     1819WeakHashSet<WebProcessProxy>& WebProcessPool::workerProcesses()
    17721820{
    17731821    static NeverDestroyed<WeakHashSet<WebProcessProxy>> processes;
    17741822    return processes;
    17751823}
    1776 #endif
    17771824
    17781825void WebProcessPool::updateProcessAssertions()
    … …  
    17861833        gpuProcess->updateProcessAssertion();
    17871834#endif
    1788 #if ENABLE(SERVICE_WORKER)
     1835
    17891836    // Check on next run loop since the web process proxy tokens are probably being updated.
    17901837    callOnMainRunLoop([] {
    1791         for (auto& serviceWorkerProcess : serviceWorkerProcesses())
    1792             serviceWorkerProcess.updateServiceWorkerProcessAssertion();
     1838        workerProcesses().forEach([](auto& workerProcess) {
     1839#if ENABLE(SERVICE_WORKER)
     1840            if (workerProcess.isRunningServiceWorkers())
     1841                workerProcess.updateWorkerProcessAssertion(WebProcessProxy::WorkerType::ServiceWorker);
     1842#endif
     1843            if (workerProcess.isRunningSharedWorkers())
     1844                workerProcess.updateWorkerProcessAssertion(WebProcessProxy::WorkerType::SharedWorker);
     1845        });
    17931846    });
    1794 #endif
    17951847}
    17961848
    … …  
    17991851#if ENABLE(SERVICE_WORKER)
    18001852    // FIXME: This is inefficient.
    1801     return WTF::anyOf(serviceWorkerProcesses(), [pageID](auto& process) {
     1853    return WTF::anyOf(workerProcesses(), [pageID](auto& process) {
    18021854        return process.hasServiceWorkerPageProxy(pageID);
    18031855    });
    … …  
    21252177
    21262178#if ENABLE(SERVICE_WORKER)
     2179size_t WebProcessPool::serviceWorkerProxiesCount() const
     2180{
     2181    unsigned count = 0;
     2182    workerProcesses().forEach([&](auto& process) {
     2183        if (process.isRunningServiceWorkers())
     2184            ++count;
     2185    });
     2186    return count;
     2187}
     2188
    21272189bool WebProcessPool::hasServiceWorkerForegroundActivityForTesting() const
    21282190{
    2129     return WTF::anyOf(serviceWorkerProcesses(), [](auto& process) {
     2191    return WTF::anyOf(workerProcesses(), [](auto& process) {
    21302192        return process.hasServiceWorkerForegroundActivityForTesting();
    21312193    });
    … …  
    21342196bool WebProcessPool::hasServiceWorkerBackgroundActivityForTesting() const
    21352197{
    2136     return WTF::anyOf(serviceWorkerProcesses(), [](auto& process) {
     2198    return WTF::anyOf(workerProcesses(), [](auto& process) {
    21372199        return process.hasServiceWorkerBackgroundActivityForTesting();
    21382200    });

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

    r288935 r289247  
    375375
    376376    bool isServiceWorkerPageID(WebPageProxyIdentifier) const;
     377    void removeFromWorkerProcesses(WebProcessProxy&);
     378
    377379#if ENABLE(SERVICE_WORKER)
    378     static void establishServiceWorkerContextConnectionToNetworkProcess(NetworkProcessProxy&, WebCore::RegistrableDomain&&, std::optional<WebCore::ScriptExecutionContextIdentifier> serviceWorkerPageIdentifier, PAL::SessionID, CompletionHandler<void()>&&);
    379     void removeFromServiceWorkerProcesses(WebProcessProxy&);
    380     size_t serviceWorkerProxiesCount() const { return serviceWorkerProcesses().computeSize(); }
    381     void updateServiceWorkerUserAgent(const String& userAgent);
    382     UserContentControllerIdentifier userContentControllerIdentifierForServiceWorkers();
     380    static void establishServiceWorkerContextConnectionToNetworkProcess(WebCore::RegistrableDomain&&, std::optional<WebCore::ScriptExecutionContextIdentifier> serviceWorkerPageIdentifier, PAL::SessionID, CompletionHandler<void()>&&);
     381    size_t serviceWorkerProxiesCount() const;
     382    UserContentControllerIdentifier userContentControllerIdentifierForWorkers();
    383383    bool hasServiceWorkerForegroundActivityForTesting() const;
    384384    bool hasServiceWorkerBackgroundActivityForTesting() const;
    385385#endif
    386386    void serviceWorkerProcessCrashed(WebProcessProxy&);
     387
     388    void updateWorkerUserAgent(const String& userAgent);
     389    static void establishSharedWorkerContextConnectionToNetworkProcess(WebCore::RegistrableDomain&&, PAL::SessionID, CompletionHandler<void()>&&);
    387390
    388391#if PLATFORM(COCOA)
    … …  
    619622    HashMap<PAL::SessionID, WeakPtr<WebProcessProxy>> m_dummyProcessProxies; // Lightweight WebProcessProxy objects without backing process.
    620623
    621 #if ENABLE(SERVICE_WORKER)
    622     static WeakHashSet<WebProcessProxy>& serviceWorkerProcesses();
    623     bool m_waitingForWorkerContextProcessConnection { false };
    624     String m_serviceWorkerUserAgent;
    625     std::optional<WebPreferencesStore> m_serviceWorkerPreferences;
    626     RefPtr<WebUserContentControllerProxy> m_userContentControllerForServiceWorker;
    627 #endif
     624    static WeakHashSet<WebProcessProxy>& workerProcesses();
     625
     626    std::optional<WebPreferencesStore> m_workerPreferences;
     627    RefPtr<WebUserContentControllerProxy> m_userContentControllerForWorkers;
     628    String m_workerUserAgent;
    628629
    629630#if ENABLE(GPU_PROCESS)

  • trunk/Source/WebKit/UIProcess/WebProcessProxy.cpp

    r289063 r289247  
    6060#include "WebProcessProxyMessages.h"
    6161#include "WebSWContextManagerConnectionMessages.h"
     62#include "WebSharedWorkerContextManagerConnectionMessages.h"
    6263#include "WebUserContentControllerProxy.h"
    6364#include "WebsiteData.h"
    … …  
    183184
    184185#if ENABLE(SERVICE_WORKER)
    185 Ref<WebProcessProxy> WebProcessProxy::createForServiceWorkers(WebProcessPool& processPool, RegistrableDomain&& registrableDomain, WebsiteDataStore& websiteDataStore)
     186Ref<WebProcessProxy> WebProcessProxy::createForWorkers(WorkerType workerType, WebProcessPool& processPool, RegistrableDomain&& registrableDomain, WebsiteDataStore& websiteDataStore)
    186187{
    187188    auto proxy = adoptRef(*new WebProcessProxy(processPool, &websiteDataStore, IsPrewarmed::No, CrossOriginMode::Shared, CaptivePortalMode::Disabled));
    188189    proxy->m_registrableDomain = WTFMove(registrableDomain);
    189     proxy->enableServiceWorkers(processPool.userContentControllerIdentifierForServiceWorkers());
     190    proxy->enableWorkers(workerType, processPool.userContentControllerIdentifierForWorkers());
    190191    proxy->connect();
    191192    return proxy;
    … …  
    996997        callback(isWebProcessResponsive);
    997998
    998     // If the web process becomes unresponsive and only runs service workers, kill it ourselves since there are no native clients to do it.
    999     if (isRunningServiceWorkers() && m_pageMap.isEmpty()) {
    1000         WEBPROCESSPROXY_RELEASE_LOG_ERROR(PerformanceLogging, "didBecomeUnresponsive: Terminating service worker-only web process because it is unresponsive");
    1001         disableServiceWorkers();
     999    // If the web process becomes unresponsive and only runs service/shared workers, kill it ourselves since there are no native clients to do it.
     1000    if (isRunningWorkers() && m_pageMap.isEmpty()) {
     1001        WEBPROCESSPROXY_RELEASE_LOG_ERROR(PerformanceLogging, "didBecomeUnresponsive: Terminating worker-only web process because it is unresponsive");
     1002        disableWorkers({ WorkerType::ServiceWorker, WorkerType::SharedWorker });
    10021003        terminate();
    10031004    }
    … …  
    16951696    if (m_registrableDomain && *m_registrableDomain != registrableDomain) {
    16961697#if ENABLE(SERVICE_WORKER)
    1697         disableServiceWorkers();
    1698 #endif
     1698        disableWorkers(WorkerType::ServiceWorker);
     1699#endif
     1700
    16991701        // Null out registrable domain since this process has now been used for several domains.
    17001702        m_registrableDomain = WebCore::RegistrableDomain { };
    … …  
    18731875    }, 0);
    18741876}
    1875 
    1876 void WebProcessProxy::setServiceWorkerUserAgent(const String& userAgent)
    1877 {
    1878     ASSERT(m_serviceWorkerInformation);
    1879     send(Messages::WebSWContextManagerConnection::SetUserAgent { userAgent }, 0);
    1880 }
    1881 
    1882 void WebProcessProxy::updateServiceWorkerPreferencesStore(const WebPreferencesStore& store)
    1883 {
    1884     ASSERT(m_serviceWorkerInformation);
    1885     send(Messages::WebSWContextManagerConnection::UpdatePreferencesStore { store }, 0);
    1886 }
    1887 
    1888 void WebProcessProxy::updateServiceWorkerProcessAssertion()
    1889 {
    1890     WEBPROCESSPROXY_RELEASE_LOG(ProcessSuspension, "updateServiceWorkerProcessAssertion:");
    1891     ASSERT(m_serviceWorkerInformation);
    1892     if (!m_serviceWorkerInformation)
    1893         return;
    1894 
    1895     bool shouldTakeForegroundActivity = WTF::anyOf(m_serviceWorkerInformation->clientProcesses, [&](auto& process) {
     1877#endif
     1878
     1879void WebProcessProxy::setWorkerUserAgent(const String& userAgent)
     1880{
     1881#if ENABLE(SERVICE_WORKER)
     1882    if (m_serviceWorkerInformation)
     1883        send(Messages::WebSWContextManagerConnection::SetUserAgent { userAgent }, 0);
     1884#endif
     1885    if (m_sharedWorkerInformation)
     1886        send(Messages::WebSharedWorkerContextManagerConnection::SetUserAgent { userAgent }, 0);
     1887}
     1888
     1889void WebProcessProxy::updateWorkerPreferencesStore(const WebPreferencesStore& store)
     1890{
     1891#if ENABLE(SERVICE_WORKER)
     1892    if (m_serviceWorkerInformation)
     1893        send(Messages::WebSWContextManagerConnection::UpdatePreferencesStore { store }, 0);
     1894#endif
     1895    if (m_sharedWorkerInformation)
     1896        send(Messages::WebSharedWorkerContextManagerConnection::UpdatePreferencesStore { store }, 0);
     1897}
     1898
     1899void WebProcessProxy::updateWorkerProcessAssertion(WorkerType workerType)
     1900{
     1901    auto& workerInformation = workerType == WorkerType::SharedWorker ? m_sharedWorkerInformation : m_serviceWorkerInformation;
     1902    ASSERT(workerInformation);
     1903    if (!workerInformation)
     1904        return;
     1905
     1906    WEBPROCESSPROXY_RELEASE_LOG(ProcessSuspension, "updateWorkerProcessAssertion: workerType=%{public}s", workerType == WorkerType::SharedWorker ? "shared" : "service");
     1907
     1908    // FIXME: Clients do not properly get populated in m_sharedWorkerInformation so we currently take an assertion no matter what.
     1909    if (workerType == WorkerType::SharedWorker) {
     1910        if (!ProcessThrottler::isValidForegroundActivity(workerInformation->activity))
     1911            workerInformation->activity = m_throttler.foregroundActivity("Worker for foreground view(s)"_s);
     1912        return;
     1913    }
     1914
     1915    bool shouldTakeForegroundActivity = WTF::anyOf(workerInformation->clientProcesses, [&](auto& process) {
    18961916        return &process != this && !!process.m_foregroundToken;
    18971917    });
    18981918    if (shouldTakeForegroundActivity) {
    1899         if (!ProcessThrottler::isValidForegroundActivity(m_serviceWorkerInformation->activity))
    1900             m_serviceWorkerInformation->activity = m_throttler.foregroundActivity("Service Worker for foreground view(s)"_s);
    1901         return;
    1902     }
    1903 
    1904     bool shouldTakeBackgroundActivity = WTF::anyOf(m_serviceWorkerInformation->clientProcesses, [&](auto& process) {
     1919        if (!ProcessThrottler::isValidForegroundActivity(workerInformation->activity))
     1920            workerInformation->activity = m_throttler.foregroundActivity("Worker for foreground view(s)"_s);
     1921        return;
     1922    }
     1923
     1924    bool shouldTakeBackgroundActivity = WTF::anyOf(workerInformation->clientProcesses, [&](auto& process) {
    19051925        return &process != this && !!process.m_backgroundToken;
    19061926    });
    19071927    if (shouldTakeBackgroundActivity) {
    1908         if (!ProcessThrottler::isValidBackgroundActivity(m_serviceWorkerInformation->activity))
    1909             m_serviceWorkerInformation->activity = m_throttler.backgroundActivity("Service Worker for background view(s)"_s);
    1910         return;
    1911     }
    1912 
    1913     if (m_hasServiceWorkerBackgroundProcessing) {
     1928        if (!ProcessThrottler::isValidBackgroundActivity(workerInformation->activity))
     1929            workerInformation->activity = m_throttler.backgroundActivity("Worker for background view(s)"_s);
     1930        return;
     1931    }
     1932
     1933    if (workerType == WorkerType::ServiceWorker && m_hasServiceWorkerBackgroundProcessing) {
    19141934        WEBPROCESSPROXY_RELEASE_LOG(ProcessSuspension, "Service Worker for background processing");
    1915         if (!ProcessThrottler::isValidBackgroundActivity(m_serviceWorkerInformation->activity))
    1916             m_serviceWorkerInformation->activity = m_throttler.backgroundActivity("Service Worker for background processing"_s);
    1917         return;
    1918     }
    1919 
    1920     m_serviceWorkerInformation->activity = nullptr;
    1921 }
     1935        if (!ProcessThrottler::isValidBackgroundActivity(workerInformation->activity))
     1936            workerInformation->activity = m_throttler.backgroundActivity("Service Worker for background processing"_s);
     1937        return;
     1938    }
     1939
     1940    workerInformation->activity = nullptr;
     1941}
     1942
     1943void WebProcessProxy::establishSharedWorkerContext(const WebPreferencesStore& store, const RegistrableDomain& registrableDomain, CompletionHandler<void()>&& completionHandler)
     1944{
     1945    WEBPROCESSPROXY_RELEASE_LOG(SharedWorker, "establishSharedWorkerContext: Started");
     1946    markProcessAsRecentlyUsed();
     1947    sendWithAsyncReply(Messages::WebProcess::EstablishSharedWorkerContextConnectionToNetworkProcess { processPool().defaultPageGroup().pageGroupID(), m_sharedWorkerInformation->remoteWorkerPageProxyID, m_sharedWorkerInformation->remoteWorkerPageID, store, registrableDomain, m_sharedWorkerInformation->initializationData }, [this, weakThis = WeakPtr { *this }, completionHandler = WTFMove(completionHandler)]() mutable {
     1948        if (weakThis)
     1949            WEBPROCESSPROXY_RELEASE_LOG(SharedWorker, "establishSharedWorkerContext: Finished");
     1950        completionHandler();
     1951    }, 0);
     1952}
     1953
     1954#if ENABLE(SERVICE_WORKER)
    19221955
    19231956void WebProcessProxy::registerServiceWorkerClientProcess(WebProcessProxy& proxy)
    … …  
    19281961    WEBPROCESSPROXY_RELEASE_LOG(ServiceWorker, "registerServiceWorkerClientProcess: clientProcess=%p, clientPID=%d", &proxy, proxy.processIdentifier());
    19291962    m_serviceWorkerInformation->clientProcesses.add(proxy);
    1930     updateServiceWorkerProcessAssertion();
     1963    updateWorkerProcessAssertion(WorkerType::ServiceWorker);
    19311964}
    19321965
    … …  
    19381971    WEBPROCESSPROXY_RELEASE_LOG(ServiceWorker, "unregisterServiceWorkerClientProcess: clientProcess=%p, clientPID=%d", &proxy, proxy.processIdentifier());
    19391972    m_serviceWorkerInformation->clientProcesses.remove(proxy);
    1940     updateServiceWorkerProcessAssertion();
     1973    updateWorkerProcessAssertion(WorkerType::ServiceWorker);
    19411974}
    19421975
    … …  
    19581991    WEBPROCESSPROXY_RELEASE_LOG(ProcessSuspension, "startServiceWorkerBackgroundProcessing");
    19591992    m_hasServiceWorkerBackgroundProcessing = true;
    1960     updateServiceWorkerProcessAssertion();
     1993    updateWorkerProcessAssertion(WorkerType::ServiceWorker);
    19611994}
    19621995
    … …  
    19682001    WEBPROCESSPROXY_RELEASE_LOG(ProcessSuspension, "endServiceWorkerBackgroundProcessing");
    19692002    m_hasServiceWorkerBackgroundProcessing = false;
    1970     updateServiceWorkerProcessAssertion();
     2003    updateWorkerProcessAssertion(WorkerType::ServiceWorker);
    19712004}
    19722005#endif // ENABLE(SERVICE_WORKER)
    19732006
    1974 void WebProcessProxy::disableServiceWorkers()
    1975 {
    1976     if (!m_serviceWorkerInformation)
    1977         return;
    1978 
    1979     WEBPROCESSPROXY_RELEASE_LOG(ServiceWorker, "disableServiceWorkers:");
    1980     m_serviceWorkerInformation = { };
     2007void WebProcessProxy::disableWorkers(OptionSet<WorkerType> workerType)
     2008{
     2009    ASSERT(!workerType.isEmpty());
     2010
     2011    bool didChange = false;
     2012    if (workerType.contains(WorkerType::ServiceWorker) && m_serviceWorkerInformation) {
     2013        m_serviceWorkerInformation = { };
     2014        didChange = true;
     2015    }
     2016    if (workerType.contains(WorkerType::SharedWorker) && m_sharedWorkerInformation) {
     2017        m_sharedWorkerInformation = { };
     2018        didChange = true;
     2019    }
     2020    if (!didChange)
     2021        return;
     2022
     2023    WEBPROCESSPROXY_RELEASE_LOG(Process, "disableWorkers: Disabling workers (SharedWorkers=%d, ServiceWorkers=%d)", workerType.contains(WorkerType::SharedWorker), workerType.contains(WorkerType::ServiceWorker));
     2024
    19812025    updateBackgroundResponsivenessTimer();
    19822026
     2027    if (!isRunningWorkers())
     2028        processPool().removeFromWorkerProcesses(*this);
     2029
    19832030#if ENABLE(SERVICE_WORKER)
    1984     processPool().removeFromServiceWorkerProcesses(*this);
    1985     send(Messages::WebSWContextManagerConnection::Close { }, 0);
    1986 #endif
     2031    if (workerType.contains(WorkerType::ServiceWorker))
     2032        send(Messages::WebSWContextManagerConnection::Close { }, 0);
     2033#endif
     2034    if (workerType.contains(WorkerType::SharedWorker))
     2035        send(Messages::WebSharedWorkerContextManagerConnection::Close { }, 0);
    19872036
    19882037    maybeShutDown();
    … …  
    20052054#endif
    20062055
    2007 void WebProcessProxy::enableServiceWorkers(const UserContentControllerIdentifier& userContentControllerIdentifier)
    2008 {
    2009     ASSERT(!m_serviceWorkerInformation);
    2010     WEBPROCESSPROXY_RELEASE_LOG(ServiceWorker, "enableServiceWorkers:");
    2011     m_serviceWorkerInformation = RemoteWorkerInformation {
     2056void WebProcessProxy::enableWorkers(WorkerType workerType, const UserContentControllerIdentifier& userContentControllerIdentifier)
     2057{
     2058    WEBPROCESSPROXY_RELEASE_LOG(ServiceWorker, "enableWorkers: workerType=%u", static_cast<unsigned>(workerType));
     2059    auto& workerInformation = workerType == WorkerType::SharedWorker ? m_sharedWorkerInformation : m_serviceWorkerInformation;
     2060    ASSERT(!workerInformation);
     2061
     2062    workerInformation = RemoteWorkerInformation {
    20122063        WebPageProxyIdentifier::generate(),
    20132064        PageIdentifier::generate(),
    … …  
    20222073    };
    20232074    updateBackgroundResponsivenessTimer();
    2024 #if ENABLE(SERVICE_WORKER)
    2025     updateServiceWorkerProcessAssertion();
    2026 #endif
     2075
     2076    updateWorkerProcessAssertion(workerType);
    20272077}
    20282078

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

    r289063 r289247  
    137137    enum class ShouldLaunchProcess : bool { No, Yes };
    138138    enum class CaptivePortalMode : bool { Disabled, Enabled };
     139    enum class WorkerType : uint32_t {
     140        ServiceWorker = 1 << 0,
     141        SharedWorker = 1 << 1
     142    };
    139143
    140144    static Ref<WebProcessProxy> create(WebProcessPool&, WebsiteDataStore*, CaptivePortalMode, IsPrewarmed, WebCore::CrossOriginMode = WebCore::CrossOriginMode::Shared, ShouldLaunchProcess = ShouldLaunchProcess::Yes);
    141     static Ref<WebProcessProxy> createForServiceWorkers(WebProcessPool&, WebCore::RegistrableDomain&&, WebsiteDataStore&);
     145    static Ref<WebProcessProxy> createForWorkers(WorkerType, WebProcessPool&, WebCore::RegistrableDomain&&, WebsiteDataStore&);
    142146
    143147    ~WebProcessProxy();
    … …  
    162166    bool isInProcessCache() const { return m_isInProcessCache; }
    163167
    164     void enableServiceWorkers(const UserContentControllerIdentifier&);
    165     void disableServiceWorkers();
     168    void enableWorkers(WorkerType, const UserContentControllerIdentifier&);
     169    void disableWorkers(OptionSet<WorkerType>);
    166170
    167171    WebsiteDataStore& websiteDataStore() const { ASSERT(m_websiteDataStore); return *m_websiteDataStore; }
    … …  
    195199    bool isRunningServiceWorkers() const { return !!m_serviceWorkerInformation; }
    196200    bool isStandaloneServiceWorkerProcess() const { return isRunningServiceWorkers() && !pageCount(); }
     201    bool isRunningSharedWorkers() const { return !!m_sharedWorkerInformation; }
     202    bool isStandaloneSharedWorkerProcess() const { return isRunningSharedWorkers() && !pageCount(); }
     203    bool isRunningWorkers() const { return m_sharedWorkerInformation || m_serviceWorkerInformation; }
    197204
    198205    bool isDummyProcessProxy() const;
    … …  
    360367    void updateAudibleMediaAssertions();
    361368
     369    void setWorkerUserAgent(const String&);
     370    void updateWorkerPreferencesStore(const WebPreferencesStore&);
     371    void establishSharedWorkerContext(const WebPreferencesStore&, const WebCore::RegistrableDomain&, CompletionHandler<void()>&&);
     372    void updateWorkerProcessAssertion(WorkerType);
    362373#if ENABLE(SERVICE_WORKER)
    363374    void establishServiceWorkerContext(const WebPreferencesStore&, const WebCore::RegistrableDomain&, std::optional<WebCore::ScriptExecutionContextIdentifier> serviceWorkerPageIdentifier, CompletionHandler<void()>&&);
    364     void setServiceWorkerUserAgent(const String&);
    365     void updateServiceWorkerPreferencesStore(const WebPreferencesStore&);
    366375    bool hasServiceWorkerPageProxy(WebPageProxyIdentifier pageProxyID) { return m_serviceWorkerInformation && m_serviceWorkerInformation->remoteWorkerPageProxyID == pageProxyID; }
    367     void updateServiceWorkerProcessAssertion();
    368376    void registerServiceWorkerClientProcess(WebProcessProxy&);
    369377    void unregisterServiceWorkerClientProcess(WebProcessProxy&);
    … …  
    657665    };
    658666    std::optional<RemoteWorkerInformation> m_serviceWorkerInformation;
     667    std::optional<RemoteWorkerInformation> m_sharedWorkerInformation;
    659668    bool m_hasServiceWorkerBackgroundProcessing { false };
    660669

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

    r289245 r289247  
    881881                461CCCA5231485A700B659B9 /* UIRemoteObjectRegistry.h in Headers */ = {isa = PBXBuildFile; fileRef = 463236852314833F00A48FA7 /* UIRemoteObjectRegistry.h */; };
    882882                461CCCA6231485AA00B659B9 /* WebRemoteObjectRegistry.h in Headers */ = {isa = PBXBuildFile; fileRef = 46323683231481EF00A48FA7 /* WebRemoteObjectRegistry.h */; };
     883                461E1BF2279A0116006AF53B /* WebSharedWorkerContextManagerConnection.h in Headers */ = {isa = PBXBuildFile; fileRef = 461E1BEF279A010F006AF53B /* WebSharedWorkerContextManagerConnection.h */; };
    883884                463FD4801EB9459600A2982C /* WKProcessTerminationReason.h in Headers */ = {isa = PBXBuildFile; fileRef = 463FD47F1EB9458400A2982C /* WKProcessTerminationReason.h */; settings = {ATTRIBUTES = (Private, ); }; };
    884885                463FD4821EB94EC000A2982C /* ProcessTerminationReason.h in Headers */ = {isa = PBXBuildFile; fileRef = 463FD4811EB94EAD00A2982C /* ProcessTerminationReason.h */; };
     886                4656F7BD27ACAA8D00CB3D7C /* WebSharedWorker.h in Headers */ = {isa = PBXBuildFile; fileRef = 4656F7BC27ACAA8100CB3D7C /* WebSharedWorker.h */; };
    885887                4659F25F275FF6B200BBB369 /* CaptivePortalModeObserver.h in Headers */ = {isa = PBXBuildFile; fileRef = 4659F25E275FF6B200BBB369 /* CaptivePortalModeObserver.h */; };
    886888                465F4E06230B2E95003CEDB7 /* StorageNamespaceIdentifier.h in Headers */ = {isa = PBXBuildFile; fileRef = 465F4E05230B2E7C003CEDB7 /* StorageNamespaceIdentifier.h */; };
    … …  
    901903                46C5B7CE27AADDD3000C5B47 /* RemoteWorkerFrameLoaderClient.h in Headers */ = {isa = PBXBuildFile; fileRef = 46C5B7CD27AADDBE000C5B47 /* RemoteWorkerFrameLoaderClient.h */; };
    902904                46C5B7CF27AADDD6000C5B47 /* RemoteWorkerLibWebRTCProvider.h in Headers */ = {isa = PBXBuildFile; fileRef = 46C5B7CB27AADDBE000C5B47 /* RemoteWorkerLibWebRTCProvider.h */; };
     905                46C916AA2799D0A2001A4E7C /* WebSharedWorkerServer.h in Headers */ = {isa = PBXBuildFile; fileRef = 46C916A92799D09D001A4E7C /* WebSharedWorkerServer.h */; };
    903906                46CE3B1123D8C8490016A96A /* WebBackForwardListCounts.h in Headers */ = {isa = PBXBuildFile; fileRef = 46CE3B1023D8C83D0016A96A /* WebBackForwardListCounts.h */; };
     907                46D48FCE2799D7E1007D2014 /* WebSharedWorkerServerToContextConnection.h in Headers */ = {isa = PBXBuildFile; fileRef = 46D48FCD2799D7DE007D2014 /* WebSharedWorkerServerToContextConnection.h */; };
    904908                46DF063C1F3905F8001980BB /* NetworkCORSPreflightChecker.h in Headers */ = {isa = PBXBuildFile; fileRef = 46DF063A1F3905E5001980BB /* NetworkCORSPreflightChecker.h */; };
    905909                46EE2849269E04AC00DD48AB /* WebBroadcastChannelRegistry.h in Headers */ = {isa = PBXBuildFile; fileRef = 46EE2848269E049B00DD48AB /* WebBroadcastChannelRegistry.h */; };
    906910                46EE284D269E052500DD48AB /* NetworkBroadcastChannelRegistry.h in Headers */ = {isa = PBXBuildFile; fileRef = 46EE284C269E051700DD48AB /* NetworkBroadcastChannelRegistry.h */; };
     911                46EE3E8B2763FD2F0060C70F /* WebSharedWorkerServerConnection.h in Headers */ = {isa = PBXBuildFile; fileRef = 468386672763FAB100CF9182 /* WebSharedWorkerServerConnection.h */; };
    907912                46F38E8C2416E6730059375A /* RunningBoardServicesSPI.h in Headers */ = {isa = PBXBuildFile; fileRef = 46F38E8B2416E66D0059375A /* RunningBoardServicesSPI.h */; };
    908913                46F9B26323526EF3006FE5FA /* WebBackForwardCacheEntry.h in Headers */ = {isa = PBXBuildFile; fileRef = 46F9B26223526ED0006FE5FA /* WebBackForwardCacheEntry.h */; };
    … …  
    42244229                460F488D1F996F6C00CF4B87 /* WebSWContextManagerConnectionMessageReceiver.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = WebSWContextManagerConnectionMessageReceiver.cpp; path = DerivedSources/WebKit/WebSWContextManagerConnectionMessageReceiver.cpp; sourceTree = BUILT_PRODUCTS_DIR; };
    42254230                460F488E1F996F6C00CF4B87 /* WebSWContextManagerConnectionMessages.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; name = WebSWContextManagerConnectionMessages.h; path = DerivedSources/WebKit/WebSWContextManagerConnectionMessages.h; sourceTree = BUILT_PRODUCTS_DIR; };
     4231                461E1BEC279A010E006AF53B /* WebSharedWorkerContextManagerConnection.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = WebSharedWorkerContextManagerConnection.cpp; sourceTree = "<group>"; };
     4232                461E1BEF279A010F006AF53B /* WebSharedWorkerContextManagerConnection.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = WebSharedWorkerContextManagerConnection.h; sourceTree = "<group>"; };
     4233                461E1BF0279A010F006AF53B /* WebSharedWorkerContextManagerConnection.messages.in */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text; path = WebSharedWorkerContextManagerConnection.messages.in; sourceTree = "<group>"; };
    42264234                462107D71F38DBD300DD7810 /* PingLoad.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = PingLoad.cpp; sourceTree = "<group>"; };
    42274235                46323683231481EF00A48FA7 /* WebRemoteObjectRegistry.h */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.c.h; path = WebRemoteObjectRegistry.h; sourceTree = "<group>"; };
    … …  
    42344242                4651ECE622178A850067EB95 /* WebProcessCacheCocoa.mm */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.objcpp; path = WebProcessCacheCocoa.mm; sourceTree = "<group>"; };
    42354243                465250E51ECF52CD002025CB /* WebKit2InitializeCocoa.mm */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.objcpp; path = WebKit2InitializeCocoa.mm; sourceTree = "<group>"; };
     4244                4656F7BA27ACAA8000CB3D7C /* WebSharedWorkerServerToContextConnection.messages.in */ = {isa = PBXFileReference; lastKnownFileType = text; path = WebSharedWorkerServerToContextConnection.messages.in; sourceTree = "<group>"; };
     4245                4656F7BB27ACAA8100CB3D7C /* WebSharedWorker.cpp */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.cpp.cpp; path = WebSharedWorker.cpp; sourceTree = "<group>"; };
     4246                4656F7BC27ACAA8100CB3D7C /* WebSharedWorker.h */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.c.h; path = WebSharedWorker.h; sourceTree = "<group>"; };
    42364247                4659F25E275FF6B200BBB369 /* CaptivePortalModeObserver.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = CaptivePortalModeObserver.h; sourceTree = "<group>"; };
    42374248                465F4E02230759D5003CEDB7 /* StorageAreaIdentifier.h */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.c.h; path = StorageAreaIdentifier.h; sourceTree = "<group>"; };
    … …  
    42554266                4683569A21E81CC7006E27A3 /* ProvisionalPageProxy.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = ProvisionalPageProxy.h; sourceTree = "<group>"; };
    42564267                4683569B21E81CC7006E27A3 /* ProvisionalPageProxy.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = ProvisionalPageProxy.cpp; sourceTree = "<group>"; };
     4268                468386672763FAB100CF9182 /* WebSharedWorkerServerConnection.h */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.c.h; path = WebSharedWorkerServerConnection.h; sourceTree = "<group>"; };
     4269                468386682763FAB100CF9182 /* WebSharedWorkerServerConnection.cpp */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.cpp.cpp; path = WebSharedWorkerServerConnection.cpp; sourceTree = "<group>"; };
    42574270                4689B90F2756D1430007C651 /* RemoteWebLockRegistry.h */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.c.h; path = RemoteWebLockRegistry.h; sourceTree = "<group>"; };
    42584271                4689B9102756D1430007C651 /* RemoteWebLockRegistry.cpp */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.cpp.cpp; path = RemoteWebLockRegistry.cpp; sourceTree = "<group>"; };
     4272                46943DCB2763F834004B610E /* WebSharedWorkerObjectConnection.messages.in */ = {isa = PBXFileReference; lastKnownFileType = text; path = WebSharedWorkerObjectConnection.messages.in; sourceTree = "<group>"; };
    42594273                469DE802273ECC5D00930276 /* ProcessLauncherCocoa.mm */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.objcpp; path = ProcessLauncherCocoa.mm; sourceTree = "<group>"; };
    42604274                46A2B6061E5675A200C3DEDA /* BackgroundProcessResponsivenessTimer.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = BackgroundProcessResponsivenessTimer.cpp; sourceTree = "<group>"; };
    … …  
    42754289                46C5B7CC27AADDBE000C5B47 /* RemoteWorkerFrameLoaderClient.cpp */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.cpp.cpp; path = RemoteWorkerFrameLoaderClient.cpp; sourceTree = "<group>"; };
    42764290                46C5B7CD27AADDBE000C5B47 /* RemoteWorkerFrameLoaderClient.h */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.c.h; path = RemoteWorkerFrameLoaderClient.h; sourceTree = "<group>"; };
     4291                46C916A82799D09D001A4E7C /* WebSharedWorkerServer.cpp */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.cpp.cpp; path = WebSharedWorkerServer.cpp; sourceTree = "<group>"; };
     4292                46C916A92799D09D001A4E7C /* WebSharedWorkerServer.h */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.c.h; path = WebSharedWorkerServer.h; sourceTree = "<group>"; };
    42774293                46CE3B1023D8C83D0016A96A /* WebBackForwardListCounts.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = WebBackForwardListCounts.h; sourceTree = "<group>"; };
     4294                46D48FCC2799D7DD007D2014 /* WebSharedWorkerServerToContextConnection.cpp */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.cpp.cpp; path = WebSharedWorkerServerToContextConnection.cpp; sourceTree = "<group>"; };
     4295                46D48FCD2799D7DE007D2014 /* WebSharedWorkerServerToContextConnection.h */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.c.h; path = WebSharedWorkerServerToContextConnection.h; sourceTree = "<group>"; };
    42784296                46DF06391F3905E5001980BB /* NetworkCORSPreflightChecker.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = NetworkCORSPreflightChecker.cpp; sourceTree = "<group>"; };
    42794297                46DF063A1F3905E5001980BB /* NetworkCORSPreflightChecker.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = NetworkCORSPreflightChecker.h; sourceTree = "<group>"; };
    … …  
    42854303                46EE284B269E051700DD48AB /* NetworkBroadcastChannelRegistry.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = NetworkBroadcastChannelRegistry.cpp; sourceTree = "<group>"; };
    42864304                46EE284C269E051700DD48AB /* NetworkBroadcastChannelRegistry.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = NetworkBroadcastChannelRegistry.h; sourceTree = "<group>"; };
     4305                46EE3E8A2763FD2A0060C70F /* WebSharedWorkerServerConnection.messages.in */ = {isa = PBXFileReference; lastKnownFileType = text; path = WebSharedWorkerServerConnection.messages.in; sourceTree = "<group>"; };
    42874306                46F38E8B2416E66D0059375A /* RunningBoardServicesSPI.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = RunningBoardServicesSPI.h; sourceTree = "<group>"; };
    42884307                46F9B26223526ED0006FE5FA /* WebBackForwardCacheEntry.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = WebBackForwardCacheEntry.h; sourceTree = "<group>"; };
    … …  
    92969315                        sourceTree = "<group>";
    92979316                };
     9317                468386652763FA1B00CF9182 /* SharedWorker */ = {
     9318                        isa = PBXGroup;
     9319                        children = (
     9320                                4656F7BB27ACAA8100CB3D7C /* WebSharedWorker.cpp */,
     9321                                4656F7BC27ACAA8100CB3D7C /* WebSharedWorker.h */,
     9322                                46C916A82799D09D001A4E7C /* WebSharedWorkerServer.cpp */,
     9323                                46C916A92799D09D001A4E7C /* WebSharedWorkerServer.h */,
     9324                                468386682763FAB100CF9182 /* WebSharedWorkerServerConnection.cpp */,
     9325                                468386672763FAB100CF9182 /* WebSharedWorkerServerConnection.h */,
     9326                                46EE3E8A2763FD2A0060C70F /* WebSharedWorkerServerConnection.messages.in */,
     9327                                46D48FCC2799D7DD007D2014 /* WebSharedWorkerServerToContextConnection.cpp */,
     9328                                46D48FCD2799D7DE007D2014 /* WebSharedWorkerServerToContextConnection.h */,
     9329                                4656F7BA27ACAA8000CB3D7C /* WebSharedWorkerServerToContextConnection.messages.in */,
     9330                        );
     9331                        path = SharedWorker;
     9332                        sourceTree = "<group>";
     9333                };
    92989334                469DE801273ECC5D00930276 /* cocoa */ = {
    92999335                        isa = PBXGroup;
    … …  
    93609396                                5C01BC3526D46AD400FEB42F /* PrivateClickMeasurement */,
    93619397                                93BA04D92151ADCD007F455F /* ServiceWorker */,
     9398                                468386652763FA1B00CF9182 /* SharedWorker */,
    93629399                                93085DC226E1BB65000EC6A7 /* storage */,
    93639400                                413075971DE84ED70039EC69 /* webrtc */,
    … …  
    94629499                                51BEB6291F3A5ACD005029B9 /* WebServiceWorkerProvider.cpp */,
    94639500                                51BEB62A1F3A5ACD005029B9 /* WebServiceWorkerProvider.h */,
     9501                                461E1BEC279A010E006AF53B /* WebSharedWorkerContextManagerConnection.cpp */,
     9502                                461E1BEF279A010F006AF53B /* WebSharedWorkerContextManagerConnection.h */,
     9503                                461E1BF0279A010F006AF53B /* WebSharedWorkerContextManagerConnection.messages.in */,
    94649504                                4668A0BB27AB604000C720BC /* WebSharedWorkerObjectConnection.cpp */,
    94659505                                4668A0B827AB603F00C720BC /* WebSharedWorkerObjectConnection.h */,
     9506                                46943DCB2763F834004B610E /* WebSharedWorkerObjectConnection.messages.in */,
    94669507                                4668A0B927AB603F00C720BC /* WebSharedWorkerProvider.cpp */,
    94679508                                4668A0BA27AB604000C720BC /* WebSharedWorkerProvider.h */,
    … …  
    1365913700                                D3B9484911FF4B6500032B39 /* WebSearchPopupMenu.h in Headers */,
    1366013701                                51BEB62C1F3A5AD7005029B9 /* WebServiceWorkerProvider.h in Headers */,
     13702                                4656F7BD27ACAA8D00CB3D7C /* WebSharedWorker.h in Headers */,
     13703                                461E1BF2279A0116006AF53B /* WebSharedWorkerContextManagerConnection.h in Headers */,
    1366113704                                4668A0BD27AB605600C720BC /* WebSharedWorkerObjectConnection.h in Headers */,
    1366213705                                4668A0BC27AB605000C720BC /* WebSharedWorkerProvider.h in Headers */,
     13706                                46C916AA2799D0A2001A4E7C /* WebSharedWorkerServer.h in Headers */,
     13707                                46EE3E8B2763FD2F0060C70F /* WebSharedWorkerServerConnection.h in Headers */,
     13708                                46D48FCE2799D7E1007D2014 /* WebSharedWorkerServerToContextConnection.h in Headers */,
    1366313709                                5C8DD3801FE4521600F2A556 /* WebsiteAutoplayPolicy.h in Headers */,
    1366413710                                1A4832D71A9CDF96008B4DFE /* WebsiteData.h in Headers */,

  • trunk/Source/WebKit/WebProcess/Network/NetworkProcessConnection.cpp

    r289054 r289247  
    5858#include "WebSWContextManagerConnectionMessages.h"
    5959#include "WebServiceWorkerProvider.h"
     60#include "WebSharedWorkerContextManagerConnection.h"
     61#include "WebSharedWorkerContextManagerConnectionMessages.h"
    6062#include "WebSharedWorkerObjectConnection.h"
     63#include "WebSharedWorkerObjectConnectionMessages.h"
    6164#include "WebSocketChannel.h"
    6265#include "WebSocketChannelMessages.h"
    … …  
    175178    }
    176179#endif
     180    if (decoder.messageReceiverName() == Messages::WebSharedWorkerObjectConnection::messageReceiverName()) {
     181        sharedWorkerConnection().didReceiveMessage(connection, decoder);
     182        return;
     183    }
     184    if (decoder.messageReceiverName() == Messages::WebSharedWorkerContextManagerConnection::messageReceiverName()) {
     185        ASSERT(SharedWorkerContextManager::singleton().connection());
     186        if (auto* contextManagerConnection = SharedWorkerContextManager::singleton().connection())
     187            static_cast<WebSharedWorkerContextManagerConnection&>(*contextManagerConnection).didReceiveMessage(connection, decoder);
     188        return;
     189    }
    177190
    178191#if ENABLE(APPLE_PAY_REMOTE_UI)

  • trunk/Source/WebKit/WebProcess/Network/NetworkProcessConnection.h

    r289054 r289247  
    4949
    5050class WebIDBConnectionToServer;
     51class WebSharedWorkerObjectConnection;
    5152class WebSWClientConnection;
    5253class WebSharedWorkerObjectConnection;

  • trunk/Source/WebKit/WebProcess/Storage/WebSharedWorkerObjectConnection.cpp

    r289054 r289247  
    2727#include "WebSharedWorkerObjectConnection.h"
    2828
     29#include "Logging.h"
    2930#include "NetworkProcessConnection.h"
    3031#include "WebProcess.h"
    31 #include <WebCore/SharedWorkerManager.h>
     32#include "WebSharedWorkerServerConnectionMessages.h"
     33#include <WebCore/ProcessIdentifier.h>
     34#include <WebCore/SharedWorkerKey.h>
     35#include <WebCore/WorkerOptions.h>
    3236
    3337namespace WebKit {
    3438
    35 WebSharedWorkerObjectConnection::WebSharedWorkerObjectConnection() = default;
     39#define CONNECTION_RELEASE_LOG(fmt, ...) RELEASE_LOG(SharedWorker, "%p - [webProcessIdentifier=%" PRIu64 "] WebSharedWorkerObjectConnection::" fmt, this, WebCore::Process::identifier().toUInt64(), ##__VA_ARGS__)
     40
     41WebSharedWorkerObjectConnection::WebSharedWorkerObjectConnection()
     42{
     43    CONNECTION_RELEASE_LOG("WebSharedWorkerObjectConnection:");
     44}
     45
     46WebSharedWorkerObjectConnection::~WebSharedWorkerObjectConnection()
     47{
     48    CONNECTION_RELEASE_LOG("~WebSharedWorkerObjectConnection:");
     49}
    3650
    3751IPC::Connection* WebSharedWorkerObjectConnection::messageSenderConnection() const
    … …  
    4054}
    4155
    42 void WebSharedWorkerObjectConnection::requestSharedWorker(const URL& url, WebCore::SharedWorker& sharedWorker, WebCore::TransferredMessagePort&& port, WebCore::WorkerOptions&& workerOptions)
     56void WebSharedWorkerObjectConnection::requestSharedWorker(const WebCore::SharedWorkerKey& sharedWorkerKey, WebCore::SharedWorkerObjectIdentifier sharedWorkerObjectIdentifier, WebCore::TransferredMessagePort&& port, const WebCore::WorkerOptions& workerOptions)
    4357{
    44     // FIXME: Should send IPC to the network process.
    45     WebCore::SharedWorkerManager::singleton().connect(url, sharedWorker, WTFMove(port), WTFMove(workerOptions));
     58    CONNECTION_RELEASE_LOG("requestSharedWorker: sharedWorkerObjectIdentifier=%{public}s", sharedWorkerObjectIdentifier.toString().utf8().data());
     59    send(Messages::WebSharedWorkerServerConnection::RequestSharedWorker { sharedWorkerKey, sharedWorkerObjectIdentifier, WTFMove(port), workerOptions });
    4660}
    4761
     62void WebSharedWorkerObjectConnection::sharedWorkerObjectIsGoingAway(const WebCore::SharedWorkerKey& sharedWorkerKey, WebCore::SharedWorkerObjectIdentifier sharedWorkerObjectIdentifier)
     63{
     64    CONNECTION_RELEASE_LOG("sharedWorkerObjectIsGoingAway: sharedWorkerObjectIdentifier=%{public}s", sharedWorkerObjectIdentifier.toString().utf8().data());
     65    send(Messages::WebSharedWorkerServerConnection::SharedWorkerObjectIsGoingAway { sharedWorkerKey, sharedWorkerObjectIdentifier });
     66}
     67
     68#undef CONNECTION_RELEASE_LOG
     69
    4870} // namespace WebKit

  • trunk/Source/WebKit/WebProcess/Storage/WebSharedWorkerObjectConnection.h

    r289054 r289247  
    2626#pragma once
    2727
     28#include "MessageReceiver.h"
    2829#include "MessageSender.h"
    2930#include <WebCore/SharedWorkerObjectConnection.h>
    … …  
    3132namespace WebKit {
    3233
    33 class WebSharedWorkerObjectConnection final : public WebCore::SharedWorkerObjectConnection, private IPC::MessageSender {
     34class WebSharedWorkerObjectConnection final : public WebCore::SharedWorkerObjectConnection, private IPC::MessageSender, public IPC::MessageReceiver {
    3435public:
    3536    static Ref<WebSharedWorkerObjectConnection> create() { return adoptRef(*new WebSharedWorkerObjectConnection); }
     37    ~WebSharedWorkerObjectConnection();
     38
     39    void didReceiveMessage(IPC::Connection&, IPC::Decoder&) final;
    3640
    3741private:
    … …  
    3943
    4044    // WebCore::SharedWorkerObjectConnection.
    41     void requestSharedWorker(const URL&, WebCore::SharedWorker&, WebCore::TransferredMessagePort&&, WebCore::WorkerOptions&&) final;
     45    void requestSharedWorker(const WebCore::SharedWorkerKey&, WebCore::SharedWorkerObjectIdentifier, WebCore::TransferredMessagePort&&, const WebCore::WorkerOptions&) final;
     46    void sharedWorkerObjectIsGoingAway(const WebCore::SharedWorkerKey&, WebCore::SharedWorkerObjectIdentifier) final;
    4247
    4348    // IPC::MessageSender.

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

    r289063 r289247  
    8585#include "WebSWContextManagerConnectionMessages.h"
    8686#include "WebServiceWorkerProvider.h"
     87#include "WebSharedWorkerContextManagerConnection.h"
     88#include "WebSharedWorkerContextManagerConnectionMessages.h"
    8789#include "WebSharedWorkerProvider.h"
    8890#include "WebSocketStream.h"
    … …  
    135137#include <WebCore/ServiceWorkerContextData.h>
    136138#include <WebCore/Settings.h>
     139#include <WebCore/SharedWorkerContextManager.h>
    137140#include <WebCore/UserGestureIndicator.h>
    138141#include <pal/Logging.h>
    … …  
    905908
    906909#if ENABLE(SERVICE_WORKER)
    907     // FIXME: Remove?
    908910    if (decoder.messageReceiverName() == Messages::WebSWContextManagerConnection::messageReceiverName()) {
    909911        ASSERT(SWContextManager::singleton().connection());
    … …  
    913915    }
    914916#endif
     917
     918    if (decoder.messageReceiverName() == Messages::WebSharedWorkerContextManagerConnection::messageReceiverName()) {
     919        ASSERT(SharedWorkerContextManager::singleton().connection());
     920        if (auto* contextManagerConnection = SharedWorkerContextManager::singleton().connection())
     921            static_cast<WebSharedWorkerContextManagerConnection&>(*contextManagerConnection).didReceiveMessage(connection, decoder);
     922        return;
     923    }
    915924
    916925    LOG_ERROR("Unhandled web process message '%s' (destination: %" PRIu64 " pid: %d)", description(decoder.messageName()), decoder.destinationID(), static_cast<int>(getCurrentProcessID()));
    … …  
    19201929}
    19211930
     1931void WebProcess::establishSharedWorkerContextConnectionToNetworkProcess(PageGroupIdentifier pageGroupID, WebPageProxyIdentifier webPageProxyID, PageIdentifier pageID, const WebPreferencesStore& store, RegistrableDomain&& registrableDomain, RemoteWorkerInitializationData&& initializationData, CompletionHandler<void()>&& completionHandler)
     1932{
     1933    // We are in the Shared Worker context process and the call below establishes our connection to the Network Process
     1934    // by calling ensureNetworkProcessConnection. SharedWorkerContextManager needs to use the same underlying IPC::Connection as the
     1935    // NetworkProcessConnection for synchronization purposes.
     1936    auto& ipcConnection = ensureNetworkProcessConnection().connection();
     1937    SharedWorkerContextManager::singleton().setConnection(makeUnique<WebSharedWorkerContextManagerConnection>(ipcConnection, WTFMove(registrableDomain), pageGroupID, webPageProxyID, pageID, store, WTFMove(initializationData)));
     1938    SharedWorkerContextManager::singleton().connection()->establishConnection(WTFMove(completionHandler));
     1939}
     1940
    19221941#if ENABLE(SERVICE_WORKER)
    19231942void WebProcess::establishServiceWorkerContextConnectionToNetworkProcess(PageGroupIdentifier pageGroupID, WebPageProxyIdentifier webPageProxyID, PageIdentifier pageID, const WebPreferencesStore& store, RegistrableDomain&& registrableDomain, std::optional<ScriptExecutionContextIdentifier> serviceWorkerPageIdentifier, RemoteWorkerInitializationData&& initializationData, CompletionHandler<void()>&& completionHandler)

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

    r289134 r289247  
    475475#endif
    476476
     477    void establishSharedWorkerContextConnectionToNetworkProcess(PageGroupIdentifier, WebPageProxyIdentifier, WebCore::PageIdentifier, const WebPreferencesStore&, WebCore::RegistrableDomain&&, RemoteWorkerInitializationData&&, CompletionHandler<void()>&&);
    477478#if ENABLE(SERVICE_WORKER)
    478479    void establishServiceWorkerContextConnectionToNetworkProcess(PageGroupIdentifier, WebPageProxyIdentifier, WebCore::PageIdentifier, const WebPreferencesStore&, WebCore::RegistrableDomain&&, std::optional<WebCore::ScriptExecutionContextIdentifier> serviceWorkerPageIdentifier, RemoteWorkerInitializationData&&, CompletionHandler<void()>&&);

  • trunk/Source/WebKit/WebProcess/WebProcess.messages.in

    r289063 r289247  
    101101#endif
    102102
     103    EstablishSharedWorkerContextConnectionToNetworkProcess(WebKit::PageGroupIdentifier pageGroupID, WebKit::WebPageProxyIdentifier webPageProxyID, WebCore::PageIdentifier pageID, struct WebKit::WebPreferencesStore store, WebCore::RegistrableDomain domain, struct WebKit::RemoteWorkerInitializationData initializationData) -> () Async
     104
    103105#if ENABLE(SERVICE_WORKER)
    104106    EstablishServiceWorkerContextConnectionToNetworkProcess(WebKit::PageGroupIdentifier pageGroupID, WebKit::WebPageProxyIdentifier webPageProxyID, WebCore::PageIdentifier pageID, struct WebKit::WebPreferencesStore store, WebCore::RegistrableDomain domain, std::optional<WebCore::ScriptExecutionContextIdentifier> serviceWorkerPageIdentifier, struct WebKit::RemoteWorkerInitializationData initializationData) -> () Async
Note: See TracChangeset for help on using the changeset viewer.