Changeset 249801 in webkit


Ignore:
Timestamp:
Sep 12, 2019 1:18:15 AM (5 years ago)
Author:
youenn@apple.com
Message:

Use WebProcess processIdentifier to identify Service Worker connections
​https://bugs.webkit.org/show_bug.cgi?id=201459

Reviewed by Chris Dumez.

Source/WebCore:

No observable change of behavior.

  • workers/service/ServiceWorkerClient.cpp:

(WebCore::ServiceWorkerClient::postMessage):
Pass sessionID to ease NetworkProcess selection of the client process connection.

  • workers/service/ServiceWorkerTypes.h:

Mark server connection identifier be process identifier based.

  • workers/service/context/SWContextManager.h:
  • workers/service/server/SWServer.cpp:

(WebCore::SWServer::Connection::Connection):

  • workers/service/server/SWServer.h:

Let connection identifier be set in constructor instead of generated.

Source/WebCore/PAL:

  • pal/SessionID.h:

(PAL::SessionID::SessionID):

Source/WebKit:

Make WebSWServerConnection be stored in NetworkConnectionToWebProcess.
They are now keyed by session IDs hence why WebSWClientConnection is using the session ID as message connection ID.
Creation no longer requires a sync IPC since the connection is uniquely identified by its session ID and its process ID.
These IDs are stable over network process crash.
Within NetworkProcess, a server connection is managed by a SWServer which is session ID specific.
In that case, the process identifier uniquely identifies the connection.

Move WebSWServerToContextConnection be owned by NetworkConnectionToWebProcess.
Instead of creating it when webprocess is connecting to network process, use a dedicated IPC message.
This is similar to WebSWServerConnection once WebProcess asks to create it.
This will allow existing WebProcess, in cache or running pages, to run service workers as well.
A context connection map is kept in Network Process to reuse context connections since these connections are not sessionID specific.

Migrate from a single boolean to a HashSet to track whether some connections are in the process of being created.
Previously if two requests to create connections were done shortly one after the other on different registrable
domains, the second request would not be processed.

  • NetworkProcess/NetworkConnectionToWebProcess.cpp:

(WebKit::NetworkConnectionToWebProcess::didReceiveMessage):
(WebKit::NetworkConnectionToWebProcess::didReceiveSyncMessage):
(WebKit::NetworkConnectionToWebProcess::didClose):
(WebKit::NetworkConnectionToWebProcess::establishSWServerConnection):
(WebKit::NetworkConnectionToWebProcess::establishSWContextConnection):

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

(WebKit::NetworkProcess::didReceiveMessage):
(WebKit::NetworkProcess::createNetworkConnectionToWebProcess):
(WebKit::NetworkProcess::forEachSWServer):
(WebKit::NetworkProcess::needsServerToContextConnectionForRegistrableDomain const):
(WebKit::NetworkProcess::createServerToContextConnection):
(WebKit::NetworkProcess::postMessageToServiceWorkerClient):
(WebKit::NetworkProcess::registerSWServerConnection):
(WebKit::NetworkProcess::unregisterSWServerConnection):
(WebKit::NetworkProcess::registerSWContextConnection):
(WebKit::NetworkProcess::unregisterSWContextConnection):

  • NetworkProcess/NetworkProcess.h:
  • NetworkProcess/NetworkProcess.messages.in:
  • NetworkProcess/ServiceWorker/WebSWServerConnection.cpp:

(WebKit::WebSWServerConnection::WebSWServerConnection):
(WebKit::WebSWServerConnection::postMessageToServiceWorkerClient):

  • NetworkProcess/ServiceWorker/WebSWServerConnection.h:
  • NetworkProcess/ServiceWorker/WebSWServerToContextConnection.cpp:

(WebKit::WebSWServerToContextConnection::WebSWServerToContextConnection):
(WebKit::WebSWServerToContextConnection::~WebSWServerToContextConnection):
(WebKit::WebSWServerToContextConnection::postMessageToServiceWorkerClient):
(WebKit::WebSWServerToContextConnection::connectionMayNoLongerBeNeeded):

  • NetworkProcess/ServiceWorker/WebSWServerToContextConnection.h:
  • NetworkProcess/ServiceWorker/WebSWServerToContextConnection.messages.in:
  • UIProcess/Network/NetworkProcessProxy.cpp:

(WebKit::NetworkProcessProxy::openNetworkProcessConnection):
(WebKit::NetworkProcessProxy::establishWorkerContextConnectionToNetworkProcess):

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

(WebKit::WebProcessPool::establishWorkerContextConnectionToNetworkProcess):

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

(WebKit::WebProcessProxy::establishServiceWorkerContext):

  • UIProcess/WebProcessProxy.h:
  • WebProcess/Network/NetworkProcessConnection.cpp:

(WebKit::NetworkProcessConnection::didReceiveMessage):
(WebKit::NetworkProcessConnection::didClose):
(WebKit::NetworkProcessConnection::serviceWorkerConnectionForSession):

  • WebProcess/Network/NetworkProcessConnection.h:
  • WebProcess/Storage/WebSWClientConnection.cpp:

(WebKit::WebSWClientConnection::WebSWClientConnection):
(WebKit::WebSWClientConnection::~WebSWClientConnection):
(WebKit::WebSWClientConnection::messageSenderConnection const):
(WebKit::WebSWClientConnection::scheduleJobInServer):
(WebKit::WebSWClientConnection::finishFetchingScriptInServer):
(WebKit::WebSWClientConnection::addServiceWorkerRegistrationInServer):
(WebKit::WebSWClientConnection::removeServiceWorkerRegistrationInServer):
(WebKit::WebSWClientConnection::postMessageToServiceWorker):
(WebKit::WebSWClientConnection::registerServiceWorkerClient):
(WebKit::WebSWClientConnection::unregisterServiceWorkerClient):
(WebKit::WebSWClientConnection::didResolveRegistrationPromise):
(WebKit::WebSWClientConnection::matchRegistration):
(WebKit::WebSWClientConnection::runOrDelayTaskForImport):
(WebKit::WebSWClientConnection::whenRegistrationReady):
(WebKit::WebSWClientConnection::getRegistrations):
(WebKit::WebSWClientConnection::startFetch):
(WebKit::WebSWClientConnection::cancelFetch):
(WebKit::WebSWClientConnection::continueDidReceiveFetchResponse):
(WebKit::WebSWClientConnection::connectionToServerLost):
(WebKit::WebSWClientConnection::clear):
(WebKit::WebSWClientConnection::syncTerminateWorker):
(WebKit::WebSWClientConnection::updateThrottleState):
(WebKit::WebSWClientConnection::storeRegistrationsOnDiskForTesting):

  • WebProcess/Storage/WebSWClientConnection.h:
  • WebProcess/Storage/WebSWContextManagerConnection.cpp:

(WebKit::WebSWContextManagerConnection::WebSWContextManagerConnection):
(WebKit::m_userAgent):
(WebKit::WebSWContextManagerConnection::postMessageToServiceWorkerClient):

  • WebProcess/Storage/WebSWContextManagerConnection.h:
  • WebProcess/WebProcess.cpp:

(WebKit::WebProcess::establishWorkerContextConnectionToNetworkProcess):

  • WebProcess/WebProcess.h:
  • WebProcess/WebProcess.messages.in:
Location:
trunk/Source
Files:
36 edited

Legend:

