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

Changeset 287084 in webkit


Ignore:
Timestamp:
Dec 15, 2021, 10:19:32 AM (5 years ago)
Author:
Chris Dumez
Message:

Move SWServers from NetworkProcess to NetworkSession
​https://bugs.webkit.org/show_bug.cgi?id=234179

Reviewed by Darin Adler.

Source/WebKit:

Move SWServers from NetworkProcess to NetworkSession since they are per session.

  • NetworkProcess/NetworkConnectionToWebProcess.cpp:

(WebKit::NetworkConnectionToWebProcess::scheduleResourceLoad):
(WebKit::NetworkConnectionToWebProcess::establishSWServerConnection):
(WebKit::NetworkConnectionToWebProcess::establishSWContextConnection):

  • NetworkProcess/NetworkProcess.cpp:

(WebKit::NetworkProcess::lowMemoryHandler):
(WebKit::NetworkProcess::addWebsiteDataStore):
(WebKit::NetworkProcess::destroySession):
(WebKit::NetworkProcess::fetchWebsiteData):
(WebKit::NetworkProcess::deleteWebsiteData):
(WebKit::NetworkProcess::deleteWebsiteDataForOrigins):
(WebKit::NetworkProcess::deleteAndRestrictWebsiteDataForRegistrableDomains):
(WebKit::NetworkProcess::registrableDomainsWithWebsiteData):
(WebKit::NetworkProcess::prepareToSuspend):
(WebKit::NetworkProcess::resume):
(WebKit::NetworkProcess::processPushMessage):
(WebKit::NetworkProcess::forEachSWServer): Deleted.
(WebKit::NetworkProcess::swServerForSession): Deleted.
(WebKit::NetworkProcess::existingSWOriginStoreForSession const): Deleted.
(WebKit::NetworkProcess::registerSWServerConnection): Deleted.
(WebKit::NetworkProcess::unregisterSWServerConnection): Deleted.
(WebKit::NetworkProcess::addServiceWorkerSession): Deleted.

  • NetworkProcess/NetworkProcess.h:

(WebKit::NetworkProcess::swServerForSessionIfExists): Deleted.

  • NetworkProcess/NetworkSession.cpp:

(WebKit::NetworkSession::lowMemoryHandler):
(WebKit::NetworkSession::swOriginStore const):
(WebKit::NetworkSession::registerSWServerConnection):
(WebKit::NetworkSession::unregisterSWServerConnection):
(WebKit::NetworkSession::ensureSWServer):
(WebKit::NetworkSession::addServiceWorkerSession):
(WebKit::NetworkSession::hasServiceWorkerDatabasePath const):

  • NetworkProcess/NetworkSession.h:

(WebKit::NetworkSession::swServer):

  • NetworkProcess/ServiceWorker/WebSWServerConnection.cpp:

(WebKit::WebSWServerConnection::WebSWServerConnection):
(WebKit::WebSWServerConnection::~WebSWServerConnection):

  • WebProcess/WebPage/WebPage.h:

Source/WTF:

  • wtf/MemoryPressureHandler.h:

Using a bool as underlying type for those enum classes is sufficient.

Location:
trunk/Source
Files:
10 edited

Legend:

Unmodified
Added
Removed

  • trunk/Source/WTF/ChangeLog

    r287080 r287084  
     12021-12-15  Chris Dumez  <cdumez@apple.com>
     2
     3        Move SWServers from NetworkProcess to NetworkSession
     4        https://bugs.webkit.org/show_bug.cgi?id=234179
     5
     6        Reviewed by Darin Adler.
     7
     8        * wtf/MemoryPressureHandler.h:
     9        Using a bool as underlying type for those enum classes is sufficient.
     10
    1112021-12-15  Tomoki Imai  <tomoki.imai@sony.com>
    212

  • trunk/Source/WTF/wtf/MemoryPressureHandler.h

    r285648 r287084  
    6767};
    6868
    69 enum class Critical : uint8_t { No, Yes };
    70 enum class Synchronous : uint8_t { No, Yes };
     69enum class Critical : bool { No, Yes };
     70enum class Synchronous : bool { No, Yes };
    7171
    7272typedef WTF::Function<void(Critical, Synchronous)> LowMemoryHandler;

  • trunk/Source/WebKit/ChangeLog

    r287073 r287084  
     12021-12-15  Chris Dumez  <cdumez@apple.com>
     2
     3        Move SWServers from NetworkProcess to NetworkSession
     4        https://bugs.webkit.org/show_bug.cgi?id=234179
     5
     6        Reviewed by Darin Adler.
     7
     8        Move SWServers from NetworkProcess to NetworkSession since they are per session.
     9
     10        * NetworkProcess/NetworkConnectionToWebProcess.cpp:
     11        (WebKit::NetworkConnectionToWebProcess::scheduleResourceLoad):
     12        (WebKit::NetworkConnectionToWebProcess::establishSWServerConnection):
     13        (WebKit::NetworkConnectionToWebProcess::establishSWContextConnection):
     14        * NetworkProcess/NetworkProcess.cpp:
     15        (WebKit::NetworkProcess::lowMemoryHandler):
     16        (WebKit::NetworkProcess::addWebsiteDataStore):
     17        (WebKit::NetworkProcess::destroySession):
     18        (WebKit::NetworkProcess::fetchWebsiteData):
     19        (WebKit::NetworkProcess::deleteWebsiteData):
     20        (WebKit::NetworkProcess::deleteWebsiteDataForOrigins):
     21        (WebKit::NetworkProcess::deleteAndRestrictWebsiteDataForRegistrableDomains):
     22        (WebKit::NetworkProcess::registrableDomainsWithWebsiteData):
     23        (WebKit::NetworkProcess::prepareToSuspend):
     24        (WebKit::NetworkProcess::resume):
     25        (WebKit::NetworkProcess::processPushMessage):
     26        (WebKit::NetworkProcess::forEachSWServer): Deleted.
     27        (WebKit::NetworkProcess::swServerForSession): Deleted.
     28        (WebKit::NetworkProcess::existingSWOriginStoreForSession const): Deleted.
     29        (WebKit::NetworkProcess::registerSWServerConnection): Deleted.
     30        (WebKit::NetworkProcess::unregisterSWServerConnection): Deleted.
     31        (WebKit::NetworkProcess::addServiceWorkerSession): Deleted.
     32        * NetworkProcess/NetworkProcess.h:
     33        (WebKit::NetworkProcess::swServerForSessionIfExists): Deleted.
     34        * NetworkProcess/NetworkSession.cpp:
     35        (WebKit::NetworkSession::lowMemoryHandler):
     36        (WebKit::NetworkSession::swOriginStore const):
     37        (WebKit::NetworkSession::registerSWServerConnection):
     38        (WebKit::NetworkSession::unregisterSWServerConnection):
     39        (WebKit::NetworkSession::ensureSWServer):
     40        (WebKit::NetworkSession::addServiceWorkerSession):
     41        (WebKit::NetworkSession::hasServiceWorkerDatabasePath const):
     42        * NetworkProcess/NetworkSession.h:
     43        (WebKit::NetworkSession::swServer):
     44        * NetworkProcess/ServiceWorker/WebSWServerConnection.cpp:
     45        (WebKit::WebSWServerConnection::WebSWServerConnection):
     46        (WebKit::WebSWServerConnection::~WebSWServerConnection):
     47        * WebProcess/WebPage/WebPage.h:
     48
    1492021-12-15  Youenn Fablet  <youenn@apple.com>
    250

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

    r286944 r287084  
    500500
    501501#if ENABLE(SERVICE_WORKER)
    502     auto& server = m_networkProcess->swServerForSession(m_sessionID);
    503     if (!server.isImportCompleted()) {
    504         server.whenImportIsCompleted([this, protectedThis = Ref { *this }, loadParameters = WTFMove(loadParameters), existingLoaderToResume]() mutable {
    505             if (!m_networkProcess->webProcessConnection(webProcessIdentifier()))
    506                 return;
    507             ASSERT(m_networkProcess->swServerForSession(m_sessionID).isImportCompleted());
    508             scheduleResourceLoad(WTFMove(loadParameters), existingLoaderToResume);
    509         });
    510         return;
     502    if (auto* session = networkSession()) {
     503        if (auto& server = session->ensureSWServer(); !server.isImportCompleted()) {
     504            server.whenImportIsCompleted([this, protectedThis = Ref { *this }, loadParameters = WTFMove(loadParameters), existingLoaderToResume]() mutable {
     505                if (!m_networkProcess->webProcessConnection(webProcessIdentifier()))
     506                    return;
     507
     508                ASSERT(networkSession());
     509                ASSERT(networkSession()->swServer());
     510                ASSERT(networkSession()->swServer()->isImportCompleted());
     511                scheduleResourceLoad(WTFMove(loadParameters), existingLoaderToResume);
     512            });
     513            return;
     514        }
    511515    }
    512516#endif
    … …  
    11521156        return;
    11531157
    1154     auto& server = m_networkProcess->swServerForSession(m_sessionID);
     1158    auto* session = networkSession();
     1159    if (!session)
     1160        return;
     1161
     1162    auto& server = session->ensureSWServer();
    11551163    auto connection = makeUnique<WebSWServerConnection>(m_networkProcess, server, m_connection.get(), m_webProcessIdentifier);
    11561164
    … …  
    11611169void NetworkConnectionToWebProcess::establishSWContextConnection(WebPageProxyIdentifier webPageProxyID, RegistrableDomain&& registrableDomain, std::optional<ScriptExecutionContextIdentifier> serviceWorkerPageIdentifier, CompletionHandler<void()>&& completionHandler)
    11621170{
    1163     if (auto* server = m_networkProcess->swServerForSessionIfExists(m_sessionID))
    1164         m_swContextConnection = makeUnique<WebSWServerToContextConnection>(*this, webPageProxyID, WTFMove(registrableDomain), serviceWorkerPageIdentifier, *server);
     1171    auto* session = networkSession();
     1172    if (auto* swServer = session ? session->swServer() : nullptr)
     1173        m_swContextConnection = makeUnique<WebSWServerToContextConnection>(*this, webPageProxyID, WTFMove(registrableDomain), serviceWorkerPageIdentifier, *swServer);
    11651174    completionHandler();
    11661175}

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

    r286936 r287084  
    6161#include "WebPushMessage.h"
    6262#include "WebResourceLoadStatisticsStore.h"
    63 #include "WebSWOriginStore.h"
    64 #include "WebSWServerConnection.h"
    65 #include "WebSWServerToContextConnection.h"
    6663#include "WebsiteDataFetchOption.h"
    6764#include "WebsiteDataStore.h"
    … …  
    8279#include <WebCore/RuntimeApplicationChecks.h>
    8380#include <WebCore/RuntimeEnabledFeatures.h>
     81#include <WebCore/SWServer.h>
    8482#include <WebCore/SecurityOrigin.h>
    8583#include <WebCore/SecurityOriginData.h>
    … …  
    117115#endif
    118116
    119 #if ENABLE(SERVICE_WORKER)
    120 #include "WebSWServerToContextConnectionMessages.h"
    121 #endif
    122 
    123117namespace WebKit {
    124118using namespace WebCore;
    … …  
    310304    WTF::releaseFastMallocFreeMemory();
    311305
    312     forEachNetworkSession([](auto& networkSession) {
    313         networkSession.clearPrefetchCache();
     306    forEachNetworkSession([critical](auto& networkSession) {
     307        networkSession.lowMemoryHandler(critical);
    314308    });
    315 
    316 #if ENABLE(SERVICE_WORKER)
    317     for (auto& swServer : m_swServers.values())
    318         swServer->handleLowMemoryWarning();
    319 #endif
    320309
    321310    for (auto& manager : m_storageManagers.values())
    … …  
    426415    addIndexedDatabaseSession(sessionID, parameters.indexedDatabaseDirectory, parameters.indexedDatabaseDirectoryExtensionHandle);
    427416
     417    RemoteNetworkingContext::ensureWebsiteDataStoreSession(*this, WTFMove(parameters));
     418
    428419#if ENABLE(SERVICE_WORKER)
    429     addServiceWorkerSession(sessionID, parameters.serviceWorkerProcessTerminationDelayEnabled, WTFMove(parameters.serviceWorkerRegistrationDirectory), parameters.serviceWorkerRegistrationDirectoryExtensionHandle);
    430 #endif
    431 
    432     RemoteNetworkingContext::ensureWebsiteDataStoreSession(*this, WTFMove(parameters));
     420    if (auto* session = networkSession(sessionID))
     421        session->addServiceWorkerSession(parameters.serviceWorkerProcessTerminationDelayEnabled, WTFMove(parameters.serviceWorkerRegistrationDirectory), parameters.serviceWorkerRegistrationDirectoryExtensionHandle);
     422#endif
    433423}
    434424
    … …  
    568558    m_sessionsControlledByAutomation.remove(sessionID);
    569559    CacheStorage::Engine::destroyEngine(*this, sessionID);
    570 
    571 #if ENABLE(SERVICE_WORKER)
    572     m_swServers.remove(sessionID);
    573     m_serviceWorkerInfo.remove(sessionID);
    574 #endif
    575560
    576561    if (auto server = m_webIDBServers.take(sessionID))
    … …  
    14671452
    14681453    auto callbackAggregator = adoptRef(*new CallbackAggregator(WTFMove(completionHandler)));
     1454    auto* networkSession = this->networkSession(sessionID);
    14691455
    14701456    if (websiteDataTypes.contains(WebsiteDataType::Cookies)) {
    … …  
    15041490
    15051491#if ENABLE(SERVICE_WORKER)
    1506     path = m_serviceWorkerInfo.get(sessionID).databasePath;
    1507     if (!path.isEmpty() && websiteDataTypes.contains(WebsiteDataType::ServiceWorkerRegistrations)) {
    1508         swServerForSession(sessionID).getOriginsWithRegistrations([callbackAggregator](const HashSet<SecurityOriginData>& securityOrigins) mutable {
     1492    if (websiteDataTypes.contains(WebsiteDataType::ServiceWorkerRegistrations) && networkSession && networkSession->hasServiceWorkerDatabasePath()) {
     1493        networkSession->ensureSWServer().getOriginsWithRegistrations([callbackAggregator](const HashSet<SecurityOriginData>& securityOrigins) mutable {
    15091494            for (auto& origin : securityOrigins)
    15101495                callbackAggregator->m_websiteData.entries.append({ origin, WebsiteDataType::ServiceWorkerRegistrations, 0 });
    … …  
    15211506
    15221507#if HAVE(CFNETWORK_ALTERNATIVE_SERVICE)
    1523     if (websiteDataTypes.contains(WebsiteDataType::AlternativeServices)) {
    1524         if (auto* session = networkSession(sessionID)) {
    1525             for (auto& origin : session->hostNamesWithAlternativeServices())
    1526                 callbackAggregator->m_websiteData.entries.append({ origin, WebsiteDataType::AlternativeServices, 0 });
    1527         }
     1508    if (websiteDataTypes.contains(WebsiteDataType::AlternativeServices) && networkSession) {
     1509        for (auto& origin : networkSession->hostNamesWithAlternativeServices())
     1510            callbackAggregator->m_websiteData.entries.append({ origin, WebsiteDataType::AlternativeServices, 0 });
    15281511    }
    15291512#endif
    15301513
    15311514#if ENABLE(INTELLIGENT_TRACKING_PREVENTION)
    1532     if (websiteDataTypes.contains(WebsiteDataType::ResourceLoadStatistics)) {
    1533         if (auto* session = networkSession(sessionID)) {
    1534             if (auto* resourceLoadStatistics = session->resourceLoadStatistics()) {
    1535                 resourceLoadStatistics->registrableDomains([callbackAggregator](auto&& domains) mutable {
    1536                     while (!domains.isEmpty())
    1537                         callbackAggregator->m_websiteData.registrableDomainsWithResourceLoadStatistics.add(domains.takeLast());
    1538                 });
    1539             }
     1515    if (websiteDataTypes.contains(WebsiteDataType::ResourceLoadStatistics) && networkSession) {
     1516        if (auto* resourceLoadStatistics = networkSession->resourceLoadStatistics()) {
     1517            resourceLoadStatistics->registrableDomains([callbackAggregator](auto&& domains) mutable {
     1518                while (!domains.isEmpty())
     1519                    callbackAggregator->m_websiteData.registrableDomainsWithResourceLoadStatistics.add(domains.takeLast());
     1520            });
    15401521        }
    15411522    }
    … …  
    15531534void NetworkProcess::deleteWebsiteData(PAL::SessionID sessionID, OptionSet<WebsiteDataType> websiteDataTypes, WallTime modifiedSince, CompletionHandler<void()>&& completionHandler)
    15541535{
     1536    auto* networkSession = this->networkSession(sessionID);
     1537
    15551538#if PLATFORM(COCOA) || USE(SOUP)
    15561539    if (websiteDataTypes.contains(WebsiteDataType::HSTSCache))
    … …  
    15791562#if ENABLE(SERVICE_WORKER)
    15801563    bool clearServiceWorkers = websiteDataTypes.contains(WebsiteDataType::DOMCache) || websiteDataTypes.contains(WebsiteDataType::ServiceWorkerRegistrations);
    1581     if (clearServiceWorkers && !sessionID.isEphemeral())
    1582         swServerForSession(sessionID).clearAll([clearTasksHandler] { });
     1564    if (clearServiceWorkers && !sessionID.isEphemeral() && networkSession)
     1565        networkSession->ensureSWServer().clearAll([clearTasksHandler] { });
    15831566#endif
    15841567
    15851568#if ENABLE(INTELLIGENT_TRACKING_PREVENTION)
    15861569    if (websiteDataTypes.contains(WebsiteDataType::ResourceLoadStatistics)) {
    1587         if (auto* networkSession = this->networkSession(sessionID)) {
    1588             if (auto* resourceLoadStatistics = networkSession->resourceLoadStatistics()) {
    1589                 auto deletedTypesRaw = websiteDataTypes.toRaw();
    1590                 auto monitoredTypesRaw = WebResourceLoadStatisticsStore::monitoredDataTypes().toRaw();
    1591                
    1592                 // If we are deleting all of the data types that the resource load statistics store monitors
    1593                 // we do not need to re-grandfather old data.
    1594                 auto shouldGrandfather = ((monitoredTypesRaw & deletedTypesRaw) == monitoredTypesRaw) ? ShouldGrandfatherStatistics::No : ShouldGrandfatherStatistics::Yes;
    1595                
    1596                 resourceLoadStatistics->scheduleClearInMemoryAndPersistent(modifiedSince, shouldGrandfather, [clearTasksHandler] { });
    1597             }
     1570        if (auto* resourceLoadStatistics = networkSession ? networkSession->resourceLoadStatistics() : nullptr) {
     1571            // If we are deleting all of the data types that the resource load statistics store monitors
     1572            // we do not need to re-grandfather old data.
     1573            auto shouldGrandfather = websiteDataTypes.containsAll(WebResourceLoadStatisticsStore::monitoredDataTypes()) ? ShouldGrandfatherStatistics::No : ShouldGrandfatherStatistics::Yes;
     1574            resourceLoadStatistics->scheduleClearInMemoryAndPersistent(modifiedSince, shouldGrandfather, [clearTasksHandler] { });
    15981575        }
    15991576    }
    16001577#endif
    16011578
    1602     if (auto* networkSession = this->networkSession(sessionID))
     1579    if (networkSession)
    16031580        networkSession->removeNetworkWebsiteData(modifiedSince, std::nullopt, [clearTasksHandler] { });
    16041581
    … …  
    16061583        clearDiskCache(modifiedSince, [clearTasksHandler] { });
    16071584
    1608     if (websiteDataTypes.contains(WebsiteDataType::PrivateClickMeasurements)) {
    1609         if (auto* networkSession = this->networkSession(sessionID))
    1610             networkSession->clearPrivateClickMeasurement([clearTasksHandler] { });
    1611     }
     1585    if (websiteDataTypes.contains(WebsiteDataType::PrivateClickMeasurements) && networkSession)
     1586        networkSession->clearPrivateClickMeasurement([clearTasksHandler] { });
    16121587
    16131588#if HAVE(CFNETWORK_ALTERNATIVE_SERVICE)
    1614     if (websiteDataTypes.contains(WebsiteDataType::AlternativeServices)) {
    1615         if (auto* networkSession = this->networkSession(sessionID))
    1616             networkSession->clearAlternativeServices(modifiedSince);
    1617     }
     1589    if (websiteDataTypes.contains(WebsiteDataType::AlternativeServices) && networkSession)
     1590        networkSession->clearAlternativeServices(modifiedSince);
    16181591#endif
    16191592
    … …  
    16501623void NetworkProcess::deleteWebsiteDataForOrigins(PAL::SessionID sessionID, OptionSet<WebsiteDataType> websiteDataTypes, const Vector<SecurityOriginData>& originDatas, const Vector<String>& cookieHostNames, const Vector<String>& HSTSCacheHostNames, const Vector<RegistrableDomain>& registrableDomains, CompletionHandler<void()>&& completionHandler)
    16511624{
     1625    auto* networkSession = this->networkSession(sessionID);
     1626
    16521627    if (websiteDataTypes.contains(WebsiteDataType::Cookies)) {
    16531628        if (auto* networkStorageSession = storageSession(sessionID))
    … …  
    16611636
    16621637#if HAVE(CFNETWORK_ALTERNATIVE_SERVICE)
    1663     if (websiteDataTypes.contains(WebsiteDataType::AlternativeServices)) {
    1664         if (auto* networkSession = this->networkSession(sessionID)) {
    1665             Vector<String> hosts;
    1666             hosts.reserveInitialCapacity(originDatas.size());
    1667             for (auto& origin : originDatas)
    1668                 hosts.uncheckedAppend(origin.host);
    1669             networkSession->deleteAlternativeServicesForHostNames(hosts);
    1670         }
     1638    if (websiteDataTypes.contains(WebsiteDataType::AlternativeServices) && networkSession) {
     1639        auto hosts = originDatas.map([](auto& originData) { return originData.host; });
     1640        networkSession->deleteAlternativeServicesForHostNames(hosts);
    16711641    }
    16721642#endif
    … …  
    16741644    auto clearTasksHandler = WTF::CallbackAggregator::create(WTFMove(completionHandler));
    16751645
    1676     if (websiteDataTypes.contains(WebsiteDataType::PrivateClickMeasurements)) {
    1677         if (auto* networkSession = this->networkSession(sessionID)) {
    1678             for (auto& originData : originDatas)
    1679                 networkSession->clearPrivateClickMeasurementForRegistrableDomain(RegistrableDomain::uncheckedCreateFromHost(originData.host), [clearTasksHandler] { });
    1680         }
     1646    if (websiteDataTypes.contains(WebsiteDataType::PrivateClickMeasurements) && networkSession) {
     1647        for (auto& originData : originDatas)
     1648            networkSession->clearPrivateClickMeasurementForRegistrableDomain(RegistrableDomain::uncheckedCreateFromHost(originData.host), [clearTasksHandler] { });
    16811649    }
    16821650
    … …  
    16911659#if ENABLE(SERVICE_WORKER)
    16921660    bool clearServiceWorkers = websiteDataTypes.contains(WebsiteDataType::DOMCache) || websiteDataTypes.contains(WebsiteDataType::ServiceWorkerRegistrations);
    1693     if (clearServiceWorkers && !sessionID.isEphemeral()) {
    1694         auto& server = swServerForSession(sessionID);
     1661    if (clearServiceWorkers && !sessionID.isEphemeral() && networkSession) {
     1662        auto& server = networkSession->ensureSWServer();
    16951663        for (auto& originData : originDatas)
    16961664            server.clear(originData, [clearTasksHandler] { });
    … …  
    17131681
    17141682#if ENABLE(INTELLIGENT_TRACKING_PREVENTION)
    1715     if (websiteDataTypes.contains(WebsiteDataType::ResourceLoadStatistics)) {
    1716         if (auto* networkSession = this->networkSession(sessionID)) {
    1717             for (auto& domain : registrableDomains) {
    1718                 if (auto* resourceLoadStatistics = networkSession->resourceLoadStatistics())
    1719                     resourceLoadStatistics->removeDataForDomain(domain, [clearTasksHandler] { });
    1720             }
     1683    if (websiteDataTypes.contains(WebsiteDataType::ResourceLoadStatistics) && networkSession) {
     1684        for (auto& domain : registrableDomains) {
     1685            if (auto* resourceLoadStatistics = networkSession->resourceLoadStatistics())
     1686                resourceLoadStatistics->removeDataForDomain(domain, [clearTasksHandler] { });
    17211687        }
    17221688    }
    … …  
    17281694    }
    17291695
    1730     if (auto* networkSession = this->networkSession(sessionID)) {
     1696    if (networkSession) {
    17311697        HashSet<WebCore::RegistrableDomain> domainsToDeleteNetworkDataFor;
    17321698        for (auto& originData : originDatas)
    … …  
    17821748void NetworkProcess::deleteAndRestrictWebsiteDataForRegistrableDomains(PAL::SessionID sessionID, OptionSet<WebsiteDataType> websiteDataTypes, RegistrableDomainsToDeleteOrRestrictWebsiteDataFor&& domains, bool shouldNotifyPage, CompletionHandler<void(const HashSet<RegistrableDomain>&)>&& completionHandler)
    17831749{
     1750    auto* networkSession = this->networkSession(sessionID);
     1751
    17841752    OptionSet<WebsiteDataFetchOption> fetchOptions = WebsiteDataFetchOption::DoNotCreateProcesses;
    17851753
    … …  
    18461814
    18471815#if HAVE(CFNETWORK_ALTERNATIVE_SERVICE)
    1848     if (websiteDataTypes.contains(WebsiteDataType::AlternativeServices)) {
    1849         if (auto* networkSession = this->networkSession(sessionID)) {
    1850             Vector<String> registrableDomainsToDelete;
    1851             registrableDomainsToDelete.reserveInitialCapacity(domainsToDeleteAllNonCookieWebsiteDataFor.size());
    1852             for (auto& domain : domainsToDeleteAllNonCookieWebsiteDataFor)
    1853                 registrableDomainsToDelete.uncheckedAppend(domain.string());
    1854             networkSession->deleteAlternativeServicesForHostNames(registrableDomainsToDelete);
    1855         }
     1816    if (websiteDataTypes.contains(WebsiteDataType::AlternativeServices) && networkSession) {
     1817        auto registrableDomainsToDelete = domainsToDeleteAllNonCookieWebsiteDataFor.map([](auto& domain) { return domain.string(); });
     1818        networkSession->deleteAlternativeServicesForHostNames(registrableDomainsToDelete);
    18561819    }
    18571820#endif
    … …  
    18951858   
    18961859#if ENABLE(SERVICE_WORKER)
    1897     path = m_serviceWorkerInfo.get(sessionID).databasePath;
    18981860    bool clearServiceWorkers = websiteDataTypes.contains(WebsiteDataType::DOMCache) || websiteDataTypes.contains(WebsiteDataType::ServiceWorkerRegistrations);
    1899     if (clearServiceWorkers && !path.isEmpty()) {
    1900         swServerForSession(sessionID).getOriginsWithRegistrations([this, sessionID, domainsToDeleteAllNonCookieWebsiteDataFor, callbackAggregator](const HashSet<SecurityOriginData>& securityOrigins) mutable {
     1861    if (clearServiceWorkers && networkSession && networkSession->hasServiceWorkerDatabasePath()) {
     1862        networkSession->ensureSWServer().getOriginsWithRegistrations([domainsToDeleteAllNonCookieWebsiteDataFor, callbackAggregator, networkSession = WeakPtr { *networkSession }](const HashSet<SecurityOriginData>& securityOrigins) mutable {
    19011863            for (auto& securityOrigin : securityOrigins) {
    19021864                if (!domainsToDeleteAllNonCookieWebsiteDataFor.contains(RegistrableDomain::uncheckedCreateFromHost(securityOrigin.host)))
    19031865                    continue;
    19041866                callbackAggregator->m_domains.add(RegistrableDomain::uncheckedCreateFromHost(securityOrigin.host));
    1905                 swServerForSession(sessionID).clear(securityOrigin, [callbackAggregator] { });
     1867                if (networkSession)
     1868                    networkSession->ensureSWServer().clear(securityOrigin, [callbackAggregator] { });
    19061869            }
    19071870        });
    … …  
    19651928void NetworkProcess::registrableDomainsWithWebsiteData(PAL::SessionID sessionID, OptionSet<WebsiteDataType> websiteDataTypes, bool shouldNotifyPage, CompletionHandler<void(HashSet<RegistrableDomain>&&)>&& completionHandler)
    19661929{
     1930    auto* networkSession = this->networkSession(sessionID);
     1931
    19671932    OptionSet<WebsiteDataFetchOption> fetchOptions = WebsiteDataFetchOption::DoNotCreateProcesses;
    19681933   
    … …  
    20382003   
    20392004#if ENABLE(SERVICE_WORKER)
    2040     path = m_serviceWorkerInfo.get(sessionID).databasePath;
    2041     if (!path.isEmpty() && websiteDataTypes.contains(WebsiteDataType::ServiceWorkerRegistrations)) {
    2042         swServerForSession(sessionID).getOriginsWithRegistrations([callbackAggregator](const HashSet<SecurityOriginData>& securityOrigins) mutable {
     2005    if (websiteDataTypes.contains(WebsiteDataType::ServiceWorkerRegistrations) && networkSession && networkSession->hasServiceWorkerDatabasePath()) {
     2006        networkSession->ensureSWServer().getOriginsWithRegistrations([callbackAggregator](const HashSet<SecurityOriginData>& securityOrigins) mutable {
    20432007            for (auto& securityOrigin : securityOrigins)
    20442008                callbackAggregator->m_websiteData.entries.append({ securityOrigin, WebsiteDataType::ServiceWorkerRegistrations, 0 });
    … …  
    22542218    forEachNetworkSession([&] (auto& networkSession) {
    22552219        platformFlushCookies(networkSession.sessionID(), [callbackAggregator] { });
     2220#if ENABLE(SERVICE_WORKER)
     2221        if (auto* swServer = networkSession.swServer())
     2222            swServer->startSuspension([callbackAggregator] { });
     2223#endif
    22562224    });
    22572225
    … …  
    22592227        connection->cleanupForSuspension([callbackAggregator] { });
    22602228
    2261 #if ENABLE(SERVICE_WORKER)
    2262     for (auto& server : m_swServers.values()) {
    2263         ASSERT(m_swServers.get(server->sessionID()) == server.get());
    2264         server->startSuspension([callbackAggregator] { });
    2265     }
    2266 #endif
    2267 
    22682229    for (auto& manager : m_storageManagers.values())
    22692230        manager->suspend([callbackAggregator] { });
    … …  
    22972258
    22982259#if ENABLE(SERVICE_WORKER)
    2299     for (auto& server : m_swServers.values())
    2300         server->endSuspension();
     2260    forEachNetworkSession([&] (auto& networkSession) {
     2261        if (auto swServer = networkSession.swServer())
     2262            swServer->endSuspension();
     2263    });
    23012264#endif
    23022265#if PLATFORM(IOS_FAMILY)
    … …  
    24462409
    24472410#if ENABLE(SERVICE_WORKER)
    2448 void NetworkProcess::forEachSWServer(const Function<void(SWServer&)>& callback)
    2449 {
    2450     for (auto& server : m_swServers.values())
    2451         callback(*server);
    2452 }
    2453 
    2454 SWServer& NetworkProcess::swServerForSession(PAL::SessionID sessionID)
    2455 {
    2456     auto result = m_swServers.ensure(sessionID, [&] {
    2457         auto info = m_serviceWorkerInfo.get(sessionID);
    2458         auto path = info.databasePath;
    2459         // There should already be a registered path for this PAL::SessionID.
    2460         // If there's not, then where did this PAL::SessionID come from?
    2461         ASSERT(sessionID.isEphemeral() || !path.isEmpty());
    2462        
    2463 #if ENABLE(APP_BOUND_DOMAINS)
    2464         auto appBoundDomainsCallback = [this, sessionID](auto&& completionHandler) {
    2465             parentProcessConnection()->sendWithAsyncReply(Messages::NetworkProcessProxy::GetAppBoundDomains { sessionID }, WTFMove(completionHandler), 0);
    2466         };
    2467 #else
    2468         auto appBoundDomainsCallback = [] (auto&& completionHandler) {
    2469             completionHandler({ });
    2470         };
    2471 #endif
    2472         bool shouldRunServiceWorkersOnMainThreadForTesting = false;
    2473         if (auto* session = networkSession(sessionID))
    2474             shouldRunServiceWorkersOnMainThreadForTesting = session->shouldRunServiceWorkersOnMainThreadForTesting();
    2475         return makeUnique<SWServer>(makeUniqueRef<WebSWOriginStore>(), info.processTerminationDelayEnabled, WTFMove(path), sessionID, shouldRunServiceWorkersOnMainThreadForTesting, parentProcessHasServiceWorkerEntitlement(), [this, sessionID](auto&& jobData, bool shouldRefreshCache, auto&& request, auto&& completionHandler) mutable {
    2476             ServiceWorkerSoftUpdateLoader::start(networkSession(sessionID), WTFMove(jobData), shouldRefreshCache, WTFMove(request), WTFMove(completionHandler));
    2477         }, [this, sessionID](auto& registrableDomain, std::optional<ScriptExecutionContextIdentifier> serviceWorkerPageIdentifier, auto&& completionHandler) {
    2478             ASSERT(!registrableDomain.isEmpty());
    2479             parentProcessConnection()->sendWithAsyncReply(Messages::NetworkProcessProxy::EstablishWorkerContextConnectionToNetworkProcess { registrableDomain, serviceWorkerPageIdentifier, sessionID }, WTFMove(completionHandler), 0);
    2480         }, WTFMove(appBoundDomainsCallback));
    2481     });
    2482     return *result.iterator->value;
    2483 }
    2484 
    2485 WebSWOriginStore* NetworkProcess::existingSWOriginStoreForSession(PAL::SessionID sessionID) const
    2486 {
    2487     auto* swServer = m_swServers.get(sessionID);
    2488     if (!swServer)
    2489         return nullptr;
    2490     return &static_cast<WebSWOriginStore&>(swServer->originStore());
    2491 }
    2492 
    2493 void NetworkProcess::registerSWServerConnection(WebSWServerConnection& connection)
    2494 {
    2495     auto* store = existingSWOriginStoreForSession(connection.sessionID());
    2496     ASSERT(store);
    2497     if (store)
    2498         store->registerSWServerConnection(connection);
    2499 }
    2500 
    2501 void NetworkProcess::unregisterSWServerConnection(WebSWServerConnection& connection)
    2502 {
    2503     if (auto* store = existingSWOriginStoreForSession(connection.sessionID()))
    2504         store->unregisterSWServerConnection(connection);
    2505 }
    2506 
    2507 void NetworkProcess::addServiceWorkerSession(PAL::SessionID sessionID, bool processTerminationDelayEnabled, String&& serviceWorkerRegistrationDirectory, const SandboxExtension::Handle& handle)
    2508 {
    2509     ServiceWorkerInfo info {
    2510         WTFMove(serviceWorkerRegistrationDirectory),
    2511         processTerminationDelayEnabled
    2512     };
    2513     auto addResult = m_serviceWorkerInfo.add(sessionID, WTFMove(info));
    2514     if (addResult.isNewEntry)
    2515         SandboxExtension::consumePermanently(handle);
    2516 }
    2517 
    25182411void NetworkProcess::getPendingPushMessages(PAL::SessionID sessionID, CompletionHandler<void(const Vector<WebPushMessage>&)>&& callback)
    25192412{
    … …  
    25292422void NetworkProcess::processPushMessage(PAL::SessionID sessionID, WebPushMessage&& pushMessage, CompletionHandler<void(bool)>&& callback)
    25302423{
    2531     swServerForSession(sessionID).processPushMessage(WTFMove(pushMessage.pushData), WTFMove(pushMessage.registrationURL), WTFMove(callback));
     2424    if (auto* session = networkSession(sessionID))
     2425        session->ensureSWServer().processPushMessage(WTFMove(pushMessage.pushData), WTFMove(pushMessage.registrationURL), WTFMove(callback));
    25322426}
    25332427#endif // ENABLE(SERVICE_WORKER)

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

    r286936 r287084  
    8686class NetworkStorageSession;
    8787class ResourceError;
    88 class SWServer;
    8988class UserContentURLPattern;
    9089enum class HTTPCookieAcceptPolicy : uint8_t;
    … …  
    109108class ProcessAssertion;
    110109class WebPageNetworkParameters;
    111 class WebSWServerConnection;
    112 class WebSWServerToContextConnection;
    113110enum class CallDownloadDidStart : bool;
    114111enum class ShouldGrandfatherStatistics : bool;
    … …  
    119116struct WebPushMessage;
    120117struct WebsiteDataStoreParameters;
    121 
    122 #if ENABLE(SERVICE_WORKER)
    123 class WebSWOriginStore;
    124 #endif
    125118
    126119namespace NetworkCache {
    … …  
    309302    void renameOriginInWebsiteData(PAL::SessionID, const URL&, const URL&, OptionSet<WebsiteDataType>, CompletionHandler<void()>&&);
    310303
    311 #if ENABLE(SERVICE_WORKER)
    312     WebCore::SWServer* swServerForSessionIfExists(PAL::SessionID sessionID) { return m_swServers.get(sessionID); }
    313     WebCore::SWServer& swServerForSession(PAL::SessionID);
    314     void registerSWServerConnection(WebSWServerConnection&);
    315     void unregisterSWServerConnection(WebSWServerConnection&);
    316    
    317     void forEachSWServer(const Function<void(WebCore::SWServer&)>&);
    318 #endif
    319 
    320304#if PLATFORM(IOS_FAMILY)
    321305    bool parentProcessHasServiceWorkerEntitlement() const;
    … …  
    501485    void suspendIDBServers(bool isSuspensionImminent);
    502486
    503 #if ENABLE(SERVICE_WORKER)
    504     void didCreateWorkerContextProcessConnection(const IPC::Attachment&);
    505 
    506     void postMessageToServiceWorker(PAL::SessionID, WebCore::ServiceWorkerIdentifier destination, WebCore::MessageWithMessagePorts&&, const WebCore::ServiceWorkerOrClientIdentifier& source, WebCore::SWServerConnectionIdentifier);
    507    
    508     void disableServiceWorkerProcessTerminationDelay();
    509    
    510     WebSWOriginStore* existingSWOriginStoreForSession(PAL::SessionID) const;
    511 
    512     void addServiceWorkerSession(PAL::SessionID, bool processTerminationDelayEnabled, String&& serviceWorkerRegistrationDirectory, const SandboxExtension::Handle&);
    513 #endif
    514 
    515487#if PLATFORM(IOS_FAMILY)
    516488    void setIsHoldingLockedFiles(bool);
    … …  
    599571    uint64_t m_suspensionIdentifier { 0 };
    600572   
    601 #if ENABLE(SERVICE_WORKER)
    602     struct ServiceWorkerInfo {
    603         String databasePath;
    604         bool processTerminationDelayEnabled { true };
    605     };
    606     HashMap<PAL::SessionID, ServiceWorkerInfo> m_serviceWorkerInfo;
    607     HashMap<PAL::SessionID, std::unique_ptr<WebCore::SWServer>> m_swServers;
    608 #endif
    609    
    610573#if ENABLE(WEB_RTC)
    611574    RefPtr<RTCDataChannelRemoteManagerProxy> m_rtcDataChannelProxy;

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

    r286361 r287084  
    4444#include "WebPageProxyMessages.h"
    4545#include "WebProcessProxy.h"
     46#include "WebSWOriginStore.h"
    4647#include "WebSocketTask.h"
    4748#include <WebCore/CookieJar.h>
    … …  
    548549}
    549550
     551void NetworkSession::lowMemoryHandler(Critical)
     552{
     553    clearPrefetchCache();
     554
     555#if ENABLE(SERVICE_WORKER)
     556    if (m_swServer)
     557        m_swServer->handleLowMemoryWarning();
     558#endif
     559}
     560
    550561#if ENABLE(SERVICE_WORKER)
    551562void NetworkSession::addNavigationPreloaderTask(ServiceWorkerFetchTask& task)
    … …  
    563574    return m_navigationPreloaders.get(identifier).get();
    564575}
    565 #endif
     576
     577WebSWOriginStore* NetworkSession::swOriginStore() const
     578{
     579    return m_swServer ? &static_cast<WebSWOriginStore&>(m_swServer->originStore()) : nullptr;
     580}
     581
     582void NetworkSession::registerSWServerConnection(WebSWServerConnection& connection)
     583{
     584    auto* store = swOriginStore();
     585    ASSERT(store);
     586    if (store)
     587        store->registerSWServerConnection(connection);
     588}
     589
     590void NetworkSession::unregisterSWServerConnection(WebSWServerConnection& connection)
     591{
     592    if (auto* store = swOriginStore())
     593        store->unregisterSWServerConnection(connection);
     594}
     595
     596SWServer& NetworkSession::ensureSWServer()
     597{
     598    if (!m_swServer) {
     599        auto info = m_serviceWorkerInfo.value_or(ServiceWorkerInfo { });
     600        auto path = info.databasePath;
     601        // There should already be a registered path for this PAL::SessionID.
     602        // If there's not, then where did this PAL::SessionID come from?
     603        ASSERT(m_sessionID.isEphemeral() || !path.isEmpty());
     604
     605#if ENABLE(APP_BOUND_DOMAINS)
     606        auto appBoundDomainsCallback = [this](auto&& completionHandler) {
     607            m_networkProcess->parentProcessConnection()->sendWithAsyncReply(Messages::NetworkProcessProxy::GetAppBoundDomains { m_sessionID }, WTFMove(completionHandler), 0);
     608        };
     609#else
     610        auto appBoundDomainsCallback = [] (auto&& completionHandler) {
     611            completionHandler({ });
     612        };
     613#endif
     614        m_swServer = makeUnique<SWServer>(makeUniqueRef<WebSWOriginStore>(), info.processTerminationDelayEnabled, WTFMove(path), m_sessionID, shouldRunServiceWorkersOnMainThreadForTesting(), m_networkProcess->parentProcessHasServiceWorkerEntitlement(), [this](auto&& jobData, bool shouldRefreshCache, auto&& request, auto&& completionHandler) mutable {
     615            ServiceWorkerSoftUpdateLoader::start(this, WTFMove(jobData), shouldRefreshCache, WTFMove(request), WTFMove(completionHandler));
     616        }, [this](auto& registrableDomain, std::optional<ScriptExecutionContextIdentifier> serviceWorkerPageIdentifier, auto&& completionHandler) {
     617            ASSERT(!registrableDomain.isEmpty());
     618            m_networkProcess->parentProcessConnection()->sendWithAsyncReply(Messages::NetworkProcessProxy::EstablishWorkerContextConnectionToNetworkProcess { registrableDomain, serviceWorkerPageIdentifier, m_sessionID }, WTFMove(completionHandler), 0);
     619        }, WTFMove(appBoundDomainsCallback));
     620    }
     621    return *m_swServer;
     622}
     623
     624void NetworkSession::addServiceWorkerSession(bool processTerminationDelayEnabled, String&& serviceWorkerRegistrationDirectory, const SandboxExtension::Handle& handle)
     625{
     626    bool hadServiceWorkerInfo = !!m_serviceWorkerInfo;
     627    m_serviceWorkerInfo = ServiceWorkerInfo {
     628        WTFMove(serviceWorkerRegistrationDirectory),
     629        processTerminationDelayEnabled
     630    };
     631    if (!hadServiceWorkerInfo)
     632        SandboxExtension::consumePermanently(handle);
     633}
     634
     635bool NetworkSession::hasServiceWorkerDatabasePath() const
     636{
     637    return m_serviceWorkerInfo && !m_serviceWorkerInfo->databasePath.isEmpty();
     638}
     639
     640#endif // ENABLE(SERVICE_WORKER)
    566641
    567642} // namespace WebKit

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

    r286830 r287084  
    5656class ResourceRequest;
    5757class ResourceError;
     58class SWServer;
    5859enum class IncludeHttpOnlyCookies : bool;
    5960enum class ShouldSample : bool;
    6061struct SecurityOriginData;
     62}
     63
     64namespace WTF {
     65enum class Critical : bool;
    6166}
    6267
    … …  
    7378class WebResourceLoadStatisticsStore;
    7479class WebSocketTask;
     80class WebSWOriginStore;
     81class WebSWServerConnection;
    7582struct NetworkSessionCreationParameters;
    7683struct SessionSet;
    … …  
    177184    bool isStaleWhileRevalidateEnabled() const { return m_isStaleWhileRevalidateEnabled; }
    178185
     186    void lowMemoryHandler(WTF::Critical);
     187
    179188#if ENABLE(SERVICE_WORKER)
    180189    void addSoftUpdateLoader(std::unique_ptr<ServiceWorkerSoftUpdateLoader>&& loader) { m_softUpdateLoaders.add(WTFMove(loader)); }
    … …  
    183192    ServiceWorkerFetchTask* navigationPreloaderTaskFromFetchIdentifier(WebCore::FetchIdentifier);
    184193    void removeNavigationPreloaderTask(ServiceWorkerFetchTask&);
     194
     195    WebCore::SWServer* swServer() { return m_swServer.get(); }
     196    WebCore::SWServer& ensureSWServer();
     197    WebSWOriginStore* swOriginStore() const; // FIXME: Can be private?
     198    void registerSWServerConnection(WebSWServerConnection&);
     199    void unregisterSWServerConnection(WebSWServerConnection&);
     200
     201    bool hasServiceWorkerDatabasePath() const;
     202
     203    void addServiceWorkerSession(bool processTerminationDelayEnabled, String&& serviceWorkerRegistrationDirectory, const SandboxExtension::Handle&);
    185204#endif
    186205
    … …  
    268287    HashSet<std::unique_ptr<ServiceWorkerSoftUpdateLoader>> m_softUpdateLoaders;
    269288    HashMap<WebCore::FetchIdentifier, WeakPtr<ServiceWorkerFetchTask>> m_navigationPreloaders;
     289
     290    struct ServiceWorkerInfo {
     291        String databasePath;
     292        bool processTerminationDelayEnabled { true };
     293    };
     294    std::optional<ServiceWorkerInfo> m_serviceWorkerInfo;
     295    std::unique_ptr<WebCore::SWServer> m_swServer;
    270296#endif
    271297

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

    r286419 r287084  
    3636#include "NetworkProcessProxyMessages.h"
    3737#include "NetworkResourceLoader.h"
     38#include "NetworkSession.h"
    3839#include "WebCoreArgumentCoders.h"
    3940#include "WebProcess.h"
    … …  
    7071    , m_networkProcess(networkProcess)
    7172{
    72     networkProcess.registerSWServerConnection(*this);
     73    if (auto* session = this->session())
     74        session->registerSWServerConnection(*this);
    7375}
    7476
    7577WebSWServerConnection::~WebSWServerConnection()
    7678{
    77     m_networkProcess->unregisterSWServerConnection(*this);
     79    if (auto* session = this->session())
     80        session->unregisterSWServerConnection(*this);
    7881    for (const auto& keyValue : m_clientOrigins)
    7982        server().unregisterServiceWorkerClient(keyValue.value, keyValue.key);

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

    r287021 r287084  
    174174
    175175namespace WTF {
    176 enum class Critical : uint8_t;
     176enum class Critical : bool;
    177177}
    178178
Note: See TracChangeset for help on using the changeset viewer.