Unmodified
Added
Removed

  • trunk/Source/WebCore/ChangeLog

    r249798 r249801  
     12019-09-12  Youenn Fablet  <youenn@apple.com>
     2
     3        Use WebProcess processIdentifier to identify Service Worker connections
     4        https://bugs.webkit.org/show_bug.cgi?id=201459
     5
     6        Reviewed by Chris Dumez.
     7
     8        No observable change of behavior.
     9
     10        * workers/service/ServiceWorkerClient.cpp:
     11        (WebCore::ServiceWorkerClient::postMessage):
     12        Pass sessionID to ease NetworkProcess selection of the client process connection.
     13        * workers/service/ServiceWorkerTypes.h:
     14        Mark server connection identifier be process identifier based.
     15        * workers/service/context/SWContextManager.h:
     16        * workers/service/server/SWServer.cpp:
     17        (WebCore::SWServer::Connection::Connection):
     18        * workers/service/server/SWServer.h:
     19        Let connection identifier be set in constructor instead of generated.
     20
    1212019-09-11  Youenn Fablet  <youenn@apple.com>
    222

  • trunk/Source/WebCore/PAL/ChangeLog

    r249684 r249801  
     12019-09-12  Youenn Fablet  <youenn@apple.com>
     2
     3        Use WebProcess processIdentifier to identify Service Worker connections
     4        https://bugs.webkit.org/show_bug.cgi?id=201459
     5
     6        Reviewed by Chris Dumez.
     7
     8        * pal/SessionID.h:
     9        (PAL::SessionID::SessionID):
     10
    1112019-09-09  Alex Christensen  <achristensen@webkit.org>
    212

  • trunk/Source/WebCore/PAL/pal/SessionID.h

    r248854 r249801  
    5656    }
    5757
     58    explicit SessionID(uint64_t identifier)
     59        : m_identifier(identifier)
     60    {
     61    }
     62
    5863    PAL_EXPORT static SessionID generateEphemeralSessionID();
    5964    PAL_EXPORT static SessionID generatePersistentSessionID();
    … …  
    7782
    7883private:
    79     explicit SessionID(uint64_t identifier)
    80         : m_identifier(identifier)
    81     {
    82     }
    83 
    8484    static bool isValidSessionIDValue(uint64_t sessionID) { return sessionID != HashTableEmptyValueID && sessionID != HashTableDeletedValueID; }
    8585

  • trunk/Source/WebCore/workers/service/ServiceWorkerClient.cpp

    r227425 r249801  
    100100    MessageWithMessagePorts message = { messageData.releaseReturnValue(), portsOrException.releaseReturnValue() };
    101101    auto sourceIdentifier = downcast<ServiceWorkerGlobalScope>(context).thread().identifier();
    102     callOnMainThread([message = WTFMove(message), destinationIdentifier = identifier(), sourceIdentifier, sourceOrigin = context.origin().isolatedCopy()] () mutable {
     102    callOnMainThread([sessionID = context.sessionID(), message = WTFMove(message), destinationIdentifier = identifier(), sourceIdentifier, sourceOrigin = context.origin().isolatedCopy()] () mutable {
    103103        if (auto* connection = SWContextManager::singleton().connection())
    104             connection->postMessageToServiceWorkerClient(destinationIdentifier, WTFMove(message), sourceIdentifier, sourceOrigin);
     104            connection->postMessageToServiceWorkerClient(sessionID, destinationIdentifier, message, sourceIdentifier, sourceOrigin);
    105105    });
    106106

  • trunk/Source/WebCore/workers/service/ServiceWorkerTypes.h

    r237110 r249801  
    2929
    3030#include "DocumentIdentifier.h"
     31#include "ProcessIdentifier.h"
    3132#include "ServiceWorkerIdentifier.h"
    3233#include <wtf/ObjectIdentifier.h>
    … …  
    7172using SWServerToContextConnectionIdentifier = ObjectIdentifier<SWServerToContextConnectionIdentifierType>;
    7273
    73 enum SWServerConnectionIdentifierType { };
     74using SWServerConnectionIdentifierType = ProcessIdentifierType;
    7475using SWServerConnectionIdentifier = ObjectIdentifier<SWServerConnectionIdentifierType>;
    7576

  • trunk/Source/WebCore/workers/service/context/SWContextManager.h

    r249287 r249801  
    5050        virtual ~Connection() { }
    5151
    52         virtual void postMessageToServiceWorkerClient(const ServiceWorkerClientIdentifier& destinationIdentifier, MessageWithMessagePorts&&, ServiceWorkerIdentifier source, const String& sourceOrigin) = 0;
     52        virtual void postMessageToServiceWorkerClient(PAL::SessionID, const ServiceWorkerClientIdentifier& destinationIdentifier, const MessageWithMessagePorts&, ServiceWorkerIdentifier source, const String& sourceOrigin) = 0;
    5353        virtual void serviceWorkerStarted(Optional<ServiceWorkerJobDataIdentifier>, ServiceWorkerIdentifier, bool doesHandleFetch) = 0;
    5454        virtual void serviceWorkerFailedToStart(Optional<ServiceWorkerJobDataIdentifier>, ServiceWorkerIdentifier, const String& message) = 0;

  • trunk/Source/WebCore/workers/service/server/SWServer.cpp

    r249781 r249801  
    5151static Seconds terminationDelay { 10_s };
    5252
    53 SWServer::Connection::Connection(SWServer& server)
     53SWServer::Connection::Connection(SWServer& server, Identifier identifier)
    5454    : m_server(server)
    55     , m_identifier(SWServerConnectionIdentifier::generate())
     55    , m_identifier(identifier)
    5656{
    5757}

  • trunk/Source/WebCore/workers/service/server/SWServer.h

    r249627 r249801  
    5757enum class ServiceWorkerState : uint8_t;
    5858struct ExceptionData;
     59struct MessageWithMessagePorts;
    5960struct ServiceWorkerClientQueryOptions;
    6061struct ServiceWorkerContextData;
    … …  
    8788        virtual void notifyClientsOfControllerChange(const HashSet<DocumentIdentifier>& contextIdentifiers, const ServiceWorkerData& newController) = 0;
    8889        virtual void registrationReady(uint64_t registrationReadyRequestIdentifier, ServiceWorkerRegistrationData&&) = 0;
     90        virtual void postMessageToServiceWorkerClient(DocumentIdentifier, const MessageWithMessagePorts&, ServiceWorkerIdentifier, const String& sourceOrigin) = 0;
    8991
    9092        virtual void serverToContextConnectionCreated(SWServerToContextConnection&) = 0;
    … …  
    9496
    9597    protected:
    96         WEBCORE_EXPORT explicit Connection(SWServer&);
     98        WEBCORE_EXPORT Connection(SWServer&, Identifier);
    9799
    98100        WEBCORE_EXPORT void finishFetchingScriptInServer(const ServiceWorkerFetchResult&);

  • trunk/Source/WebKit/ChangeLog

    r249795 r249801  
     12019-09-12  Youenn Fablet  <youenn@apple.com>
     2
     3        Use WebProcess processIdentifier to identify Service Worker connections
     4        https://bugs.webkit.org/show_bug.cgi?id=201459
     5
     6        Reviewed by Chris Dumez.
     7
     8        Make WebSWServerConnection be stored in NetworkConnectionToWebProcess.
     9        They are now keyed by session IDs hence why WebSWClientConnection is using the session ID as message connection ID.
     10        Creation no longer requires a sync IPC since the connection is uniquely identified by its session ID and its process ID.
     11        These IDs are stable over network process crash.
     12        Within NetworkProcess, a server connection is managed by a SWServer which is session ID specific.
     13        In that case, the process identifier uniquely identifies the connection.
     14
     15        Move WebSWServerToContextConnection be owned by NetworkConnectionToWebProcess.
     16        Instead of creating it when webprocess is connecting to network process, use a dedicated IPC message.
     17        This is similar to WebSWServerConnection once WebProcess asks to create it.
     18        This will allow existing WebProcess, in cache or running pages, to run service workers as well.
     19        A context connection map is kept in Network Process to reuse context connections since these connections are not sessionID specific.
     20
     21        Migrate from a single boolean to a HashSet to track whether some connections are in the process of being created.
     22        Previously if two requests to create connections were done shortly one after the other on different registrable
     23        domains, the second request would not be processed.
     24
     25        * NetworkProcess/NetworkConnectionToWebProcess.cpp:
     26        (WebKit::NetworkConnectionToWebProcess::didReceiveMessage):
     27        (WebKit::NetworkConnectionToWebProcess::didReceiveSyncMessage):
     28        (WebKit::NetworkConnectionToWebProcess::didClose):
     29        (WebKit::NetworkConnectionToWebProcess::establishSWServerConnection):
     30        (WebKit::NetworkConnectionToWebProcess::establishSWContextConnection):
     31        * NetworkProcess/NetworkConnectionToWebProcess.h:
     32        * NetworkProcess/NetworkConnectionToWebProcess.messages.in:
     33        * NetworkProcess/NetworkProcess.cpp:
     34        (WebKit::NetworkProcess::didReceiveMessage):
     35        (WebKit::NetworkProcess::createNetworkConnectionToWebProcess):
     36        (WebKit::NetworkProcess::forEachSWServer):
     37        (WebKit::NetworkProcess::needsServerToContextConnectionForRegistrableDomain const):
     38        (WebKit::NetworkProcess::createServerToContextConnection):
     39        (WebKit::NetworkProcess::postMessageToServiceWorkerClient):
     40        (WebKit::NetworkProcess::registerSWServerConnection):
     41        (WebKit::NetworkProcess::unregisterSWServerConnection):
     42        (WebKit::NetworkProcess::registerSWContextConnection):
     43        (WebKit::NetworkProcess::unregisterSWContextConnection):
     44        * NetworkProcess/NetworkProcess.h:
     45        * NetworkProcess/NetworkProcess.messages.in:
     46        * NetworkProcess/ServiceWorker/WebSWServerConnection.cpp:
     47        (WebKit::WebSWServerConnection::WebSWServerConnection):
     48        (WebKit::WebSWServerConnection::postMessageToServiceWorkerClient):
     49        * NetworkProcess/ServiceWorker/WebSWServerConnection.h:
     50        * NetworkProcess/ServiceWorker/WebSWServerToContextConnection.cpp:
     51        (WebKit::WebSWServerToContextConnection::WebSWServerToContextConnection):
     52        (WebKit::WebSWServerToContextConnection::~WebSWServerToContextConnection):
     53        (WebKit::WebSWServerToContextConnection::postMessageToServiceWorkerClient):
     54        (WebKit::WebSWServerToContextConnection::connectionMayNoLongerBeNeeded):
     55        * NetworkProcess/ServiceWorker/WebSWServerToContextConnection.h:
     56        * NetworkProcess/ServiceWorker/WebSWServerToContextConnection.messages.in:
     57        * UIProcess/Network/NetworkProcessProxy.cpp:
     58        (WebKit::NetworkProcessProxy::openNetworkProcessConnection):
     59        (WebKit::NetworkProcessProxy::establishWorkerContextConnectionToNetworkProcess):
     60        * UIProcess/Network/NetworkProcessProxy.h:
     61        * UIProcess/Network/NetworkProcessProxy.messages.in:
     62        * UIProcess/WebProcessPool.cpp:
     63        (WebKit::WebProcessPool::establishWorkerContextConnectionToNetworkProcess):
     64        * UIProcess/WebProcessPool.h:
     65        * UIProcess/WebProcessProxy.cpp:
     66        (WebKit::WebProcessProxy::establishServiceWorkerContext):
     67        * UIProcess/WebProcessProxy.h:
     68        * WebProcess/Network/NetworkProcessConnection.cpp:
     69        (WebKit::NetworkProcessConnection::didReceiveMessage):
     70        (WebKit::NetworkProcessConnection::didClose):
     71        (WebKit::NetworkProcessConnection::serviceWorkerConnectionForSession):
     72        * WebProcess/Network/NetworkProcessConnection.h:
     73        * WebProcess/Storage/WebSWClientConnection.cpp:
     74        (WebKit::WebSWClientConnection::WebSWClientConnection):
     75        (WebKit::WebSWClientConnection::~WebSWClientConnection):
     76        (WebKit::WebSWClientConnection::messageSenderConnection const):
     77        (WebKit::WebSWClientConnection::scheduleJobInServer):
     78        (WebKit::WebSWClientConnection::finishFetchingScriptInServer):
     79        (WebKit::WebSWClientConnection::addServiceWorkerRegistrationInServer):
     80        (WebKit::WebSWClientConnection::removeServiceWorkerRegistrationInServer):
     81        (WebKit::WebSWClientConnection::postMessageToServiceWorker):
     82        (WebKit::WebSWClientConnection::registerServiceWorkerClient):
     83        (WebKit::WebSWClientConnection::unregisterServiceWorkerClient):
     84        (WebKit::WebSWClientConnection::didResolveRegistrationPromise):
     85        (WebKit::WebSWClientConnection::matchRegistration):
     86        (WebKit::WebSWClientConnection::runOrDelayTaskForImport):
     87        (WebKit::WebSWClientConnection::whenRegistrationReady):
     88        (WebKit::WebSWClientConnection::getRegistrations):
     89        (WebKit::WebSWClientConnection::startFetch):
     90        (WebKit::WebSWClientConnection::cancelFetch):
     91        (WebKit::WebSWClientConnection::continueDidReceiveFetchResponse):
     92        (WebKit::WebSWClientConnection::connectionToServerLost):
     93        (WebKit::WebSWClientConnection::clear):
     94        (WebKit::WebSWClientConnection::syncTerminateWorker):
     95        (WebKit::WebSWClientConnection::updateThrottleState):
     96        (WebKit::WebSWClientConnection::storeRegistrationsOnDiskForTesting):
     97        * WebProcess/Storage/WebSWClientConnection.h:
     98        * WebProcess/Storage/WebSWContextManagerConnection.cpp:
     99        (WebKit::WebSWContextManagerConnection::WebSWContextManagerConnection):
     100        (WebKit::m_userAgent):
     101        (WebKit::WebSWContextManagerConnection::postMessageToServiceWorkerClient):
     102        * WebProcess/Storage/WebSWContextManagerConnection.h:
     103        * WebProcess/WebProcess.cpp:
     104        (WebKit::WebProcess::establishWorkerContextConnectionToNetworkProcess):
     105        * WebProcess/WebProcess.h:
     106        * WebProcess/WebProcess.messages.in:
     107
    11082019-09-11  Keith Rollin  <krollin@apple.com>
    2109

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

    r249640 r249801  
    214214#if ENABLE(SERVICE_WORKER)
    215215    if (decoder.messageReceiverName() == Messages::WebSWServerConnection::messageReceiverName()) {
    216         if (auto swConnection = m_swConnections.get(makeObjectIdentifier<SWServerConnectionIdentifierType>(decoder.destinationID())))
     216        if (auto swConnection = m_swConnections.get(PAL::SessionID { decoder.destinationID() }))
    217217            swConnection->didReceiveMessage(connection, decoder);
    218218        return;
    219219    }
    220 
    221220    if (decoder.messageReceiverName() == Messages::WebSWServerToContextConnection::messageReceiverName()) {
    222         if (auto* contextConnection = m_networkProcess->connectionToContextProcessFromIPCConnection(connection)) {
    223             contextConnection->didReceiveMessage(connection, decoder);
     221        ASSERT(m_swContextConnection);
     222        if (m_swContextConnection) {
     223            m_swContextConnection->didReceiveMessage(connection, decoder);
    224224            return;
    225225        }
    … …  
    227227
    228228    if (decoder.messageReceiverName() == Messages::ServiceWorkerFetchTask::messageReceiverName()) {
    229         if (auto* contextConnection = m_networkProcess->connectionToContextProcessFromIPCConnection(connection)) {
    230             contextConnection->didReceiveFetchTaskMessage(connection, decoder);
     229        ASSERT(m_swContextConnection);
     230        if (m_swContextConnection) {
     231            m_swContextConnection->didReceiveFetchTaskMessage(connection, decoder);
    231232            return;
    232233        }
    … …  
    269270#if ENABLE(SERVICE_WORKER)
    270271    if (decoder.messageReceiverName() == Messages::WebSWServerConnection::messageReceiverName()) {
    271         if (auto swConnection = m_swConnections.get(makeObjectIdentifier<SWServerConnectionIdentifierType>(decoder.destinationID())))
     272        if (auto swConnection = m_swConnections.get(PAL::SessionID { decoder.destinationID() }))
    272273            swConnection->didReceiveSyncMessage(connection, decoder, reply);
    273274        return;
    … …  
    286287{
    287288#if ENABLE(SERVICE_WORKER)
    288     if (RefPtr<WebSWServerToContextConnection> serverToContextConnection = m_networkProcess->connectionToContextProcessFromIPCConnection(connection)) {
    289         // Service Worker process exited.
    290         m_networkProcess->connectionToContextProcessWasClosed(serverToContextConnection.releaseNonNull());
    291         return;
     289    if (m_swContextConnection) {
     290        auto& registrableDomain = m_swContextConnection->registrableDomain();
     291
     292        m_swContextConnection->connectionClosed();
     293
     294        Optional<PAL::SessionID> sessionID;
     295        m_networkProcess->forEachSWServer([&](auto& server) {
     296            server.markAllWorkersForRegistrableDomainAsTerminated(registrableDomain);
     297            if (server.needsServerToContextConnectionForRegistrableDomain(registrableDomain))
     298                sessionID = server.sessionID();
     299        });
     300        if (sessionID)
     301            m_networkProcess->createServerToContextConnection(registrableDomain, *sessionID);
    292302    }
    293303#else
    … …  
    869879}
    870880
    871 void NetworkConnectionToWebProcess::establishSWServerConnection(PAL::SessionID sessionID, CompletionHandler<void(WebCore::SWServerConnectionIdentifier&&)>&& completionHandler)
     881void NetworkConnectionToWebProcess::establishSWServerConnection(PAL::SessionID sessionID)
    872882{
    873883    auto& server = m_networkProcess->swServerForSession(sessionID);
    874     auto connection = makeUnique<WebSWServerConnection>(m_networkProcess, server, m_connection.get(), sessionID);
    875    
    876     SWServerConnectionIdentifier serverConnectionIdentifier = connection->identifier();
    877     LOG(ServiceWorker, "NetworkConnectionToWebProcess::establishSWServerConnection - %s", serverConnectionIdentifier.loggingString().utf8().data());
    878 
    879     ASSERT(!m_swConnections.contains(serverConnectionIdentifier));
    880     m_swConnections.add(serverConnectionIdentifier, makeWeakPtr(*connection));
     884    auto connection = makeUnique<WebSWServerConnection>(m_networkProcess, server, m_connection.get(), m_webProcessIdentifier, sessionID);
     885
     886    ASSERT(!m_swConnections.contains(sessionID));
     887    m_swConnections.add(sessionID, makeWeakPtr(*connection));
    881888    server.addConnection(WTFMove(connection));
    882     completionHandler(WTFMove(serverConnectionIdentifier));
     889}
     890
     891void NetworkConnectionToWebProcess::establishSWContextConnection(RegistrableDomain&& registrableDomain)
     892{
     893    m_swContextConnection = WebSWServerToContextConnection::create(m_networkProcess, registrableDomain, m_connection.get());
     894
     895    m_networkProcess->forEachSWServer([&](auto& server) {
     896        server.serverToContextConnectionCreated(*m_swContextConnection);
     897    });
    883898}
    884899#endif

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

    r249640 r249801  
    6969class WebIDBConnectionToClient;
    7070class WebSWServerConnection;
     71class WebSWServerToContextConnection;
    7172typedef uint64_t ResourceLoadIdentifier;
    7273
    … …  
    209210
    210211#if ENABLE(SERVICE_WORKER)
    211     void establishSWServerConnection(PAL::SessionID, CompletionHandler<void(WebCore::SWServerConnectionIdentifier&&)>&&);
     212    void establishSWServerConnection(PAL::SessionID);
     213    void establishSWContextConnection(WebCore::RegistrableDomain&&);
    212214    void unregisterSWConnections();
    213215#endif
    … …  
    320322
    321323#if ENABLE(SERVICE_WORKER)
    322     HashMap<WebCore::SWServerConnectionIdentifier, WeakPtr<WebSWServerConnection>> m_swConnections;
     324    HashMap<PAL::SessionID, WeakPtr<WebSWServerConnection>> m_swConnections;
     325    RefPtr<WebSWServerToContextConnection> m_swContextConnection;
    323326#endif
    324327

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

    r249640 r249801  
    8282
    8383#if ENABLE(SERVICE_WORKER)
    84     EstablishSWServerConnection(PAL::SessionID sessionID) -> (WebCore::SWServerConnectionIdentifier serverConnectionIdentifier) Synchronous
     84    EstablishSWServerConnection(PAL::SessionID sessionID)
     85    EstablishSWContextConnection(WebCore::RegistrableDomain domain)
    8586#endif
    8687

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

    r249671 r249801  
    229229#endif
    230230
    231 #if ENABLE(SERVICE_WORKER)
    232     if (decoder.messageReceiverName() == Messages::WebSWServerToContextConnection::messageReceiverName()) {
    233         ASSERT(parentProcessHasServiceWorkerEntitlement());
    234         if (!parentProcessHasServiceWorkerEntitlement())
    235             return;
    236         if (auto* webSWConnection = connectionToContextProcessFromIPCConnection(connection)) {
    237             webSWConnection->didReceiveMessage(connection, decoder);
    238             return;
    239         }
    240     }
    241 #endif
    242231    didReceiveNetworkProcessMessage(connection, decoder);
    243232}
    … …  
    430419}
    431420
    432 void NetworkProcess::createNetworkConnectionToWebProcess(ProcessIdentifier identifier, bool isServiceWorkerProcess, WebCore::RegistrableDomain&& registrableDomain, CompletionHandler<void(Optional<IPC::Attachment>&&)>&& completionHandler)
     421void NetworkProcess::createNetworkConnectionToWebProcess(ProcessIdentifier identifier, CompletionHandler<void(Optional<IPC::Attachment>&&)>&& completionHandler)
    433422{
    434423    auto ipcConnection = createIPCConnectionToWebProcess();
    … …  
    447436
    448437    connection.setOnLineState(NetworkStateNotifier::singleton().onLine());
    449    
    450 #if ENABLE(SERVICE_WORKER)
    451     if (isServiceWorkerProcess) {
    452         ASSERT(parentProcessHasServiceWorkerEntitlement());
    453         ASSERT(m_waitingForServerToContextProcessConnection);
    454         auto contextConnection = WebSWServerToContextConnection::create(*this, registrableDomain, connection.connection());
    455         auto addResult = m_serverToContextConnections.add(WTFMove(registrableDomain), contextConnection.copyRef());
    456         ASSERT_UNUSED(addResult, addResult.isNewEntry);
    457 
    458         m_waitingForServerToContextProcessConnection = false;
    459 
    460         for (auto* server : SWServer::allServers())
    461             server->serverToContextConnectionCreated(contextConnection);
    462     }
    463 #else
    464     UNUSED_PARAM(isServiceWorkerProcess);
    465     UNUSED_PARAM(registrableDomain);
    466 #endif
    467438
    468439    m_storageManagerSet->addConnection(connection.connection());
    … …  
    24022373
    24032374#if ENABLE(SERVICE_WORKER)
    2404 WebSWServerToContextConnection* NetworkProcess::connectionToContextProcessFromIPCConnection(IPC::Connection& connection)
    2405 {
    2406     for (auto& serverToContextConnection : m_serverToContextConnections.values()) {
    2407         if (serverToContextConnection->ipcConnection() == &connection)
    2408             return serverToContextConnection.get();
    2409     }
    2410     return nullptr;
    2411 }
    2412 
    2413 void NetworkProcess::connectionToContextProcessWasClosed(Ref<WebSWServerToContextConnection>&& serverToContextConnection)
    2414 {
    2415     auto& registrableDomain = serverToContextConnection->registrableDomain();
    2416    
    2417     serverToContextConnection->connectionClosed();
    2418     m_serverToContextConnections.remove(registrableDomain);
    2419    
    2420     for (auto& swServer : m_swServers.values())
    2421         swServer->markAllWorkersForRegistrableDomainAsTerminated(registrableDomain);
    2422    
    2423     if (needsServerToContextConnectionForRegistrableDomain(registrableDomain)) {
    2424         RELEASE_LOG(ServiceWorker, "Connection to service worker process was closed but is still needed, relaunching it");
    2425         createServerToContextConnection(registrableDomain, WTF::nullopt);
    2426     }
    2427 }
    2428 
    2429 bool NetworkProcess::needsServerToContextConnectionForRegistrableDomain(const RegistrableDomain& registrableDomain) const
    2430 {
    2431     return WTF::anyOf(m_swServers.values(), [&](auto& swServer) {
    2432         return swServer->needsServerToContextConnectionForRegistrableDomain(registrableDomain);
    2433     });
     2375void NetworkProcess::forEachSWServer(const Function<void(SWServer&)>& callback)
     2376{
     2377    for (auto& server : m_swServers.values())
     2378        callback(*server);
    24342379}
    24352380
    … …  
    24592404}
    24602405
     2406bool NetworkProcess::needsServerToContextConnectionForRegistrableDomain(const RegistrableDomain& registrableDomain) const
     2407{
     2408    return WTF::anyOf(m_swServers.values(), [&](auto& swServer) {
     2409        return swServer->needsServerToContextConnectionForRegistrableDomain(registrableDomain);
     2410    });
     2411}
     2412
    24612413WebSWServerToContextConnection* NetworkProcess::serverToContextConnectionForRegistrableDomain(const RegistrableDomain& registrableDomain)
    24622414{
    … …  
    24642416}
    24652417
    2466 void NetworkProcess::createServerToContextConnection(const RegistrableDomain& registrableDomain, Optional<PAL::SessionID> sessionID)
    2467 {
    2468     if (m_waitingForServerToContextProcessConnection)
     2418void NetworkProcess::createServerToContextConnection(const RegistrableDomain& registrableDomain, PAL::SessionID sessionID)
     2419{
     2420    if (m_pendingConnectionDomains.contains(registrableDomain))
    24692421        return;
    2470    
    2471     m_waitingForServerToContextProcessConnection = true;
    2472     if (sessionID)
    2473         parentProcessConnection()->send(Messages::NetworkProcessProxy::EstablishWorkerContextConnectionToNetworkProcessForExplicitSession(registrableDomain, *sessionID), 0);
    2474     else
    2475         parentProcessConnection()->send(Messages::NetworkProcessProxy::EstablishWorkerContextConnectionToNetworkProcess(registrableDomain), 0);
    2476 }
    2477 
    2478 void NetworkProcess::postMessageToServiceWorkerClient(const ServiceWorkerClientIdentifier& destinationIdentifier, MessageWithMessagePorts&& message, ServiceWorkerIdentifier sourceIdentifier, const String& sourceOrigin)
    2479 {
    2480     if (auto connection = m_swServerConnections.get(destinationIdentifier.serverConnectionIdentifier))
     2422
     2423    m_pendingConnectionDomains.add(registrableDomain);
     2424    parentProcessConnection()->send(Messages::NetworkProcessProxy::EstablishWorkerContextConnectionToNetworkProcess { registrableDomain, sessionID }, 0);
     2425}
     2426
     2427void NetworkProcess::postMessageToServiceWorkerClient(PAL::SessionID sessionID, const ServiceWorkerClientIdentifier& destinationIdentifier, MessageWithMessagePorts&& message, ServiceWorkerIdentifier sourceIdentifier, const String& sourceOrigin)
     2428{
     2429    if (auto* connection = swServerForSession(sessionID).connection(destinationIdentifier.serverConnectionIdentifier))
    24812430        connection->postMessageToServiceWorkerClient(destinationIdentifier.contextIdentifier, WTFMove(message), sourceIdentifier, sourceOrigin);
    24822431}
    24832432
    2484 void NetworkProcess::postMessageToServiceWorker(WebCore::ServiceWorkerIdentifier destination, WebCore::MessageWithMessagePorts&& message, const WebCore::ServiceWorkerOrClientIdentifier& source, SWServerConnectionIdentifier connectionIdentifier)
    2485 {
    2486     if (auto connection = m_swServerConnections.get(connectionIdentifier))
    2487         connection->postMessageToServiceWorker(destination, WTFMove(message), source);
    2488 }
    2489 
    24902433void NetworkProcess::registerSWServerConnection(WebSWServerConnection& connection)
    24912434{
    24922435    ASSERT(parentProcessHasServiceWorkerEntitlement());
    2493     ASSERT(!m_swServerConnections.contains(connection.identifier()));
    2494     m_swServerConnections.add(connection.identifier(), makeWeakPtr(connection));
    24952436    auto* store = existingSWOriginStoreForSession(connection.sessionID());
    24962437    ASSERT(store);
    … …  
    25012442void NetworkProcess::unregisterSWServerConnection(WebSWServerConnection& connection)
    25022443{
    2503     ASSERT(m_swServerConnections.get(connection.identifier()).get() == &connection);
    2504     m_swServerConnections.remove(connection.identifier());
    25052444    if (auto* store = existingSWOriginStoreForSession(connection.sessionID()))
    25062445        store->unregisterSWServerConnection(connection);
    25072446}
    25082447
    2509 void NetworkProcess::swContextConnectionMayNoLongerBeNeeded(WebSWServerToContextConnection& serverToContextConnection)
    2510 {
    2511     auto& registrableDomain = serverToContextConnection.registrableDomain();
    2512     if (needsServerToContextConnectionForRegistrableDomain(registrableDomain))
    2513         return;
    2514    
    2515     RELEASE_LOG(ServiceWorker, "Service worker process is no longer needed, terminating it");
    2516     serverToContextConnection.terminate();
    2517    
    2518     for (auto& swServer : m_swServers.values())
    2519         swServer->markAllWorkersForRegistrableDomainAsTerminated(registrableDomain);
    2520    
    2521     serverToContextConnection.connectionClosed();
    2522     m_serverToContextConnections.remove(registrableDomain);
     2448void NetworkProcess::registerSWContextConnection(WebSWServerToContextConnection& connection)
     2449{
     2450    ASSERT(!m_serverToContextConnections.contains(connection.registrableDomain()));
     2451    m_pendingConnectionDomains.remove(connection.registrableDomain());
     2452    m_serverToContextConnections.add(connection.registrableDomain(), &connection);
     2453}
     2454
     2455void NetworkProcess::unregisterSWContextConnection(WebSWServerToContextConnection& connection)
     2456{
     2457    ASSERT(m_serverToContextConnections.get(connection.registrableDomain()) == &connection);
     2458    m_serverToContextConnections.remove(connection.registrableDomain());
    25232459}
    25242460

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

    r249671 r249801  
    299299#if ENABLE(SERVICE_WORKER)
    300300    WebSWServerToContextConnection* serverToContextConnectionForRegistrableDomain(const WebCore::RegistrableDomain&);
    301     void createServerToContextConnection(const WebCore::RegistrableDomain&, Optional<PAL::SessionID>);
     301    void createServerToContextConnection(const WebCore::RegistrableDomain&, PAL::SessionID);
    302302   
    303303    WebCore::SWServer& swServerForSession(PAL::SessionID);
    … …  
    305305    void unregisterSWServerConnection(WebSWServerConnection&);
    306306   
    307     void swContextConnectionMayNoLongerBeNeeded(WebSWServerToContextConnection&);
    308    
    309     WebSWServerToContextConnection* connectionToContextProcessFromIPCConnection(IPC::Connection&);
    310     void connectionToContextProcessWasClosed(Ref<WebSWServerToContextConnection>&&);
     307    void registerSWContextConnection(WebSWServerToContextConnection&);
     308    void unregisterSWContextConnection(WebSWServerToContextConnection&);
     309
     310    bool needsServerToContextConnectionForRegistrableDomain(const WebCore::RegistrableDomain&) const;
     311    void forEachSWServer(const Function<void(WebCore::SWServer&)>&);
    311312#endif
    312313
    … …  
    394395    void didReceiveSyncNetworkProcessMessage(IPC::Connection&, IPC::Decoder&, std::unique_ptr<IPC::Encoder>&);
    395396    void initializeNetworkProcess(NetworkProcessCreationParameters&&);
    396     void createNetworkConnectionToWebProcess(WebCore::ProcessIdentifier, bool isServiceWorkerProcess, WebCore::RegistrableDomain&&, CompletionHandler<void(Optional<IPC::Attachment>&&)>&&);
     397    void createNetworkConnectionToWebProcess(WebCore::ProcessIdentifier, CompletionHandler<void(Optional<IPC::Attachment>&&)>&&);
    397398
    398399    void fetchWebsiteData(PAL::SessionID, OptionSet<WebsiteDataType>, OptionSet<WebsiteDataFetchOption>, uint64_t callbackID);
    … …  
    463464    void didCreateWorkerContextProcessConnection(const IPC::Attachment&);
    464465   
    465     void postMessageToServiceWorkerClient(const WebCore::ServiceWorkerClientIdentifier& destinationIdentifier, WebCore::MessageWithMessagePorts&&, WebCore::ServiceWorkerIdentifier sourceIdentifier, const String& sourceOrigin);
    466     void postMessageToServiceWorker(WebCore::ServiceWorkerIdentifier destination, WebCore::MessageWithMessagePorts&&, const WebCore::ServiceWorkerOrClientIdentifier& source, WebCore::SWServerConnectionIdentifier);
     466    void postMessageToServiceWorkerClient(PAL::SessionID, const WebCore::ServiceWorkerClientIdentifier& destinationIdentifier, WebCore::MessageWithMessagePorts&&, WebCore::ServiceWorkerIdentifier sourceIdentifier, const String& sourceOrigin);
     467    void postMessageToServiceWorker(PAL::SessionID, WebCore::ServiceWorkerIdentifier destination, WebCore::MessageWithMessagePorts&&, const WebCore::ServiceWorkerOrClientIdentifier& source, WebCore::SWServerConnectionIdentifier);
    467468   
    468469    void disableServiceWorkerProcessTerminationDelay();
    469470   
    470471    WebSWOriginStore* existingSWOriginStoreForSession(PAL::SessionID) const;
    471     bool needsServerToContextConnectionForRegistrableDomain(const WebCore::RegistrableDomain&) const;
    472472
    473473    void addServiceWorkerSession(PAL::SessionID, String& serviceWorkerRegistrationDirectory, const SandboxExtension::Handle&);
    … …  
    540540   
    541541#if ENABLE(SERVICE_WORKER)
    542     HashMap<WebCore::RegistrableDomain, RefPtr<WebSWServerToContextConnection>> m_serverToContextConnections;
    543     bool m_waitingForServerToContextProcessConnection { false };
     542    HashMap<WebCore::RegistrableDomain, WebSWServerToContextConnection*> m_serverToContextConnections;
    544543    bool m_shouldDisableServiceWorkerProcessTerminationDelay { false };
    545544    HashMap<PAL::SessionID, String> m_swDatabasePaths;
    546545    HashMap<PAL::SessionID, std::unique_ptr<WebCore::SWServer>> m_swServers;
    547     HashMap<WebCore::SWServerConnectionIdentifier, WeakPtr<WebSWServerConnection>> m_swServerConnections;
     546    HashSet<WebCore::RegistrableDomain> m_pendingConnectionDomains;
    548547#endif
    549548

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

    r249671 r249801  
    2626
    2727    # Creates a connection for communication with a WebProcess
    28     CreateNetworkConnectionToWebProcess(WebCore::ProcessIdentifier processIdentifier, bool isServiceWorkerProcess, WebCore::RegistrableDomain registrableDomain) -> (Optional<IPC::Attachment> connectionIdentifier) Async
     28    CreateNetworkConnectionToWebProcess(WebCore::ProcessIdentifier processIdentifier) -> (Optional<IPC::Attachment> connectionIdentifier) Async
    2929
    3030#if USE(SOUP)
    … …  
    152152
    153153#if ENABLE(SERVICE_WORKER)
    154     PostMessageToServiceWorkerClient(struct WebCore::ServiceWorkerClientIdentifier destinationIdentifier, struct WebCore::MessageWithMessagePorts message, WebCore::ServiceWorkerIdentifier sourceIdentifier, String sourceOrigin)
    155 
    156     PostMessageToServiceWorker(WebCore::ServiceWorkerIdentifier destination, struct WebCore::MessageWithMessagePorts message, WebCore::ServiceWorkerOrClientIdentifier source, WebCore::SWServerConnectionIdentifier connectionIdentifier)
    157 
     154    PostMessageToServiceWorkerClient(PAL::SessionID sessionID, struct WebCore::ServiceWorkerClientIdentifier destinationIdentifier, struct WebCore::MessageWithMessagePorts message, WebCore::ServiceWorkerIdentifier sourceIdentifier, String sourceOrigin)
    158155    DisableServiceWorkerProcessTerminationDelay()
    159156#endif

  • trunk/Source/WebKit/NetworkProcess/ServiceWorker/WebSWServerConnection.cpp

    r249287 r249801  
    6262#define SWSERVERCONNECTION_RELEASE_LOG_ERROR_IF_ALLOWED(fmt, ...) RELEASE_LOG_ERROR_IF(m_sessionID.isAlwaysOnLoggingAllowed(), ServiceWorker, "%p - WebSWServerConnection::" fmt, this, ##__VA_ARGS__)
    6363
    64 WebSWServerConnection::WebSWServerConnection(NetworkProcess& networkProcess, SWServer& server, IPC::Connection& connection, SessionID sessionID)
    65     : SWServer::Connection(server)
     64WebSWServerConnection::WebSWServerConnection(NetworkProcess& networkProcess, SWServer& server, IPC::Connection& connection, ProcessIdentifier processIdentifier, SessionID sessionID)
     65    : SWServer::Connection(server, processIdentifier)
    6666    , m_sessionID(sessionID)
    6767    , m_contentConnection(connection)
    … …  
    254254}
    255255
    256 void WebSWServerConnection::postMessageToServiceWorkerClient(DocumentIdentifier destinationContextIdentifier, MessageWithMessagePorts&& message, ServiceWorkerIdentifier sourceIdentifier, const String& sourceOrigin)
     256void WebSWServerConnection::postMessageToServiceWorkerClient(DocumentIdentifier destinationContextIdentifier, const MessageWithMessagePorts& message, ServiceWorkerIdentifier sourceIdentifier, const String& sourceOrigin)
    257257{
    258258    auto* sourceServiceWorker = server().workerByID(sourceIdentifier);
    … …  
    260260        return;
    261261
    262     send(Messages::WebSWClientConnection::PostMessageToServiceWorkerClient { destinationContextIdentifier, WTFMove(message), sourceServiceWorker->data(), sourceOrigin });
     262    send(Messages::WebSWClientConnection::PostMessageToServiceWorkerClient { destinationContextIdentifier, message, sourceServiceWorker->data(), sourceOrigin });
    263263}
    264264

  • trunk/Source/WebKit/NetworkProcess/ServiceWorker/WebSWServerConnection.h

    r245299 r249801  
    3232#include "ServiceWorkerFetchTask.h"
    3333#include <WebCore/FetchIdentifier.h>
     34#include <WebCore/ProcessIdentifier.h>
    3435#include <WebCore/SWServer.h>
    3536#include <pal/SessionID.h>
    … …  
    5455class WebSWServerConnection : public WebCore::SWServer::Connection, public IPC::MessageSender, public IPC::MessageReceiver {
    5556public:
    56     WebSWServerConnection(NetworkProcess&, WebCore::SWServer&, IPC::Connection&, PAL::SessionID);
     57    WebSWServerConnection(NetworkProcess&, WebCore::SWServer&, IPC::Connection&, WebCore::ProcessIdentifier, PAL::SessionID);
    5758    WebSWServerConnection(const WebSWServerConnection&) = delete;
    5859    ~WebSWServerConnection() final;
    … …  
    6465
    6566    PAL::SessionID sessionID() const { return m_sessionID; }
    66 
    67     void postMessageToServiceWorkerClient(WebCore::DocumentIdentifier destinationContextIdentifier, WebCore::MessageWithMessagePorts&&, WebCore::ServiceWorkerIdentifier sourceServiceWorkerIdentifier, const String& sourceOrigin);
    68     void postMessageToServiceWorker(WebCore::ServiceWorkerIdentifier destination, WebCore::MessageWithMessagePorts&&, const WebCore::ServiceWorkerOrClientIdentifier& source);
    6967
    7068private:
    … …  
    9593    void syncTerminateWorkerFromClient(WebCore::ServiceWorkerIdentifier&&, CompletionHandler<void()>&&);
    9694
     95    void postMessageToServiceWorkerClient(WebCore::DocumentIdentifier destinationContextIdentifier, const WebCore::MessageWithMessagePorts&, WebCore::ServiceWorkerIdentifier sourceServiceWorkerIdentifier, const String& sourceOrigin) final;
     96
    9797    void serverToContextConnectionCreated(WebCore::SWServerToContextConnection&) final;
    9898
    … …  
    103103    void updateThrottleState();
    104104
     105    void postMessageToServiceWorker(WebCore::ServiceWorkerIdentifier destination, WebCore::MessageWithMessagePorts&&, const WebCore::ServiceWorkerOrClientIdentifier& source);
     106
    105107    IPC::Connection* messageSenderConnection() const final { return m_contentConnection.ptr(); }
    106     uint64_t messageSenderDestinationID() const final { return identifier().toUInt64(); }
     108    uint64_t messageSenderDestinationID() const final { return m_sessionID.toUInt64(); }
    107109   
    108110    template<typename U> static void sendToContextProcess(WebCore::SWServerToContextConnection&, U&& message);

  • trunk/Source/WebKit/NetworkProcess/ServiceWorker/WebSWServerToContextConnection.cpp

    r249287 r249801  
    3030
    3131#include "FormDataReference.h"
     32#include "Logging.h"
    3233#include "NetworkProcess.h"
    3334#include "ServiceWorkerFetchTask.h"
    … …  
    3536#include "WebCoreArgumentCoders.h"
    3637#include "WebSWContextManagerConnectionMessages.h"
     38#include <WebCore/SWServer.h>
    3739#include <WebCore/ServiceWorkerContextData.h>
    3840
    … …  
    4547    , m_networkProcess(networkProcess)
    4648{
    47 }
    48 
    49 WebSWServerToContextConnection::~WebSWServerToContextConnection() = default;
     49    m_networkProcess->registerSWContextConnection(*this);
     50}
     51
     52WebSWServerToContextConnection::~WebSWServerToContextConnection()
     53{
     54    m_networkProcess->unregisterSWContextConnection(*this);
     55}
    5056
    5157IPC::Connection* WebSWServerToContextConnection::messageSenderConnection() const
    … …  
    6672}
    6773
     74void WebSWServerToContextConnection::postMessageToServiceWorkerClient(PAL::SessionID sessionID, const ServiceWorkerClientIdentifier& destinationIdentifier, const MessageWithMessagePorts& message, ServiceWorkerIdentifier sourceIdentifier, const String& sourceOrigin)
     75{
     76    if (auto* connection = m_networkProcess->swServerForSession(sessionID).connection(destinationIdentifier.serverConnectionIdentifier))
     77        connection->postMessageToServiceWorkerClient(destinationIdentifier.contextIdentifier, message, sourceIdentifier, sourceOrigin);
     78}
     79
    6880void WebSWServerToContextConnection::installServiceWorkerContext(const ServiceWorkerContextData& data, PAL::SessionID sessionID, const String& userAgent)
    6981{
    … …  
    118130void WebSWServerToContextConnection::connectionMayNoLongerBeNeeded()
    119131{
    120     m_networkProcess->swContextConnectionMayNoLongerBeNeeded(*this);
     132    if (m_networkProcess->needsServerToContextConnectionForRegistrableDomain(registrableDomain()))
     133        return;
     134
     135    RELEASE_LOG(ServiceWorker, "Service worker process is no longer needed, terminating it");
     136    terminate();
     137
     138    m_networkProcess->forEachSWServer([&](auto& server) {
     139        server.markAllWorkersForRegistrableDomainAsTerminated(registrableDomain());
     140    });
     141
     142    connectionClosed();
    121143}
    122144

  • trunk/Source/WebKit/NetworkProcess/ServiceWorker/WebSWServerToContextConnection.h

    r249287 r249801  
    3535namespace WebCore {
    3636struct FetchOptions;
     37struct MessageWithMessagePorts;
    3738class ResourceRequest;
    3839}
    … …  
    8384    uint64_t messageSenderDestinationID() const final;
    8485
     86    void postMessageToServiceWorkerClient(PAL::SessionID, const WebCore::ServiceWorkerClientIdentifier& destinationIdentifier, const WebCore::MessageWithMessagePorts&, WebCore::ServiceWorkerIdentifier sourceIdentifier, const String& sourceOrigin);
     87
    8588    // Messages to the SW host WebProcess
    8689    void installServiceWorkerContext(const WebCore::ServiceWorkerContextData&, PAL::SessionID, const String& userAgent) final;

  • trunk/Source/WebKit/NetworkProcess/ServiceWorker/WebSWServerToContextConnection.messages.in

    r249287 r249801  
    3737    Claim(uint64_t claimRequestIdentifier, WebCore::ServiceWorkerIdentifier serviceWorkerIdentifier);
    3838    SetScriptResource(WebCore::ServiceWorkerIdentifier identifier, URL scriptURL, String script, URL responseURL, String mimeType);
     39    PostMessageToServiceWorkerClient(PAL::SessionID sessionID, struct WebCore::ServiceWorkerClientIdentifier destination, struct WebCore::MessageWithMessagePorts message, WebCore::ServiceWorkerIdentifier source, String sourceOrigin)
    3940}
    4041

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

    r249778 r249801  
    143143void NetworkProcessProxy::openNetworkProcessConnection(uint64_t connectionRequestIdentifier, WebProcessProxy& webProcessProxy)
    144144{
    145     bool isServiceWorkerProcess = false;
    146     RegistrableDomain registrableDomain;
    147 #if ENABLE(SERVICE_WORKER)
    148     if (webProcessProxy.isRunningServiceWorkers()) {
    149         isServiceWorkerProcess = true;
    150         registrableDomain = webProcessProxy.registrableDomain();
    151     }
    152 #endif
    153 
    154     connection()->sendWithAsyncReply(Messages::NetworkProcess::CreateNetworkConnectionToWebProcess { webProcessProxy.coreProcessIdentifier(), isServiceWorkerProcess, registrableDomain }, [this, weakThis = makeWeakPtr(this), webProcessProxy = makeWeakPtr(webProcessProxy), connectionRequestIdentifier](auto&& connectionIdentifier) mutable {
     145    connection()->sendWithAsyncReply(Messages::NetworkProcess::CreateNetworkConnectionToWebProcess { webProcessProxy.coreProcessIdentifier() }, [this, weakThis = makeWeakPtr(this), webProcessProxy = makeWeakPtr(webProcessProxy), connectionRequestIdentifier](auto&& connectionIdentifier) mutable {
    155146        if (!weakThis)
    156147            return;
    … …  
    12101201
    12111202#if ENABLE(SERVICE_WORKER)
    1212 void NetworkProcessProxy::establishWorkerContextConnectionToNetworkProcess(RegistrableDomain&& registrableDomain)
    1213 {
    1214     m_processPool.establishWorkerContextConnectionToNetworkProcess(*this, WTFMove(registrableDomain), WTF::nullopt);
    1215 }
    1216 
    1217 void NetworkProcessProxy::establishWorkerContextConnectionToNetworkProcessForExplicitSession(RegistrableDomain&& registrableDomain, PAL::SessionID sessionID)
     1203void NetworkProcessProxy::establishWorkerContextConnectionToNetworkProcess(RegistrableDomain&& registrableDomain, PAL::SessionID sessionID)
    12181204{
    12191205    m_processPool.establishWorkerContextConnectionToNetworkProcess(*this, WTFMove(registrableDomain), sessionID);

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

    r249778 r249801  
    239239
    240240#if ENABLE(SERVICE_WORKER)
    241     void establishWorkerContextConnectionToNetworkProcess(WebCore::RegistrableDomain&&);
    242     void establishWorkerContextConnectionToNetworkProcessForExplicitSession(WebCore::RegistrableDomain&&, PAL::SessionID);
     241    void establishWorkerContextConnectionToNetworkProcess(WebCore::RegistrableDomain&&, PAL::SessionID);
    243242#endif
    244243

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

    r249501 r249801  
    6262
    6363#if ENABLE(SERVICE_WORKER)
    64     EstablishWorkerContextConnectionToNetworkProcess(WebCore::RegistrableDomain registrableDomain)
    65     EstablishWorkerContextConnectionToNetworkProcessForExplicitSession(WebCore::RegistrableDomain registrableDomain, PAL::SessionID explicitSession)
     64    EstablishWorkerContextConnectionToNetworkProcess(WebCore::RegistrableDomain registrableDomain, PAL::SessionID sessionID)
    6665#endif
    6766

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

    r249778 r249801  
    688688
    689689#if ENABLE(SERVICE_WORKER)
    690 void WebProcessPool::establishWorkerContextConnectionToNetworkProcess(NetworkProcessProxy& proxy, RegistrableDomain&& registrableDomain, Optional<PAL::SessionID> sessionID)
     690void WebProcessPool::establishWorkerContextConnectionToNetworkProcess(NetworkProcessProxy& proxy, RegistrableDomain&& registrableDomain, PAL::SessionID sessionID)
    691691{
    692692    ASSERT_UNUSED(proxy, &proxy == m_networkProcess.get());
    693693
    694     if (m_serviceWorkerProcesses.contains(registrableDomain))
    695         return;
    696 
    697694    m_mayHaveRegisteredServiceWorkers.clear();
    698695
    699     WebsiteDataStore* websiteDataStore = nullptr;
    700     if (sessionID)
    701         websiteDataStore = WebsiteDataStore::existingNonDefaultDataStoreForSessionID(*sessionID);
     696    auto* websiteDataStore = WebsiteDataStore::existingNonDefaultDataStoreForSessionID(sessionID);
    702697
    703698    if (!websiteDataStore) {
    … …  
    707702    }
    708703
     704    if (m_serviceWorkerProcesses.contains(registrableDomain))
     705        return;
     706
    709707    if (m_serviceWorkerProcesses.isEmpty())
    710708        sendToAllProcesses(Messages::WebProcess::RegisterServiceWorkerClients { });
    … …  
    719717    m_processes.append(WTFMove(serviceWorkerProcessProxy));
    720718
    721     serviceWorkerProcessProxyPtr->establishServiceWorkerContext(m_serviceWorkerPreferences ? m_serviceWorkerPreferences.value() : m_defaultPageGroup->preferences().store(), sessionID.valueOr(PAL::SessionID::defaultSessionID()));
     719    serviceWorkerProcessProxyPtr->establishServiceWorkerContext(m_serviceWorkerPreferences ? m_serviceWorkerPreferences.value() : m_defaultPageGroup->preferences().store());
    722720    if (!m_serviceWorkerUserAgent.isNull())
    723721        serviceWorkerProcessProxyPtr->setServiceWorkerUserAgent(m_serviceWorkerUserAgent);

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

    r249778 r249801  
    382382    bool isServiceWorkerPageID(WebPageProxyIdentifier) const;
    383383#if ENABLE(SERVICE_WORKER)
    384     void establishWorkerContextConnectionToNetworkProcess(NetworkProcessProxy&, WebCore::RegistrableDomain&&, Optional<PAL::SessionID>);
     384    void establishWorkerContextConnectionToNetworkProcess(NetworkProcessProxy&, WebCore::RegistrableDomain&&, PAL::SessionID);
    385385    const HashMap<WebCore::RegistrableDomain, WebProcessProxy*>& serviceWorkerProxies() const { return m_serviceWorkerProcesses; }
    386386    void setAllowsAnySSLCertificateForServiceWorker(bool allows) { m_allowsAnySSLCertificateForServiceWorker = allows; }

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

    r249647 r249801  
    14941494
    14951495#if ENABLE(SERVICE_WORKER)
    1496 void WebProcessProxy::establishServiceWorkerContext(const WebPreferencesStore& store, PAL::SessionID sessionID)
    1497 {
    1498     send(Messages::WebProcess::EstablishWorkerContextConnectionToNetworkProcess { processPool().defaultPageGroup().pageGroupID(), m_serviceWorkerInformation->serviceWorkerPageProxyID, m_serviceWorkerInformation->serviceWorkerPageID, store, sessionID }, 0);
     1496void WebProcessProxy::establishServiceWorkerContext(const WebPreferencesStore& store)
     1497{
     1498    send(Messages::WebProcess::EstablishWorkerContextConnectionToNetworkProcess { processPool().defaultPageGroup().pageGroupID(), m_serviceWorkerInformation->serviceWorkerPageProxyID, m_serviceWorkerInformation->serviceWorkerPageID, store, *m_registrableDomain, m_websiteDataStore->sessionID() }, 0);
    14991499}
    15001500

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

    r249647 r249801  
    314314
    315315#if ENABLE(SERVICE_WORKER)
    316     void establishServiceWorkerContext(const WebPreferencesStore&, PAL::SessionID);
    317     void startForServiceWorkers(const WebPreferencesStore&, PAL::SessionID);
     316    void establishServiceWorkerContext(const WebPreferencesStore&);
    318317    void setServiceWorkerUserAgent(const String&);
    319318    void updateServiceWorkerPreferencesStore(const WebPreferencesStore&);

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

    r249640 r249801  
    138138#if ENABLE(SERVICE_WORKER)
    139139    if (decoder.messageReceiverName() == Messages::WebSWClientConnection::messageReceiverName()) {
    140         auto serviceWorkerConnection = m_swConnectionsByIdentifier.get(makeObjectIdentifier<SWServerConnectionIdentifierType>(decoder.destinationID()));
     140        auto serviceWorkerConnection = m_swConnectionsBySession.get(PAL::SessionID { decoder.destinationID() });
    141141        if (serviceWorkerConnection)
    142142            serviceWorkerConnection->didReceiveMessage(connection, decoder);
    … …  
    201201
    202202#if ENABLE(SERVICE_WORKER)
    203     auto swConnections = std::exchange(m_swConnectionsByIdentifier, { });
     203    auto swConnections = std::exchange(m_swConnectionsBySession, { });
    204204    for (auto& connection : swConnections.values())
    205205        connection->connectionToServerLost();
    … …  
    265265    }).iterator->value;
    266266}
    267 
    268 void NetworkProcessConnection::removeSWClientConnection(WebSWClientConnection& connection)
    269 {
    270     ASSERT(m_swConnectionsByIdentifier.contains(connection.serverConnectionIdentifier()));
    271     m_swConnectionsByIdentifier.remove(connection.serverConnectionIdentifier());
    272 }
    273 
    274 SWServerConnectionIdentifier NetworkProcessConnection::initializeSWClientConnection(WebSWClientConnection& connection)
    275 {
    276     ASSERT(connection.sessionID().isValid());
    277     SWServerConnectionIdentifier identifier;
    278     bool result = m_connection->sendSync(Messages::NetworkConnectionToWebProcess::EstablishSWServerConnection(connection.sessionID()), Messages::NetworkConnectionToWebProcess::EstablishSWServerConnection::Reply(identifier), 0);
    279     ASSERT_UNUSED(result, result);
    280 
    281     ASSERT(!m_swConnectionsByIdentifier.contains(identifier));
    282     m_swConnectionsByIdentifier.add(identifier, &connection);
    283 
    284     return identifier;
    285 }
    286267#endif
    287268

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

    r249640 r249801  
    7979    WebSWClientConnection* existingServiceWorkerConnectionForSession(PAL::SessionID sessionID) { return m_swConnectionsBySession.get(sessionID); }
    8080    WebSWClientConnection& serviceWorkerConnectionForSession(PAL::SessionID);
    81 
    82     WebCore::SWServerConnectionIdentifier initializeSWClientConnection(WebSWClientConnection&);
    83     void removeSWClientConnection(WebSWClientConnection&);
    8481#endif
    8582
    … …  
    114111#if ENABLE(SERVICE_WORKER)
    115112    HashMap<PAL::SessionID, RefPtr<WebSWClientConnection>> m_swConnectionsBySession;
    116     HashMap<WebCore::SWServerConnectionIdentifier, WebSWClientConnection*> m_swConnectionsByIdentifier;
    117113#endif
    118114};

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

    r249526 r249801  
    3232#include "FormDataReference.h"
    3333#include "Logging.h"
     34#include "NetworkConnectionToWebProcessMessages.h"
    3435#include "NetworkProcessConnection.h"
    3536#include "NetworkProcessMessages.h"
    … …  
    4142#include "WebSWServerConnectionMessages.h"
    4243#include <WebCore/Document.h>
     44#include <WebCore/ProcessIdentifier.h>
    4345#include <WebCore/SecurityOrigin.h>
    4446#include <WebCore/SerializedScriptValue.h>
    … …  
    5658WebSWClientConnection::WebSWClientConnection(SessionID sessionID)
    5759    : m_sessionID(sessionID)
     60    , m_identifier(Process::identifier())
    5861    , m_swOriginTable(makeUniqueRef<WebSWOriginTable>())
    5962{
    6063    ASSERT(m_sessionID.isValid());
    61     initializeConnectionIfNeeded();
     64    send(Messages::NetworkConnectionToWebProcess::EstablishSWServerConnection { sessionID });
    6265}
    6366
    6467WebSWClientConnection::~WebSWClientConnection()
    6568{
    66     if (m_connection)
    67         WebProcess::singleton().ensureNetworkProcessConnection().removeSWClientConnection(*this);
    68 }
    69 
    70 void WebSWClientConnection::initializeConnectionIfNeeded()
    71 {
    72     if (m_connection)
    73         return;
    74 
    75     auto& networkProcessConnection = WebProcess::singleton().ensureNetworkProcessConnection();
    76 
    77     m_connection = &networkProcessConnection.connection();
    78     m_identifier = networkProcessConnection.initializeSWClientConnection(*this);
    79 
    80     updateThrottleState();
    81 }
    82 
    83 template<typename U>
    84 void WebSWClientConnection::ensureConnectionAndSend(const U& message)
    85 {
    86     initializeConnectionIfNeeded();
    87     if (m_connection)
    88         send(message);
     69    clear();
     70}
     71
     72IPC::Connection* WebSWClientConnection::messageSenderConnection() const
     73{
     74    return &WebProcess::singleton().ensureNetworkProcessConnection().connection();
    8975}
    9076
    9177void WebSWClientConnection::scheduleJobInServer(const ServiceWorkerJobData& jobData)
    9278{
    93     ensureConnectionAndSend(Messages::WebSWServerConnection::ScheduleJobInServer(jobData));
     79    send(Messages::WebSWServerConnection::ScheduleJobInServer { jobData });
    9480}
    9581
    9682void WebSWClientConnection::finishFetchingScriptInServer(const ServiceWorkerFetchResult& result)
    9783{
    98     ensureConnectionAndSend(Messages::WebSWServerConnection::FinishFetchingScriptInServer(result));
     84    send(Messages::WebSWServerConnection::FinishFetchingScriptInServer { result });
    9985}
    10086
    10187void WebSWClientConnection::addServiceWorkerRegistrationInServer(ServiceWorkerRegistrationIdentifier identifier)
    10288{
    103     ensureConnectionAndSend(Messages::WebSWServerConnection::AddServiceWorkerRegistrationInServer(identifier));
     89    send(Messages::WebSWServerConnection::AddServiceWorkerRegistrationInServer { identifier });
    10490}
    10591
    10692void WebSWClientConnection::removeServiceWorkerRegistrationInServer(ServiceWorkerRegistrationIdentifier identifier)
    10793{
    108     ensureConnectionAndSend(Messages::WebSWServerConnection::RemoveServiceWorkerRegistrationInServer(identifier));
     94    send(Messages::WebSWServerConnection::RemoveServiceWorkerRegistrationInServer { identifier });
    10995}
    11096
    11197void WebSWClientConnection::postMessageToServiceWorker(ServiceWorkerIdentifier destinationIdentifier, MessageWithMessagePorts&& message, const ServiceWorkerOrClientIdentifier& sourceIdentifier)
    11298{
    113     WebProcess::singleton().ensureNetworkProcessConnection().connection().send(Messages::NetworkProcess::PostMessageToServiceWorker { destinationIdentifier, WTFMove(message), sourceIdentifier, serverConnectionIdentifier() }, 0);
     99    send(Messages::WebSWServerConnection::PostMessageToServiceWorker { destinationIdentifier, WTFMove(message), sourceIdentifier });
    114100}
    115101
    116102void WebSWClientConnection::registerServiceWorkerClient(const SecurityOrigin& topOrigin, const WebCore::ServiceWorkerClientData& data, const Optional<WebCore::ServiceWorkerRegistrationIdentifier>& controllingServiceWorkerRegistrationIdentifier, const String& userAgent)
    117103{
    118     ensureConnectionAndSend(Messages::WebSWServerConnection::RegisterServiceWorkerClient { topOrigin.data(), data, controllingServiceWorkerRegistrationIdentifier, userAgent });
     104    send(Messages::WebSWServerConnection::RegisterServiceWorkerClient { topOrigin.data(), data, controllingServiceWorkerRegistrationIdentifier, userAgent });
    119105}
    120106
    121107void WebSWClientConnection::unregisterServiceWorkerClient(DocumentIdentifier contextIdentifier)
    122108{
    123     ensureConnectionAndSend(Messages::WebSWServerConnection::UnregisterServiceWorkerClient { ServiceWorkerClientIdentifier { serverConnectionIdentifier(), contextIdentifier } });
     109    send(Messages::WebSWServerConnection::UnregisterServiceWorkerClient { ServiceWorkerClientIdentifier { serverConnectionIdentifier(), contextIdentifier } });
    124110}
    125111
    126112void WebSWClientConnection::didResolveRegistrationPromise(const ServiceWorkerRegistrationKey& key)
    127113{
    128     ensureConnectionAndSend(Messages::WebSWServerConnection::DidResolveRegistrationPromise(key));
     114    send(Messages::WebSWServerConnection::DidResolveRegistrationPromise { key });
    129115}
    130116
    … …  
    177163        uint64_t callbackID = ++m_previousCallbackIdentifier;
    178164        m_ongoingMatchRegistrationTasks.add(callbackID, WTFMove(callback));
    179         ensureConnectionAndSend(Messages::WebSWServerConnection::MatchRegistration(callbackID, topOrigin, clientURL));
     165        send(Messages::WebSWServerConnection::MatchRegistration(callbackID, topOrigin, clientURL));
    180166    });
    181167}
    182168
    183 void WebSWClientConnection::runOrDelayTaskForImport(WTF::Function<void()>&& task)
     169void WebSWClientConnection::runOrDelayTaskForImport(Function<void()>&& task)
    184170{
    185171    if (m_swOriginTable->isImported()) {
    … …  
    188174    }
    189175    m_tasksPendingOriginImport.append(WTFMove(task));
    190     initializeConnectionIfNeeded();
    191176}
    192177
    … …  
    195180    uint64_t callbackID = ++m_previousCallbackIdentifier;
    196181    m_ongoingRegistrationReadyTasks.add(callbackID, WTFMove(callback));
    197     ensureConnectionAndSend(Messages::WebSWServerConnection::WhenRegistrationReady(callbackID, topOrigin, clientURL));
     182    send(Messages::WebSWServerConnection::WhenRegistrationReady(callbackID, topOrigin, clientURL));
    198183}
    199184
    … …  
    217202        uint64_t callbackID = ++m_previousCallbackIdentifier;
    218203        m_ongoingGetRegistrationsTasks.add(callbackID, WTFMove(callback));
    219         ensureConnectionAndSend(Messages::WebSWServerConnection::GetRegistrations(callbackID, topOrigin, clientURL));
     204        send(Messages::WebSWServerConnection::GetRegistrations { callbackID, topOrigin, clientURL });
    220205    });
    221206}
    … …  
    223208void WebSWClientConnection::startFetch(FetchIdentifier fetchIdentifier, ServiceWorkerRegistrationIdentifier serviceWorkerRegistrationIdentifier, const ResourceRequest& request, const FetchOptions& options, const String& referrer)
    224209{
    225     ensureConnectionAndSend(Messages::WebSWServerConnection::StartFetch { serviceWorkerRegistrationIdentifier, fetchIdentifier, request, options, IPC::FormDataReference { request.httpBody() }, referrer });
     210    send(Messages::WebSWServerConnection::StartFetch { serviceWorkerRegistrationIdentifier, fetchIdentifier, request, options, IPC::FormDataReference { request.httpBody() }, referrer });
    226211}
    227212
    228213void WebSWClientConnection::cancelFetch(FetchIdentifier fetchIdentifier, ServiceWorkerRegistrationIdentifier serviceWorkerRegistrationIdentifier)
    229214{
    230     ensureConnectionAndSend(Messages::WebSWServerConnection::CancelFetch { serviceWorkerRegistrationIdentifier, fetchIdentifier });
     215    send(Messages::WebSWServerConnection::CancelFetch { serviceWorkerRegistrationIdentifier, fetchIdentifier });
    231216}
    232217
    233218void WebSWClientConnection::continueDidReceiveFetchResponse(FetchIdentifier fetchIdentifier, ServiceWorkerRegistrationIdentifier serviceWorkerRegistrationIdentifier)
    234219{
    235     ensureConnectionAndSend(Messages::WebSWServerConnection::ContinueDidReceiveFetchResponse { serviceWorkerRegistrationIdentifier, fetchIdentifier });
     220    send(Messages::WebSWServerConnection::ContinueDidReceiveFetchResponse { serviceWorkerRegistrationIdentifier, fetchIdentifier });
    236221}
    237222
    238223void WebSWClientConnection::connectionToServerLost()
    239224{
    240     m_connection = nullptr;
    241 
     225    clear();
     226}
     227
     228void WebSWClientConnection::clear()
     229{
    242230    auto registrationTasks = WTFMove(m_ongoingMatchRegistrationTasks);
    243231    for (auto& callback : registrationTasks.values())
    … …  
    248236        callback({ });
    249237
     238    auto registrationReadyTasks = WTFMove(m_ongoingRegistrationReadyTasks);
     239    for (auto& callback : registrationReadyTasks.values())
     240        callback({ });
     241
    250242    clearPendingJobs();
    251243}
    … …  
    253245void WebSWClientConnection::syncTerminateWorker(ServiceWorkerIdentifier identifier)
    254246{
    255     initializeConnectionIfNeeded();
    256 
    257     sendSync(Messages::WebSWServerConnection::SyncTerminateWorkerFromClient(identifier), Messages::WebSWServerConnection::SyncTerminateWorkerFromClient::Reply());
    258 }
    259 
    260 WebCore::SWServerConnectionIdentifier WebSWClientConnection::serverConnectionIdentifier() const
    261 {
    262     const_cast<WebSWClientConnection*>(this)->initializeConnectionIfNeeded();
    263     return m_identifier;
     247    sendSync(Messages::WebSWServerConnection::SyncTerminateWorkerFromClient { identifier }, Messages::WebSWServerConnection::SyncTerminateWorkerFromClient::Reply());
    264248}
    265249
    … …  
    267251{
    268252    m_isThrottleable = WebProcess::singleton().areAllPagesThrottleable();
    269     ensureConnectionAndSend(Messages::WebSWServerConnection::SetThrottleState { m_isThrottleable });
     253    send(Messages::WebSWServerConnection::SetThrottleState { m_isThrottleable });
    270254}
    271255
    272256void WebSWClientConnection::storeRegistrationsOnDiskForTesting(CompletionHandler<void()>&& callback)
    273257{
    274     initializeConnectionIfNeeded();
    275258    sendWithAsyncReply(Messages::WebSWServerConnection::StoreRegistrationsOnDisk { }, WTFMove(callback));
    276259}

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

    r249526 r249801  
    5353    ~WebSWClientConnection();
    5454
    55     WebCore::SWServerConnectionIdentifier serverConnectionIdentifier() const final;
     55    WebCore::SWServerConnectionIdentifier serverConnectionIdentifier() const final { return m_identifier; }
    5656
    5757    void addServiceWorkerRegistrationInServer(WebCore::ServiceWorkerRegistrationIdentifier) final;
    … …  
    7474private:
    7575    explicit WebSWClientConnection(PAL::SessionID);
    76 
    77     void initializeConnectionIfNeeded();
    7876
    7977    void scheduleJobInServer(const WebCore::ServiceWorkerJobData&) final;
    … …  
    9896    void scheduleStorageJob(const WebCore::ServiceWorkerJobData&);
    9997
    100     void runOrDelayTaskForImport(WTF::Function<void()>&& task);
     98    void runOrDelayTaskForImport(Function<void()>&& task);
    10199
    102     IPC::Connection* messageSenderConnection() const final { return m_connection.get(); }
    103     uint64_t messageSenderDestinationID() const final { return m_identifier.toUInt64(); }
     100    IPC::Connection* messageSenderConnection() const final;
     101    uint64_t messageSenderDestinationID() const final { return m_sessionID.toUInt64(); }
    104102
    105103    void setSWOriginTableSharedMemory(const SharedMemory::Handle&);
    106104    void setSWOriginTableIsImported();
    107105
    108     template<typename U> void ensureConnectionAndSend(const U& message);
     106    void clear();
    109107
    110108    PAL::SessionID m_sessionID;
    111109    WebCore::SWServerConnectionIdentifier m_identifier;
    112110
    113     RefPtr<IPC::Connection> m_connection;
    114111    UniqueRef<WebSWOriginTable> m_swOriginTable;
    115112
    … …  
    118115    HashMap<uint64_t, GetRegistrationsCallback> m_ongoingGetRegistrationsTasks;
    119116    HashMap<uint64_t, WhenRegistrationReadyCallback> m_ongoingRegistrationReadyTasks;
    120     Deque<WTF::Function<void()>> m_tasksPendingOriginImport;
     117    Deque<Function<void()>> m_tasksPendingOriginImport;
    121118    bool m_isThrottleable { true };
    122119}; // class WebSWServerConnection

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

    r249626 r249801  
    3232#include "FormDataReference.h"
    3333#include "Logging.h"
     34#include "NetworkConnectionToWebProcessMessages.h"
    3435#include "NetworkProcessMessages.h"
    3536#include "ServiceWorkerFetchTaskMessages.h"
    … …  
    8788}
    8889
    89 WebSWContextManagerConnection::WebSWContextManagerConnection(Ref<IPC::Connection>&& connection, uint64_t pageGroupID, WebPageProxyIdentifier webPageProxyID, PageIdentifier pageID, const WebPreferencesStore& store)
     90WebSWContextManagerConnection::WebSWContextManagerConnection(Ref<IPC::Connection>&& connection, WebCore::RegistrableDomain&& registrableDomain, uint64_t pageGroupID, WebPageProxyIdentifier webPageProxyID, PageIdentifier pageID, const WebPreferencesStore& store)
    9091    : m_connectionToNetworkProcess(WTFMove(connection))
     92    , m_registrableDomain(WTFMove(registrableDomain))
    9193    , m_pageGroupID(pageGroupID)
    9294    , m_webPageProxyID(webPageProxyID)
    … …  
    99101{
    100102    updatePreferencesStore(store);
     103    m_connectionToNetworkProcess->send(Messages::NetworkConnectionToWebProcess::EstablishSWContextConnection { m_registrableDomain }, 0);
    101104}
    102105
    … …  
    261264}
    262265
    263 void WebSWContextManagerConnection::postMessageToServiceWorkerClient(const ServiceWorkerClientIdentifier& destinationIdentifier, MessageWithMessagePorts&& message, ServiceWorkerIdentifier sourceIdentifier, const String& sourceOrigin)
    264 {
    265     m_connectionToNetworkProcess->send(Messages::NetworkProcess::PostMessageToServiceWorkerClient(destinationIdentifier, WTFMove(message), sourceIdentifier, sourceOrigin), 0);
     266void WebSWContextManagerConnection::postMessageToServiceWorkerClient(PAL::SessionID sessionID, const ServiceWorkerClientIdentifier& destinationIdentifier, const MessageWithMessagePorts& message, ServiceWorkerIdentifier sourceIdentifier, const String& sourceOrigin)
     267{
     268    m_connectionToNetworkProcess->send(Messages::WebSWServerToContextConnection::PostMessageToServiceWorkerClient(sessionID, destinationIdentifier, message, sourceIdentifier, sourceOrigin), 0);
    266269}
    267270

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

    r249501 r249801  
    5454class WebSWContextManagerConnection final : public WebCore::SWContextManager::Connection, public IPC::MessageReceiver {
    5555public:
    56     WebSWContextManagerConnection(Ref<IPC::Connection>&&, uint64_t pageGroupID, WebPageProxyIdentifier, WebCore::PageIdentifier, const WebPreferencesStore&);
     56    WebSWContextManagerConnection(Ref<IPC::Connection>&&, WebCore::RegistrableDomain&&, uint64_t pageGroupID, WebPageProxyIdentifier, WebCore::PageIdentifier, const WebPreferencesStore&);
    5757    ~WebSWContextManagerConnection();
    5858
    … …  
    6666
    6767    // WebCore::SWContextManager::Connection.
    68     void postMessageToServiceWorkerClient(const WebCore::ServiceWorkerClientIdentifier& destinationIdentifier, WebCore::MessageWithMessagePorts&&, WebCore::ServiceWorkerIdentifier sourceIdentifier, const String& sourceOrigin) final;
     68    void postMessageToServiceWorkerClient(PAL::SessionID, const WebCore::ServiceWorkerClientIdentifier& destinationIdentifier, const WebCore::MessageWithMessagePorts&, WebCore::ServiceWorkerIdentifier sourceIdentifier, const String& sourceOrigin) final;
    6969    void didFinishInstall(Optional<WebCore::ServiceWorkerJobDataIdentifier>, WebCore::ServiceWorkerIdentifier, bool wasSuccessful) final;
    7070    void didFinishActivation(WebCore::ServiceWorkerIdentifier) final;
    … …  
    100100
    101101    Ref<IPC::Connection> m_connectionToNetworkProcess;
     102    WebCore::RegistrableDomain m_registrableDomain;
    102103    uint64_t m_pageGroupID;
    103104    WebPageProxyIdentifier m_webPageProxyID;

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

    r249640 r249801  
    18121812
    18131813#if ENABLE(SERVICE_WORKER)
    1814 void WebProcess::establishWorkerContextConnectionToNetworkProcess(uint64_t pageGroupID, WebPageProxyIdentifier webPageProxyID, PageIdentifier pageID, const WebPreferencesStore& store, PAL::SessionID initialSessionID)
     1814void WebProcess::establishWorkerContextConnectionToNetworkProcess(uint64_t pageGroupID, WebPageProxyIdentifier webPageProxyID, PageIdentifier pageID, const WebPreferencesStore& store, RegistrableDomain&& registrableDomain, PAL::SessionID initialSessionID)
    18151815{
    18161816    // We are in the Service Worker context process and the call below establishes our connection to the Network Process
    … …  
    18181818    // NetworkProcessConnection for synchronization purposes.
    18191819    auto& ipcConnection = ensureNetworkProcessConnection().connection();
    1820     SWContextManager::singleton().setConnection(makeUnique<WebSWContextManagerConnection>(ipcConnection, pageGroupID, webPageProxyID, pageID, store));
     1820    SWContextManager::singleton().setConnection(makeUnique<WebSWContextManagerConnection>(ipcConnection, WTFMove(registrableDomain), pageGroupID, webPageProxyID, pageID, store));
    18211821}
    18221822

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

    r249501 r249801  
    366366
    367367#if ENABLE(SERVICE_WORKER)
    368     void establishWorkerContextConnectionToNetworkProcess(uint64_t pageGroupID, WebPageProxyIdentifier, WebCore::PageIdentifier, const WebPreferencesStore&, PAL::SessionID);
     368    void establishWorkerContextConnectionToNetworkProcess(uint64_t pageGroupID, WebPageProxyIdentifier, WebCore::PageIdentifier, const WebPreferencesStore&, WebCore::RegistrableDomain&&, PAL::SessionID);
    369369    void registerServiceWorkerClients();
    370370#endif

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

    r249501 r249801  
    112112
    113113#if ENABLE(SERVICE_WORKER)
    114     EstablishWorkerContextConnectionToNetworkProcess(uint64_t pageGroupID, WebKit::WebPageProxyIdentifier webPageProxyID, WebCore::PageIdentifier pageID, struct WebKit::WebPreferencesStore store, PAL::SessionID initialSessionID)
     114    EstablishWorkerContextConnectionToNetworkProcess(uint64_t pageGroupID, WebKit::WebPageProxyIdentifier webPageProxyID, WebCore::PageIdentifier pageID, struct WebKit::WebPreferencesStore store, WebCore::RegistrableDomain domain, PAL::SessionID initialSessionID)
    115115    RegisterServiceWorkerClients()
    116116#endif
Note: See TracChangeset for help on using the changeset viewer.