Attachment 341702 Details for Bug 186166 – Patch

[patch] Patch

bug-186166-20180531163623.patch (text/plain), 56.16 KB, created by youenn fablet on 2018-05-31 16:36:24 PDT

(hide)

Description:

Filename:

MIME Type:

Creator: youenn fablet

Created: 2018-05-31 16:36:24 PDT

Size: 56.16 KB

patch

obsolete

>Subversion Revision: 232347
>diff --git a/Source/WebCore/ChangeLog b/Source/WebCore/ChangeLog
>index b8c00e19ae4657faeb090bf274adb155562204d8..95a97da2301d19c38498378d5e24a4a13d484982 100644
>--- a/Source/WebCore/ChangeLog
>+++ b/Source/WebCore/ChangeLog
>@@ -1,3 +1,19 @@
>+2018-05-31  Youenn Fablet  <youenn@apple.com>
>+
>+        Make NetworkProcess get cache storage parameters at creation of the CacheStorage engine
>+        https://bugs.webkit.org/show_bug.cgi?id=186166
>+
>+        Reviewed by NOBODY (OOPS!).
>+
>+        Covered by existing tests.
>+
>+        * platform/network/NetworkStorageSession.h:
>+        (WebCore::NetworkStorageSession::cacheStorageDirectory const): Deleted.
>+        (WebCore::NetworkStorageSession::setCacheStorageDirectory): Deleted.
>+        (WebCore::NetworkStorageSession::cacheStoragePerOriginQuota const): Deleted.
>+        (WebCore::NetworkStorageSession::setCacheStoragePerOriginQuota): Deleted.
>+        (): Deleted.
>+
> 2018-05-31  Zalan Bujtas  <zalan@apple.com>
> 
>         [LFC] Margin box is border box + margins.
>diff --git a/Source/WebKit/ChangeLog b/Source/WebKit/ChangeLog
>index 23de5dd709914ede45bc153ee53db6edef33f03c..9d12366a300011fb537640a386cb11c03d5f645a 100644
>--- a/Source/WebKit/ChangeLog
>+++ b/Source/WebKit/ChangeLog
>@@ -1,3 +1,92 @@
>+2018-05-31  Youenn Fablet  <youenn@apple.com>
>+
>+        Make NetworkProcess get cache storage parameters at creation of the CacheStorage engine
>+        https://bugs.webkit.org/show_bug.cgi?id=186166
>+
>+        Reviewed by NOBODY (OOPS!).
>+
>+        Make CacheStorage::Engine creation asynchronous.
>+        Update Engine public methods be static methods taking a SessionID, which will be used to create the engine.
>+
>+        Add IPC methdos to retrieve cache storage parameters from NetworkProcess to UIProcess.
>+
>+        Add NetworkProcessProxy ability to compute the cache storage parameters based on the SessionID.
>+        For that purpose, make NetworkProcessProxy store a map of SessionID-to-WebsiteDataStore.
>+
>+        * NetworkProcess/NetworkProcess.cpp:
>+        (WebKit::NetworkProcess::deleteWebsiteData):
>+        (WebKit::NetworkProcess::deleteWebsiteDataForOrigins):
>+        (WebKit::NetworkProcess::cacheStorageParameters):
>+        (WebKit::NetworkProcess::setCacheStorageParameters):
>+        (WebKit::NetworkProcess::cacheStorageDirectory const): Deleted.
>+        (WebKit::NetworkProcess::cacheStoragePerOriginQuota const): Deleted.
>+        * NetworkProcess/NetworkProcess.h:
>+        * NetworkProcess/NetworkProcess.messages.in:
>+        * NetworkProcess/NetworkProcessCreationParameters.cpp:
>+        (WebKit::NetworkProcessCreationParameters::encode const):
>+        (WebKit::NetworkProcessCreationParameters::decode):
>+        * NetworkProcess/NetworkProcessCreationParameters.h:
>+        * NetworkProcess/cache/CacheStorageEngine.cpp:
>+        (WebKit::CacheStorage::Engine::from):
>+        (WebKit::CacheStorage::Engine::fetchEntries):
>+        (WebKit::CacheStorage::Engine::open):
>+        (WebKit::CacheStorage::Engine::remove):
>+        (WebKit::CacheStorage::Engine::retrieveCaches):
>+        (WebKit::CacheStorage::Engine::retrieveRecords):
>+        (WebKit::CacheStorage::Engine::putRecords):
>+        (WebKit::CacheStorage::Engine::deleteMatchingRecords):
>+        (WebKit::CacheStorage::Engine::lock):
>+        (WebKit::CacheStorage::Engine::unlock):
>+        (WebKit::CacheStorage::Engine::clearMemoryRepresentation):
>+        (WebKit::CacheStorage::Engine::representation):
>+        (WebKit::CacheStorage::Engine::clearAllCaches):
>+        (WebKit::CacheStorage::Engine::clearCachesForOrigin):
>+        (WebKit::CacheStorage::Engine::Engine):
>+        (WebKit::CacheStorage::Engine::readCachesFromDisk):
>+        (WebKit::CacheStorage::Engine::defaultEngine): Deleted.
>+        * NetworkProcess/cache/CacheStorageEngine.h:
>+        (WebKit::CacheStorage::Engine::shouldPersist const):
>+        (WebKit::CacheStorage::Engine::weakPtrFactory):
>+        (WebKit::CacheStorage::Engine::create): Deleted.
>+        * NetworkProcess/cache/CacheStorageEngineConnection.cpp:
>+        (WebKit::CacheStorageEngineConnection::~CacheStorageEngineConnection):
>+        (WebKit::CacheStorageEngineConnection::open):
>+        (WebKit::CacheStorageEngineConnection::remove):
>+        (WebKit::CacheStorageEngineConnection::caches):
>+        (WebKit::CacheStorageEngineConnection::retrieveRecords):
>+        (WebKit::CacheStorageEngineConnection::deleteMatchingRecords):
>+        (WebKit::CacheStorageEngineConnection::putRecords):
>+        (WebKit::CacheStorageEngineConnection::reference):
>+        (WebKit::CacheStorageEngineConnection::dereference):
>+        (WebKit::CacheStorageEngineConnection::clearMemoryRepresentation):
>+        (WebKit::CacheStorageEngineConnection::engineRepresentation):
>+        * NetworkProcess/cache/CacheStorageEngineConnection.h:
>+        * NetworkProcess/cocoa/NetworkProcessCocoa.mm:
>+        (WebKit::NetworkProcess::platformInitializeNetworkProcessCocoa):
>+        * NetworkProcess/mac/RemoteNetworkingContext.mm:
>+        (WebKit::RemoteNetworkingContext::ensureWebsiteDataStoreSession):
>+        * Shared/WebsiteDataStoreParameters.cpp:
>+        (WebKit::WebsiteDataStoreParameters::encode const):
>+        (WebKit::WebsiteDataStoreParameters::decode):
>+        (WebKit::WebsiteDataStoreParameters::privateSessionParameters):
>+        * Shared/WebsiteDataStoreParameters.h:
>+        (): Deleted.
>+        * UIProcess/Network/NetworkProcessProxy.cpp:
>+        (WebKit::NetworkProcessProxy::addSession):
>+        (WebKit::NetworkProcessProxy::removeSession):
>+        (WebKit::NetworkProcessProxy::retrieveCacheStorageParameters):
>+        * UIProcess/Network/NetworkProcessProxy.h:
>+        * UIProcess/Network/NetworkProcessProxy.messages.in:
>+        * UIProcess/WebProcessPool.cpp:
>+        (WebKit::WebProcessPool::ensureNetworkProcess):
>+        (WebKit::WebProcessPool::setAnyPageGroupMightHavePrivateBrowsingEnabled):
>+        (WebKit::WebProcessPool::pageBeginUsingWebsiteDataStore):
>+        (WebKit::WebProcessPool::pageEndUsingWebsiteDataStore):
>+        * UIProcess/WebsiteData/Cocoa/WebsiteDataStoreCocoa.mm:
>+        (WebKit::WebsiteDataStore::parameters):
>+        * UIProcess/WebsiteData/WebsiteDataStore.cpp:
>+        (WebKit::WebsiteDataStore::~WebsiteDataStore):
>+
> 2018-05-30  Yusuke Suzuki  <utatane.tea@gmail.com>
> 
>         [JSC] Pass VM& parameter as much as possible
>diff --git a/Source/WebCore/platform/network/NetworkStorageSession.h b/Source/WebCore/platform/network/NetworkStorageSession.h
>index 2a78644656ccb29a3f68c88a1b06d5d1197f40a6..6e99393df2b89d6c0ffdadd9f241ab8fc092fb93 100644
>--- a/Source/WebCore/platform/network/NetworkStorageSession.h
>+++ b/Source/WebCore/platform/network/NetworkStorageSession.h
>@@ -85,11 +85,6 @@ public:
>     WEBCORE_EXPORT NSHTTPCookieStorage *nsCookieStorage() const;
> #endif
> 
>-    const String& cacheStorageDirectory() const { return m_cacheStorageDirectory; }
>-    void setCacheStorageDirectory(String&& path) { m_cacheStorageDirectory = WTFMove(path); }
>-    uint64_t cacheStoragePerOriginQuota() const { return m_cacheStoragePerOriginQuota; }
>-    void setCacheStoragePerOriginQuota(uint64_t quota) { m_cacheStoragePerOriginQuota = quota; }
>-
> #if PLATFORM(COCOA) || USE(CFURLCONNECTION)
>     WEBCORE_EXPORT static void ensureSession(PAL::SessionID, const String& identifierBase, RetainPtr<CFHTTPCookieStorageRef>&&);
>     NetworkStorageSession(PAL::SessionID, RetainPtr<CFURLStorageSessionRef>&&, RetainPtr<CFHTTPCookieStorageRef>&&);
>@@ -173,9 +168,6 @@ private:
> 
>     CredentialStorage m_credentialStorage;
> 
>-    String m_cacheStorageDirectory;
>-    uint64_t m_cacheStoragePerOriginQuota { 0 };
>-
> #if HAVE(CFNETWORK_STORAGE_PARTITIONING)
>     bool shouldPartitionCookies(const String& topPrivatelyControlledDomain) const;
>     bool shouldBlockThirdPartyCookies(const String& topPrivatelyControlledDomain) const;
>diff --git a/Source/WebKit/NetworkProcess/NetworkProcess.cpp b/Source/WebKit/NetworkProcess/NetworkProcess.cpp
>index 29d62469d487e02580e35f9d739c657bbc181e3c..a160814d630786da494fdeb0e82e7dc503d84b24 100644
>--- a/Source/WebKit/NetworkProcess/NetworkProcess.cpp
>+++ b/Source/WebKit/NetworkProcess/NetworkProcess.cpp
>@@ -132,6 +132,10 @@ NetworkProcess::NetworkProcess()
> 
> NetworkProcess::~NetworkProcess()
> {
>+    for (auto& callbacks : m_cacheStorageParametersCallbacks.values()) {
>+        for (auto& callback : callbacks)
>+            callback(String { }, 0);
>+    }
> }
> 
> AuthenticationManager& NetworkProcess::authenticationManager()
>@@ -564,7 +568,7 @@ void NetworkProcess::deleteWebsiteData(PAL::SessionID sessionID, OptionSet<Websi
>     });
> 
>     if (websiteDataTypes.contains(WebsiteDataType::DOMCache))
>-        CacheStorage::Engine::from(sessionID).clearAllCaches(clearTasksHandler);
>+        CacheStorage::Engine::clearAllCaches(sessionID, clearTasksHandler.copyRef());
> 
>     if (websiteDataTypes.contains(WebsiteDataType::DiskCache) && !sessionID.isEphemeral())
>         clearDiskCache(modifiedSince, [clearTasksHandler = WTFMove(clearTasksHandler)] { });
>@@ -608,7 +612,7 @@ void NetworkProcess::deleteWebsiteDataForOrigins(PAL::SessionID sessionID, Optio
> 
>     if (websiteDataTypes.contains(WebsiteDataType::DOMCache)) {
>         for (auto& originData : originDatas)
>-            CacheStorage::Engine::from(sessionID).clearCachesForOrigin(originData, clearTasksHandler);
>+            CacheStorage::Engine::clearCachesForOrigin(sessionID, SecurityOriginData { originData }, clearTasksHandler.copyRef());
>     }
> 
>     if (websiteDataTypes.contains(WebsiteDataType::DiskCache) && !sessionID.isEphemeral())
>@@ -848,19 +852,25 @@ void NetworkProcess::prefetchDNS(const String& hostname)
>     WebCore::prefetchDNS(hostname);
> }
> 
>-String NetworkProcess::cacheStorageDirectory(PAL::SessionID sessionID) const
>+void NetworkProcess::cacheStorageParameters(PAL::SessionID sessionID, CacheStorageParametersCallback&& callback)
> {
>-    if (sessionID.isEphemeral())
>-        return { };
>-
>-    if (sessionID == PAL::SessionID::defaultSessionID())
>-        return m_cacheStorageDirectory;
>+    m_cacheStorageParametersCallbacks.ensure(sessionID, [&] {
>+        parentProcessConnection()->send(Messages::NetworkProcessProxy::RetrieveCacheStorageParameters { sessionID }, 0);
>+        return Vector<CacheStorageParametersCallback> { };
>+    }).iterator->value.append(WTFMove(callback));
>+}
> 
>-    auto* session = NetworkStorageSession::storageSession(sessionID);
>-    if (!session)
>-        return { };
>+void NetworkProcess::setCacheStorageParameters(PAL::SessionID sessionID, uint64_t quota, String&& cacheStorageDirectory, SandboxExtension::Handle&& handle)
>+{
>+    auto iterator = m_cacheStorageParametersCallbacks.find(sessionID);
>+    if (iterator == m_cacheStorageParametersCallbacks.end())
>+        return;
> 
>-    return session->cacheStorageDirectory();
>+    SandboxExtension::consumePermanently(handle);
>+    auto callbacks = WTFMove(iterator->value);
>+    m_cacheStorageParametersCallbacks.remove(iterator);
>+    for (auto& callback : callbacks)
>+        callback(String { cacheStorageDirectory }, quota);
> }
> 
> void NetworkProcess::preconnectTo(const WebCore::URL& url, WebCore::StoredCredentialsPolicy storedCredentialsPolicy)
>@@ -879,11 +889,6 @@ void NetworkProcess::preconnectTo(const WebCore::URL& url, WebCore::StoredCreden
> #endif
> }
> 
>-uint64_t NetworkProcess::cacheStoragePerOriginQuota() const
>-{
>-    return m_cacheStoragePerOriginQuota;
>-}
>-
> void NetworkProcess::registerURLSchemeAsSecure(const String& scheme) const
> {
>     SchemeRegistry::registerURLSchemeAsSecure(scheme);
>diff --git a/Source/WebKit/NetworkProcess/NetworkProcess.h b/Source/WebKit/NetworkProcess/NetworkProcess.h
>index 83ea2401b0ca16f78dffe56fe5db90fc6281ac6d..eb572639d02e0d35ae61201050be7c8c83514122 100644
>--- a/Source/WebKit/NetworkProcess/NetworkProcess.h
>+++ b/Source/WebKit/NetworkProcess/NetworkProcess.h
>@@ -143,8 +143,9 @@ public:
> #endif
> 
>     Seconds loadThrottleLatency() const { return m_loadThrottleLatency; }
>-    String cacheStorageDirectory(PAL::SessionID) const;
>-    uint64_t cacheStoragePerOriginQuota() const;
>+
>+    using CacheStorageParametersCallback = CompletionHandler<void(const String&, uint64_t quota)>;
>+    void cacheStorageParameters(PAL::SessionID, CacheStorageParametersCallback&&);
> 
>     void preconnectTo(const WebCore::URL&, WebCore::StoredCredentialsPolicy);
> 
>@@ -208,6 +209,8 @@ private:
> 
>     void clearCachedCredentials();
> 
>+    void setCacheStorageParameters(PAL::SessionID, uint64_t quota, String&& cacheStorageDirectory, SandboxExtension::Handle&&);
>+
>     // FIXME: This should take a session ID so we can identify which disk cache to delete.
>     void clearDiskCache(WallTime modifiedSince, Function<void ()>&& completionHandler);
> 
>@@ -255,8 +258,6 @@ private:
>     // Connections to WebProcesses.
>     Vector<RefPtr<NetworkConnectionToWebProcess>> m_webProcessConnections;
> 
>-    String m_cacheStorageDirectory;
>-    uint64_t m_cacheStoragePerOriginQuota { 0 };
>     String m_diskCacheDirectory;
>     bool m_hasSetCacheModel;
>     CacheModel m_cacheModel;
>@@ -299,6 +300,8 @@ private:
> #endif
> 
>     bool m_tracksResourceLoadMilestones { false };
>+
>+    HashMap<PAL::SessionID, Vector<CacheStorageParametersCallback>> m_cacheStorageParametersCallbacks;
> };
> 
> } // namespace WebKit
>diff --git a/Source/WebKit/NetworkProcess/NetworkProcess.messages.in b/Source/WebKit/NetworkProcess/NetworkProcess.messages.in
>index 563a565f3e2bf0ef111afda4c209a5120cfa9b55..8376bbc9b48a6b4138c414abdd9a6cc8f94eeadb 100644
>--- a/Source/WebKit/NetworkProcess/NetworkProcess.messages.in
>+++ b/Source/WebKit/NetworkProcess/NetworkProcess.messages.in
>@@ -98,4 +98,6 @@ messages -> NetworkProcess LegacyReceiver {
>     RegisterURLSchemeAsDisplayIsolated(String scheme)
>     RegisterURLSchemeAsCORSEnabled(String scheme)
>     RegisterURLSchemeAsCanDisplayOnlyIfCanRequest(String scheme)
>+
>+    SetCacheStorageParameters(PAL::SessionID sessionID, uint64_t quota, String cacheStorageDirectory, WebKit::SandboxExtension::Handle handle);
> }
>diff --git a/Source/WebKit/NetworkProcess/NetworkProcessCreationParameters.cpp b/Source/WebKit/NetworkProcess/NetworkProcessCreationParameters.cpp
>index fc2255440582398a0b6c22ccbbcee2acc7f2d852..ca098d3eae703574ae891fd0905171259188f2db 100644
>--- a/Source/WebKit/NetworkProcess/NetworkProcessCreationParameters.cpp
>+++ b/Source/WebKit/NetworkProcess/NetworkProcessCreationParameters.cpp
>@@ -46,9 +46,6 @@ void NetworkProcessCreationParameters::encode(IPC::Encoder& encoder) const
>     encoder.encodeEnum(cacheModel);
>     encoder << diskCacheSizeOverride;
>     encoder << canHandleHTTPSServerTrustEvaluation;
>-    encoder << cacheStorageDirectory;
>-    encoder << cacheStoragePerOriginQuota;
>-    encoder << cacheStorageDirectoryExtensionHandle;
>     encoder << diskCacheDirectory;
>     encoder << diskCacheDirectoryExtensionHandle;
>     encoder << shouldEnableNetworkCacheEfficacyLogging;
>@@ -132,16 +129,6 @@ bool NetworkProcessCreationParameters::decode(IPC::Decoder& decoder, NetworkProc
>         return false;
>     if (!decoder.decode(result.canHandleHTTPSServerTrustEvaluation))
>         return false;
>-    if (!decoder.decode(result.cacheStorageDirectory))
>-        return false;
>-    if (!decoder.decode(result.cacheStoragePerOriginQuota))
>-        return false;
>-    
>-    std::optional<SandboxExtension::Handle> cacheStorageDirectoryExtensionHandle;
>-    decoder >> cacheStorageDirectoryExtensionHandle;
>-    if (!cacheStorageDirectoryExtensionHandle)
>-        return false;
>-    result.cacheStorageDirectoryExtensionHandle = WTFMove(*cacheStorageDirectoryExtensionHandle);
> 
>     if (!decoder.decode(result.diskCacheDirectory))
>         return false;
>diff --git a/Source/WebKit/NetworkProcess/NetworkProcessCreationParameters.h b/Source/WebKit/NetworkProcess/NetworkProcessCreationParameters.h
>index 06f4d40050ff1a3e28b8612bcdd0085fa874eec1..2f347ca1afb5886c1a13132ca9ca991d534de533 100644
>--- a/Source/WebKit/NetworkProcess/NetworkProcessCreationParameters.h
>+++ b/Source/WebKit/NetworkProcess/NetworkProcessCreationParameters.h
>@@ -56,9 +56,6 @@ struct NetworkProcessCreationParameters {
>     int64_t diskCacheSizeOverride { -1 };
>     bool canHandleHTTPSServerTrustEvaluation { true };
> 
>-    String cacheStorageDirectory;
>-    uint64_t cacheStoragePerOriginQuota;
>-    SandboxExtension::Handle cacheStorageDirectoryExtensionHandle;
>     String diskCacheDirectory;
>     SandboxExtension::Handle diskCacheDirectoryExtensionHandle;
>     bool shouldEnableNetworkCacheEfficacyLogging { false };
>diff --git a/Source/WebKit/NetworkProcess/cache/CacheStorageEngine.cpp b/Source/WebKit/NetworkProcess/cache/CacheStorageEngine.cpp
>index ddb8c251285b5fbcc7a6c38d35b72e18430bcf72..e626e23780e7a4f4eaffe18ba55202a7f0e077d0 100644
>--- a/Source/WebKit/NetworkProcess/cache/CacheStorageEngine.cpp
>+++ b/Source/WebKit/NetworkProcess/cache/CacheStorageEngine.cpp
>@@ -80,15 +80,23 @@ Engine::~Engine()
>         callback(Data { }, 1);
> }
> 
>-Engine& Engine::from(PAL::SessionID sessionID)
>+void Engine::from(PAL::SessionID sessionID, Function<void(Engine&)>&& callback)
> {
>+    auto iterator = globalEngineMap().find(sessionID);
>+    if (iterator != globalEngineMap().end()) {
>+        callback(*iterator->value);
>+        return;
>+    }
>+
>     if (sessionID.isEphemeral())
>         sessionID = PAL::SessionID::legacyPrivateSessionID();
> 
>-    auto addResult = globalEngineMap().add(sessionID, nullptr);
>-    if (addResult.isNewEntry)
>-        addResult.iterator->value = Engine::create(NetworkProcess::singleton().cacheStorageDirectory(sessionID));
>-    return *addResult.iterator->value;
>+    NetworkProcess::singleton().cacheStorageParameters(sessionID, [sessionID, callback = WTFMove(callback)](auto&& rootPath, auto quota) {
>+        auto addResult = globalEngineMap().add(sessionID, nullptr);
>+        if (addResult.isNewEntry)
>+            addResult.iterator->value = adoptRef(*new Engine { String { rootPath }, quota });
>+        callback(*addResult.iterator->value);
>+    });
> }
> 
> void Engine::destroyEngine(PAL::SessionID sessionID)
>@@ -97,20 +105,101 @@ void Engine::destroyEngine(PAL::SessionID sessionID)
>     globalEngineMap().remove(sessionID);
> }
> 
>-void Engine::fetchEntries(PAL::SessionID sessionID, bool shouldComputeSize, WTF::CompletionHandler<void(Vector<WebsiteData::Entry>)>&& completionHandler)
>+void Engine::fetchEntries(PAL::SessionID sessionID, bool shouldComputeSize, CompletionHandler<void(Vector<WebsiteData::Entry>)>&& completionHandler)
>+{
>+    from(sessionID, [shouldComputeSize, completionHandler = WTFMove(completionHandler)] (auto& engine) mutable {
>+        engine.fetchEntries(shouldComputeSize, WTFMove(completionHandler));
>+    });
>+}
>+
>+void Engine::open(PAL::SessionID sessionID, WebCore::ClientOrigin&& origin, String&& cacheName, WebCore::DOMCacheEngine::CacheIdentifierCallback&& callback)
>+{
>+    from(sessionID, [origin = WTFMove(origin), cacheName = WTFMove(cacheName), callback = WTFMove(callback)](auto& engine) mutable {
>+        engine.open(origin, cacheName, WTFMove(callback));
>+    });
>+}
>+
>+void Engine::remove(PAL::SessionID sessionID, uint64_t cacheIdentifier, WebCore::DOMCacheEngine::CacheIdentifierCallback&& callback)
>+{
>+    from(sessionID, [cacheIdentifier, callback = WTFMove(callback)](auto& engine) mutable {
>+        engine.remove(cacheIdentifier, WTFMove(callback));
>+    });
>+}
>+
>+void Engine::retrieveCaches(PAL::SessionID sessionID, WebCore::ClientOrigin&& origin, uint64_t updateCounter, WebCore::DOMCacheEngine::CacheInfosCallback&& callback)
> {
>-    from(sessionID).fetchEntries(shouldComputeSize, WTFMove(completionHandler));
>+    from(sessionID, [origin = WTFMove(origin), updateCounter, callback = WTFMove(callback)](auto& engine) mutable {
>+        engine.retrieveCaches(origin, updateCounter, WTFMove(callback));
>+    });
>+}
>+
>+
>+void Engine::retrieveRecords(PAL::SessionID sessionID, uint64_t cacheIdentifier, WebCore::URL&& url, WebCore::DOMCacheEngine::RecordsCallback&& callback)
>+{
>+    from(sessionID, [cacheIdentifier, url = WTFMove(url), callback = WTFMove(callback)](auto& engine) mutable {
>+        engine.retrieveRecords(cacheIdentifier, WTFMove(url), WTFMove(callback));
>+    });
>+}
>+
>+void Engine::putRecords(PAL::SessionID sessionID, uint64_t cacheIdentifier, Vector<WebCore::DOMCacheEngine::Record>&& records, WebCore::DOMCacheEngine::RecordIdentifiersCallback&& callback)
>+{
>+    from(sessionID, [cacheIdentifier, records = WTFMove(records), callback = WTFMove(callback)](auto& engine) mutable {
>+        engine.putRecords(cacheIdentifier, WTFMove(records), WTFMove(callback));
>+    });
> }
> 
>-Engine& Engine::defaultEngine()
>+void Engine::deleteMatchingRecords(PAL::SessionID sessionID, uint64_t cacheIdentifier, WebCore::ResourceRequest&& request, WebCore::CacheQueryOptions&& options, WebCore::DOMCacheEngine::RecordIdentifiersCallback&& callback)
> {
>-    auto sessionID = PAL::SessionID::defaultSessionID();
>-    static NeverDestroyed<Ref<Engine>> defaultEngine = { Engine::create(NetworkProcess::singleton().cacheStorageDirectory(sessionID)) };
>-    return defaultEngine.get();
>+    from(sessionID, [cacheIdentifier, request = WTFMove(request), options = WTFMove(options), callback = WTFMove(callback)](auto& engine) mutable {
>+        engine.deleteMatchingRecords(cacheIdentifier, WTFMove(request), WTFMove(options), WTFMove(callback));
>+    });
>+}
>+
>+void Engine::lock(PAL::SessionID sessionID, uint64_t cacheIdentifier)
>+{
>+    from(sessionID, [cacheIdentifier](auto& engine) mutable {
>+        engine.lock(cacheIdentifier);
>+    });
>+}
>+
>+void Engine::unlock(PAL::SessionID sessionID, uint64_t cacheIdentifier)
>+{
>+    from(sessionID, [cacheIdentifier](auto& engine) mutable {
>+        engine.unlock(cacheIdentifier);
>+    });
>+}
>+
>+void Engine::clearMemoryRepresentation(PAL::SessionID sessionID, WebCore::ClientOrigin&& origin, WebCore::DOMCacheEngine::CompletionCallback&& callback)
>+{
>+    from(sessionID, [origin = WTFMove(origin), callback = WTFMove(callback)](auto& engine) mutable {
>+        engine.clearMemoryRepresentation(origin, WTFMove(callback));
>+    });
>+}
>+
>+void Engine::representation(PAL::SessionID sessionID, CompletionHandler<void(String&&)>&& callback)
>+{
>+    from(sessionID, [callback = WTFMove(callback)](auto& engine) mutable {
>+        callback(engine.representation());
>+    });
>+}
>+
>+void Engine::clearAllCaches(PAL::SessionID sessionID, Ref<WTF::CallbackAggregator>&& aggregator)
>+{
>+    from(sessionID, [aggregator = WTFMove(aggregator)](auto& engine) mutable {
>+        engine.clearAllCaches(aggregator);
>+    });
>+}
>+
>+void Engine::clearCachesForOrigin(PAL::SessionID sessionID, WebCore::SecurityOriginData&& originData, Ref<WTF::CallbackAggregator>&& aggregator)
>+{
>+    from(sessionID, [originData = WTFMove(originData), aggregator = WTFMove(aggregator)](auto& engine) mutable {
>+        engine.clearCachesForOrigin(originData, aggregator);
>+    });
> }
> 
>-Engine::Engine(String&& rootPath)
>+Engine::Engine(String&& rootPath, uint64_t quota)
>     : m_rootPath(WTFMove(rootPath))
>+    , m_quota(quota)
> {
>     if (!m_rootPath.isNull())
>         m_ioQueue = WorkQueue::create("com.apple.WebKit.CacheStorageEngine.serialBackground", WorkQueue::Type::Serial, WorkQueue::QOS::Background);
>@@ -232,7 +321,7 @@ void Engine::readCachesFromDisk(const WebCore::ClientOrigin& origin, CachesCallb
>     initialize([this, origin, callback = WTFMove(callback)](std::optional<Error>&& error) mutable {
>         auto& caches = m_caches.ensure(origin, [&origin, this] {
>             auto path = cachesRootPath(origin);
>-            return Caches::create(*this, WebCore::ClientOrigin { origin }, WTFMove(path), NetworkProcess::singleton().cacheStoragePerOriginQuota());
>+            return Caches::create(*this, WebCore::ClientOrigin { origin }, WTFMove(path), m_quota);
>         }).iterator->value;
> 
>         if (caches->isInitialized()) {
>diff --git a/Source/WebKit/NetworkProcess/cache/CacheStorageEngine.h b/Source/WebKit/NetworkProcess/cache/CacheStorageEngine.h
>index e2973b2b56edf2bd3953d6e9d40b0218f81e037c..f842d3bec9b704325eb15938212312d7e63243c6 100644
>--- a/Source/WebKit/NetworkProcess/cache/CacheStorageEngine.h
>+++ b/Source/WebKit/NetworkProcess/cache/CacheStorageEngine.h
>@@ -57,24 +57,28 @@ class Engine : public RefCounted<Engine> {
> public:
>     ~Engine();
> 
>-    static Engine& from(PAL::SessionID);
>+    static void from(PAL::SessionID, Function<void(Engine&)>&&);
>     static void destroyEngine(PAL::SessionID);
>     static void fetchEntries(PAL::SessionID, bool shouldComputeSize, WTF::CompletionHandler<void(Vector<WebsiteData::Entry>)>&&);
> 
>-    static Ref<Engine> create(String&& rootPath) { return adoptRef(*new Engine(WTFMove(rootPath))); }
>+    static void open(PAL::SessionID, WebCore::ClientOrigin&&, String&& cacheName, WebCore::DOMCacheEngine::CacheIdentifierCallback&&);
>+    static void remove(PAL::SessionID, uint64_t cacheIdentifier, WebCore::DOMCacheEngine::CacheIdentifierCallback&&);
>+    static void retrieveCaches(PAL::SessionID, WebCore::ClientOrigin&&, uint64_t updateCounter, WebCore::DOMCacheEngine::CacheInfosCallback&&);
> 
>-    bool shouldPersist() const { return !!m_ioQueue;}
>+    static void retrieveRecords(PAL::SessionID, uint64_t cacheIdentifier, WebCore::URL&&, WebCore::DOMCacheEngine::RecordsCallback&&);
>+    static void putRecords(PAL::SessionID, uint64_t cacheIdentifier, Vector<WebCore::DOMCacheEngine::Record>&&, WebCore::DOMCacheEngine::RecordIdentifiersCallback&&);
>+    static void deleteMatchingRecords(PAL::SessionID, uint64_t cacheIdentifier, WebCore::ResourceRequest&&, WebCore::CacheQueryOptions&&, WebCore::DOMCacheEngine::RecordIdentifiersCallback&&);
> 
>-    void open(const WebCore::ClientOrigin&, const String& cacheName, WebCore::DOMCacheEngine::CacheIdentifierCallback&&);
>-    void remove(uint64_t cacheIdentifier, WebCore::DOMCacheEngine::CacheIdentifierCallback&&);
>-    void retrieveCaches(const WebCore::ClientOrigin&, uint64_t updateCounter, WebCore::DOMCacheEngine::CacheInfosCallback&&);
>+    static void lock(PAL::SessionID, uint64_t cacheIdentifier);
>+    static void unlock(PAL::SessionID, uint64_t cacheIdentifier);
> 
>-    void retrieveRecords(uint64_t cacheIdentifier, WebCore::URL&&, WebCore::DOMCacheEngine::RecordsCallback&&);
>-    void putRecords(uint64_t cacheIdentifier, Vector<WebCore::DOMCacheEngine::Record>&&, WebCore::DOMCacheEngine::RecordIdentifiersCallback&&);
>-    void deleteMatchingRecords(uint64_t cacheIdentifier, WebCore::ResourceRequest&&, WebCore::CacheQueryOptions&&, WebCore::DOMCacheEngine::RecordIdentifiersCallback&&);
>+    static void clearMemoryRepresentation(PAL::SessionID, WebCore::ClientOrigin&&, WebCore::DOMCacheEngine::CompletionCallback&&);
>+    static void representation(PAL::SessionID, CompletionHandler<void(String&&)>&&);
> 
>-    void lock(uint64_t cacheIdentifier);
>-    void unlock(uint64_t cacheIdentifier);
>+    static void clearAllCaches(PAL::SessionID, Ref<WTF::CallbackAggregator>&&);
>+    static void clearCachesForOrigin(PAL::SessionID, WebCore::SecurityOriginData&&, Ref<WTF::CallbackAggregator>&&);
>+
>+    bool shouldPersist() const { return !!m_ioQueue;}
> 
>     void writeFile(const String& filename, NetworkCache::Data&&, WebCore::DOMCacheEngine::CompletionCallback&&);
>     void readFile(const String& filename, CompletionHandler<void(const NetworkCache::Data&, int error)>&&);
>@@ -84,17 +88,28 @@ public:
>     const NetworkCache::Salt& salt() const { return m_salt.value(); }
>     uint64_t nextCacheIdentifier() { return ++m_nextCacheIdentifier; }
> 
>-    void clearMemoryRepresentation(const WebCore::ClientOrigin&, WebCore::DOMCacheEngine::CompletionCallback&&);
>-    String representation();
>+
>+    WeakPtrFactory<Engine>& weakPtrFactory() { return m_weakFactory; }
>+
>+private:
>+    explicit Engine(String&& rootPath, uint64_t quota);
>+
>+    void open(const WebCore::ClientOrigin&, const String& cacheName, WebCore::DOMCacheEngine::CacheIdentifierCallback&&);
>+    void remove(uint64_t cacheIdentifier, WebCore::DOMCacheEngine::CacheIdentifierCallback&&);
>+    void retrieveCaches(const WebCore::ClientOrigin&, uint64_t updateCounter, WebCore::DOMCacheEngine::CacheInfosCallback&&);
> 
>     void clearAllCaches(WTF::CallbackAggregator&);
>     void clearCachesForOrigin(const WebCore::SecurityOriginData&, WTF::CallbackAggregator&);
> 
>-    WeakPtrFactory<Engine>& weakPtrFactory() { return m_weakFactory; }
>+    void clearMemoryRepresentation(const WebCore::ClientOrigin&, WebCore::DOMCacheEngine::CompletionCallback&&);
>+    String representation();
> 
>-private:
>-    static Engine& defaultEngine();
>-    explicit Engine(String&& rootPath);
>+    void retrieveRecords(uint64_t cacheIdentifier, WebCore::URL&&, WebCore::DOMCacheEngine::RecordsCallback&&);
>+    void putRecords(uint64_t cacheIdentifier, Vector<WebCore::DOMCacheEngine::Record>&&, WebCore::DOMCacheEngine::RecordIdentifiersCallback&&);
>+    void deleteMatchingRecords(uint64_t cacheIdentifier, WebCore::ResourceRequest&&, WebCore::CacheQueryOptions&&, WebCore::DOMCacheEngine::RecordIdentifiersCallback&&);
>+
>+    void lock(uint64_t cacheIdentifier);
>+    void unlock(uint64_t cacheIdentifier);
> 
>     String cachesRootPath(const WebCore::ClientOrigin&);
> 
>@@ -115,6 +130,7 @@ private:
>     HashMap<WebCore::ClientOrigin, RefPtr<Caches>> m_caches;
>     uint64_t m_nextCacheIdentifier { 0 };
>     String m_rootPath;
>+    uint64_t m_quota { 0 };
>     RefPtr<WorkQueue> m_ioQueue;
>     std::optional<NetworkCache::Salt> m_salt;
>     HashMap<CacheIdentifier, LockCount> m_cacheLocks;
>diff --git a/Source/WebKit/NetworkProcess/cache/CacheStorageEngineConnection.cpp b/Source/WebKit/NetworkProcess/cache/CacheStorageEngineConnection.cpp
>index 535f05ad2adf93ae7e7649b2ebfd29bf8808b02b..a5623455d9af0e42720ec5ae33baf47195c8ab5a 100644
>--- a/Source/WebKit/NetworkProcess/cache/CacheStorageEngineConnection.cpp
>+++ b/Source/WebKit/NetworkProcess/cache/CacheStorageEngineConnection.cpp
>@@ -58,15 +58,15 @@ CacheStorageEngineConnection::~CacheStorageEngineConnection()
>         auto& sessionID = keyValue.key;
>         for (auto& references : keyValue.value) {
>             ASSERT(references.value);
>-            Engine::from(sessionID).unlock(references.key);
>+            Engine::unlock(sessionID, references.key);
>         }
>     }
> }
> 
>-void CacheStorageEngineConnection::open(PAL::SessionID sessionID, uint64_t requestIdentifier, const WebCore::ClientOrigin& origin, const String& cacheName)
>+void CacheStorageEngineConnection::open(PAL::SessionID sessionID, uint64_t requestIdentifier, WebCore::ClientOrigin&& origin, String&& cacheName)
> {
>     RELEASE_LOG_IF_ALLOWED("open (%" PRIu64 ")", requestIdentifier);
>-    Engine::from(sessionID).open(origin, cacheName, [connection = makeRef(m_connection.connection()), sessionID, requestIdentifier](const CacheIdentifierOrError& result) {
>+    Engine::open(sessionID, WTFMove(origin), WTFMove(cacheName), [connection = makeRef(m_connection.connection()), sessionID, requestIdentifier](const CacheIdentifierOrError& result) {
>         RELEASE_LOG_FUNCTION_IF_ALLOWED_IN_CALLBACK("open", "cache identifier is %" PRIu64, [](const auto& value) { return value.identifier; });
>         connection->send(Messages::WebCacheStorageConnection::OpenCompleted(requestIdentifier, result), sessionID.sessionID());
>     });
>@@ -75,16 +75,16 @@ void CacheStorageEngineConnection::open(PAL::SessionID sessionID, uint64_t reque
> void CacheStorageEngineConnection::remove(PAL::SessionID sessionID, uint64_t requestIdentifier, uint64_t cacheIdentifier)
> {
>     RELEASE_LOG_IF_ALLOWED("remove (%" PRIu64 ") cache %" PRIu64, requestIdentifier, cacheIdentifier);
>-    Engine::from(sessionID).remove(cacheIdentifier, [connection = makeRef(m_connection.connection()), sessionID, requestIdentifier](const CacheIdentifierOrError& result) {
>+    Engine::remove(sessionID, cacheIdentifier, [connection = makeRef(m_connection.connection()), sessionID, requestIdentifier](const CacheIdentifierOrError& result) {
>         RELEASE_LOG_FUNCTION_IF_ALLOWED_IN_CALLBACK("remove", "removed cache %" PRIu64, [](const auto& value) { return value.identifier; });
>         connection->send(Messages::WebCacheStorageConnection::RemoveCompleted(requestIdentifier, result), sessionID.sessionID());
>     });
> }
> 
>-void CacheStorageEngineConnection::caches(PAL::SessionID sessionID, uint64_t requestIdentifier, const WebCore::ClientOrigin& origin, uint64_t updateCounter)
>+void CacheStorageEngineConnection::caches(PAL::SessionID sessionID, uint64_t requestIdentifier, WebCore::ClientOrigin&& origin, uint64_t updateCounter)
> {
>     RELEASE_LOG_IF_ALLOWED("caches (%" PRIu64 ")", requestIdentifier);
>-    Engine::from(sessionID).retrieveCaches(origin, updateCounter, [connection = makeRef(m_connection.connection()), sessionID, origin, requestIdentifier](CacheInfosOrError&& result) {
>+    Engine::retrieveCaches(sessionID, WTFMove(origin), updateCounter, [connection = makeRef(m_connection.connection()), sessionID, origin, requestIdentifier](CacheInfosOrError&& result) {
>         RELEASE_LOG_FUNCTION_IF_ALLOWED_IN_CALLBACK("caches", "caches size is %lu", [](const auto& value) { return value.infos.size(); });
>         connection->send(Messages::WebCacheStorageConnection::UpdateCaches(requestIdentifier, result), sessionID.sessionID());
>     });
>@@ -93,7 +93,7 @@ void CacheStorageEngineConnection::caches(PAL::SessionID sessionID, uint64_t req
> void CacheStorageEngineConnection::retrieveRecords(PAL::SessionID sessionID, uint64_t requestIdentifier, uint64_t cacheIdentifier, WebCore::URL&& url)
> {
>     RELEASE_LOG_IF_ALLOWED("retrieveRecords (%" PRIu64 ") in cache %" PRIu64, requestIdentifier, cacheIdentifier);
>-    Engine::from(sessionID).retrieveRecords(cacheIdentifier, WTFMove(url), [connection = makeRef(m_connection.connection()), sessionID, requestIdentifier](RecordsOrError&& result) {
>+    Engine::retrieveRecords(sessionID, cacheIdentifier, WTFMove(url), [connection = makeRef(m_connection.connection()), sessionID, requestIdentifier](RecordsOrError&& result) {
>         RELEASE_LOG_FUNCTION_IF_ALLOWED_IN_CALLBACK("retrieveRecords", "records size is %lu", [](const auto& value) { return value.size(); });
>         connection->send(Messages::WebCacheStorageConnection::UpdateRecords(requestIdentifier, result), sessionID.sessionID());
>     });
>@@ -102,7 +102,7 @@ void CacheStorageEngineConnection::retrieveRecords(PAL::SessionID sessionID, uin
> void CacheStorageEngineConnection::deleteMatchingRecords(PAL::SessionID sessionID, uint64_t requestIdentifier, uint64_t cacheIdentifier, WebCore::ResourceRequest&& request, WebCore::CacheQueryOptions&& options)
> {
>     RELEASE_LOG_IF_ALLOWED("deleteMatchingRecords (%" PRIu64 ") in cache %" PRIu64, requestIdentifier, cacheIdentifier);
>-    Engine::from(sessionID).deleteMatchingRecords(cacheIdentifier, WTFMove(request), WTFMove(options), [connection = makeRef(m_connection.connection()), sessionID, requestIdentifier](RecordIdentifiersOrError&& result) {
>+    Engine::deleteMatchingRecords(sessionID, cacheIdentifier, WTFMove(request), WTFMove(options), [connection = makeRef(m_connection.connection()), sessionID, requestIdentifier](RecordIdentifiersOrError&& result) {
>         RELEASE_LOG_FUNCTION_IF_ALLOWED_IN_CALLBACK("deleteMatchingRecords", "deleted %lu records",  [](const auto& value) { return value.size(); });
>         connection->send(Messages::WebCacheStorageConnection::DeleteRecordsCompleted(requestIdentifier, result), sessionID.sessionID());
>     });
>@@ -111,7 +111,7 @@ void CacheStorageEngineConnection::deleteMatchingRecords(PAL::SessionID sessionI
> void CacheStorageEngineConnection::putRecords(PAL::SessionID sessionID, uint64_t requestIdentifier, uint64_t cacheIdentifier, Vector<Record>&& records)
> {
>     RELEASE_LOG_IF_ALLOWED("putRecords (%" PRIu64 ") in cache %" PRIu64 ", %lu records", requestIdentifier, cacheIdentifier, records.size());
>-    Engine::from(sessionID).putRecords(cacheIdentifier, WTFMove(records), [connection = makeRef(m_connection.connection()), sessionID, requestIdentifier](RecordIdentifiersOrError&& result) {
>+    Engine::putRecords(sessionID, cacheIdentifier, WTFMove(records), [connection = makeRef(m_connection.connection()), sessionID, requestIdentifier](RecordIdentifiersOrError&& result) {
>         RELEASE_LOG_FUNCTION_IF_ALLOWED_IN_CALLBACK("putRecords", "put %lu records",  [](const auto& value) { return value.size(); });
>         connection->send(Messages::WebCacheStorageConnection::PutRecordsCompleted(requestIdentifier, result), sessionID.sessionID());
>     });
>@@ -127,7 +127,7 @@ void CacheStorageEngineConnection::reference(PAL::SessionID sessionID, uint64_t
>         return 0;
>     }).iterator->value;
>     if (!counter++)
>-        Engine::from(sessionID).lock(cacheIdentifier);
>+        Engine::lock(sessionID, cacheIdentifier);
> }
> 
> void CacheStorageEngineConnection::dereference(PAL::SessionID sessionID, uint64_t cacheIdentifier)
>@@ -147,20 +147,22 @@ void CacheStorageEngineConnection::dereference(PAL::SessionID sessionID, uint64_
>     if (--referenceResult->value)
>         return;
> 
>-    Engine::from(sessionID).unlock(cacheIdentifier);
>+    Engine::unlock(sessionID, cacheIdentifier);
>     references.remove(referenceResult);
> }
> 
>-void CacheStorageEngineConnection::clearMemoryRepresentation(PAL::SessionID sessionID, uint64_t requestIdentifier, const WebCore::ClientOrigin& origin)
>+void CacheStorageEngineConnection::clearMemoryRepresentation(PAL::SessionID sessionID, uint64_t requestIdentifier, WebCore::ClientOrigin&& origin)
> {
>-    Engine::from(sessionID).clearMemoryRepresentation(origin, [connection = makeRef(m_connection.connection()), sessionID, requestIdentifier] (std::optional<Error>&& error) {
>+    Engine::clearMemoryRepresentation(sessionID, WTFMove(origin), [connection = makeRef(m_connection.connection()), sessionID, requestIdentifier] (std::optional<Error>&& error) {
>         connection->send(Messages::WebCacheStorageConnection::ClearMemoryRepresentationCompleted(requestIdentifier, error), sessionID.sessionID());
>     });
> }
> 
> void CacheStorageEngineConnection::engineRepresentation(PAL::SessionID sessionID, uint64_t requestIdentifier)
> {
>-    m_connection.connection().send(Messages::WebCacheStorageConnection::EngineRepresentationCompleted(requestIdentifier, Engine::from(sessionID).representation()), sessionID.sessionID());
>+    Engine::representation(sessionID, [connection = makeRef(m_connection.connection()), sessionID, requestIdentifier] (auto&& representation) {
>+        connection->send(Messages::WebCacheStorageConnection::EngineRepresentationCompleted { requestIdentifier, representation }, sessionID.sessionID());
>+    });
> }
> 
> }
>diff --git a/Source/WebKit/NetworkProcess/cache/CacheStorageEngineConnection.h b/Source/WebKit/NetworkProcess/cache/CacheStorageEngineConnection.h
>index e57c5e390e063d9fb1d5d0d925fa2e31e7afd223..bc880f5eb589aedcfee45a2341838b253dba6104 100644
>--- a/Source/WebKit/NetworkProcess/cache/CacheStorageEngineConnection.h
>+++ b/Source/WebKit/NetworkProcess/cache/CacheStorageEngineConnection.h
>@@ -50,9 +50,9 @@ public:
> private:
>     explicit CacheStorageEngineConnection(NetworkConnectionToWebProcess&);
> 
>-    void open(PAL::SessionID, uint64_t openRequestIdentifier, const WebCore::ClientOrigin&, const String& cacheName);
>+    void open(PAL::SessionID, uint64_t openRequestIdentifier, WebCore::ClientOrigin&&, String&& cacheName);
>     void remove(PAL::SessionID, uint64_t removeRequestIdentifier, uint64_t cacheIdentifier);
>-    void caches(PAL::SessionID, uint64_t retrieveCachesIdentifier, const WebCore::ClientOrigin&, uint64_t updateCounter);
>+    void caches(PAL::SessionID, uint64_t retrieveCachesIdentifier, WebCore::ClientOrigin&&, uint64_t updateCounter);
> 
>     void retrieveRecords(PAL::SessionID, uint64_t requestIdentifier, uint64_t cacheIdentifier, WebCore::URL&&);
>     void deleteMatchingRecords(PAL::SessionID, uint64_t requestIdentifier, uint64_t cacheIdentifier, WebCore::ResourceRequest&&, WebCore::CacheQueryOptions&&);
>@@ -61,7 +61,7 @@ private:
>     void reference(PAL::SessionID, uint64_t cacheIdentifier);
>     void dereference(PAL::SessionID, uint64_t cacheIdentifier);
> 
>-    void clearMemoryRepresentation(PAL::SessionID, uint64_t requestIdentifier, const WebCore::ClientOrigin&);
>+    void clearMemoryRepresentation(PAL::SessionID, uint64_t requestIdentifier, WebCore::ClientOrigin&&);
>     void engineRepresentation(PAL::SessionID, uint64_t requestIdentifier);
> 
>     NetworkConnectionToWebProcess& m_connection;
>diff --git a/Source/WebKit/NetworkProcess/cocoa/NetworkProcessCocoa.mm b/Source/WebKit/NetworkProcess/cocoa/NetworkProcessCocoa.mm
>index 7e48cf8f37f37bc5d225f41f8e3e95206a01d7f2..017184323000a9490508aec3c9803efdd4bdf7ff 100644
>--- a/Source/WebKit/NetworkProcess/cocoa/NetworkProcessCocoa.mm
>+++ b/Source/WebKit/NetworkProcess/cocoa/NetworkProcessCocoa.mm
>@@ -110,12 +110,6 @@ void NetworkProcess::platformInitializeNetworkProcessCocoa(const NetworkProcessC
> 
>     ASSERT(!m_diskCacheIsDisabledForTesting);
> 
>-    if (!parameters.cacheStorageDirectory.isNull()) {
>-        m_cacheStorageDirectory = parameters.cacheStorageDirectory;
>-        m_cacheStoragePerOriginQuota = parameters.cacheStoragePerOriginQuota;
>-        SandboxExtension::consumePermanently(parameters.cacheStorageDirectoryExtensionHandle);
>-    }
>-
> #if ENABLE(WIFI_ASSERTIONS)
>     initializeWiFiAssertions(parameters);
> #endif
>diff --git a/Source/WebKit/NetworkProcess/mac/RemoteNetworkingContext.mm b/Source/WebKit/NetworkProcess/mac/RemoteNetworkingContext.mm
>index e989bd8e99d4111cfd737a06503775f3ddc005f6..1e02e91c8ca35e4a97ceaef61809155fdd53d2f5 100644
>--- a/Source/WebKit/NetworkProcess/mac/RemoteNetworkingContext.mm
>+++ b/Source/WebKit/NetworkProcess/mac/RemoteNetworkingContext.mm
>@@ -72,12 +72,6 @@ void RemoteNetworkingContext::ensureWebsiteDataStoreSession(WebsiteDataStorePara
>     for (const auto& cookie : parameters.pendingCookies)
>         session->setCookie(cookie);
> 
>-    if (!sessionID.isEphemeral() && !parameters.cacheStorageDirectory.isNull()) {
>-        SandboxExtension::consumePermanently(parameters.cacheStorageDirectoryExtensionHandle);
>-        session->setCacheStorageDirectory(WTFMove(parameters.cacheStorageDirectory));
>-        session->setCacheStoragePerOriginQuota(parameters.cacheStoragePerOriginQuota);
>-    }
>-
>     SessionTracker::setSession(sessionID, NetworkSession::create(WTFMove(parameters.networkSessionParameters)));
> }
> 
>diff --git a/Source/WebKit/Shared/WebsiteDataStoreParameters.cpp b/Source/WebKit/Shared/WebsiteDataStoreParameters.cpp
>index 57dad55c659b6429ff5c681a0e16bd132a88e7e8..8ac9950b5abb44a65aa54cbe1462d6d4863a0799 100644
>--- a/Source/WebKit/Shared/WebsiteDataStoreParameters.cpp
>+++ b/Source/WebKit/Shared/WebsiteDataStoreParameters.cpp
>@@ -41,9 +41,6 @@ void WebsiteDataStoreParameters::encode(IPC::Encoder& encoder) const
>     encoder << uiProcessCookieStorageIdentifier;
>     encoder << cookieStoragePathExtensionHandle;
>     encoder << pendingCookies;
>-    encoder << cacheStorageDirectory;
>-    encoder << cacheStoragePerOriginQuota;
>-    encoder << cacheStorageDirectoryExtensionHandle;
> }
> 
> std::optional<WebsiteDataStoreParameters> WebsiteDataStoreParameters::decode(IPC::Decoder& decoder)
>@@ -67,29 +64,13 @@ std::optional<WebsiteDataStoreParameters> WebsiteDataStoreParameters::decode(IPC
>     decoder >> pendingCookies;
>     if (!pendingCookies)
>         return std::nullopt;
>-
>-    std::optional<String> cacheStorageDirectory;
>-    decoder >> cacheStorageDirectory;
>-    if (!cacheStorageDirectory)
>-        return std::nullopt;
>-
>-    std::optional<uint64_t> cacheStoragePerOriginQuota;
>-    decoder >> cacheStoragePerOriginQuota;
>-    if (!cacheStoragePerOriginQuota)
>-        return std::nullopt;
>-
>-    std::optional<SandboxExtension::Handle> cacheStorageDirectoryExtensionHandle;
>-    decoder >> cacheStorageDirectoryExtensionHandle;
>-    if (!cacheStorageDirectoryExtensionHandle)
>-        return std::nullopt;
>-    
>-    return {{ WTFMove(*uiProcessCookieStorageIdentifier), WTFMove(*cookieStoragePathExtensionHandle), WTFMove(*pendingCookies), WTFMove(*cacheStorageDirectory), WTFMove(*cacheStoragePerOriginQuota), WTFMove(*cacheStorageDirectoryExtensionHandle), WTFMove(*networkSessionParameters)}};
>+    return {{ WTFMove(*uiProcessCookieStorageIdentifier), WTFMove(*cookieStoragePathExtensionHandle), WTFMove(*pendingCookies), WTFMove(*networkSessionParameters)}};
> }
> 
> WebsiteDataStoreParameters WebsiteDataStoreParameters::privateSessionParameters(PAL::SessionID sessionID)
> {
>     ASSERT(sessionID.isEphemeral());
>-    return { { }, { }, { }, { }, WebsiteDataStore::defaultCacheStoragePerOriginQuota, { }, { sessionID, { }, AllowsCellularAccess::Yes
>+    return { { }, { }, { }, { sessionID, { }, AllowsCellularAccess::Yes
> #if PLATFORM(COCOA)
>         , nullptr
> #endif
>diff --git a/Source/WebKit/Shared/WebsiteDataStoreParameters.h b/Source/WebKit/Shared/WebsiteDataStoreParameters.h
>index 8d434963551662d8189135431322206ed5e45a08..abff503bf67854996291a7cc2c57e318e90346ad 100644
>--- a/Source/WebKit/Shared/WebsiteDataStoreParameters.h
>+++ b/Source/WebKit/Shared/WebsiteDataStoreParameters.h
>@@ -54,9 +54,6 @@ struct WebsiteDataStoreParameters {
>     Vector<uint8_t> uiProcessCookieStorageIdentifier;
>     SandboxExtension::Handle cookieStoragePathExtensionHandle;
>     Vector<WebCore::Cookie> pendingCookies;
>-    String cacheStorageDirectory;
>-    uint64_t cacheStoragePerOriginQuota { 0 };
>-    SandboxExtension::Handle cacheStorageDirectoryExtensionHandle;
>     NetworkSessionCreationParameters networkSessionParameters;
> };
> 
>diff --git a/Source/WebKit/UIProcess/Network/NetworkProcessProxy.cpp b/Source/WebKit/UIProcess/Network/NetworkProcessProxy.cpp
>index 2514568e48436508f255dd4381cea74fb5897b17..ef1aa08877d03f5cbc29a0a6b483af0b41cd1737 100644
>--- a/Source/WebKit/UIProcess/Network/NetworkProcessProxy.cpp
>+++ b/Source/WebKit/UIProcess/Network/NetworkProcessProxy.cpp
>@@ -574,6 +574,41 @@ void NetworkProcessProxy::didSyncAllCookies()
>     }
> }
> 
>+void NetworkProcessProxy::addSession(Ref<WebsiteDataStore>&& store)
>+{
>+    if (canSendMessage())
>+        send(Messages::NetworkProcess::AddWebsiteDataStore { store->parameters() }, 0);
>+    if (!store->sessionID().isEphemeral())
>+        m_websiteDataStores.set(store->sessionID(), WTFMove(store));
>+}
>+
>+void NetworkProcessProxy::removeSession(PAL::SessionID sessionID)
>+{
>+    if (canSendMessage())
>+        send(Messages::NetworkProcess::DestroySession { sessionID }, 0);
>+    if (!sessionID.isEphemeral())
>+        m_websiteDataStores.remove(sessionID);
>+}
>+
>+void NetworkProcessProxy::retrieveCacheStorageParameters(PAL::SessionID sessionID)
>+{
>+    auto iterator = m_websiteDataStores.find(sessionID);
>+    if (iterator == m_websiteDataStores.end()) {
>+        auto quota = m_processPool.websiteDataStore() ? m_processPool.websiteDataStore()->websiteDataStore().cacheStoragePerOriginQuota() : WebsiteDataStore::defaultCacheStoragePerOriginQuota;
>+        send(Messages::NetworkProcess::SetCacheStorageParameters { sessionID, quota, { }, { } }, 0);
>+        return;
>+    }
>+
>+
>+    auto& store = *iterator->value;
>+    auto& cacheStorageDirectory = store.cacheStorageDirectory();
>+    SandboxExtension::Handle cacheStorageDirectoryExtensionHandle;
>+    if (!cacheStorageDirectory.isEmpty())
>+        SandboxExtension::createHandleForReadWriteDirectory(cacheStorageDirectory, cacheStorageDirectoryExtensionHandle);
>+
>+    send(Messages::NetworkProcess::SetCacheStorageParameters { sessionID, store.cacheStoragePerOriginQuota(), store.cacheStorageDirectory(), cacheStorageDirectoryExtensionHandle }, 0);
>+}
>+
> #if ENABLE(CONTENT_EXTENSIONS)
> void NetworkProcessProxy::contentExtensionRules(UserContentControllerIdentifier identifier)
> {
>diff --git a/Source/WebKit/UIProcess/Network/NetworkProcessProxy.h b/Source/WebKit/UIProcess/Network/NetworkProcessProxy.h
>index ef6656cb7b693dd4554ffe2af4abd8050c036062..6cc521c6ac1d4c4cf0aa48727498107c20a3a46f 100644
>--- a/Source/WebKit/UIProcess/Network/NetworkProcessProxy.h
>+++ b/Source/WebKit/UIProcess/Network/NetworkProcessProxy.h
>@@ -26,6 +26,7 @@
> #ifndef NetworkProcessProxy_h
> #define NetworkProcessProxy_h
> 
>+#include "APIWebsiteDataStore.h"
> #include "ChildProcessProxy.h"
> #if ENABLE(LEGACY_CUSTOM_PROTOCOL_MANAGER)
> #include "LegacyCustomProtocolManagerProxy.h"
>@@ -99,6 +100,9 @@ public:
>     void didDestroyWebUserContentControllerProxy(WebUserContentControllerProxy&);
> #endif
> 
>+    void addSession(Ref<WebsiteDataStore>&&);
>+    void removeSession(PAL::SessionID);
>+
> private:
>     NetworkProcessProxy(WebProcessPool&);
> 
>@@ -143,6 +147,7 @@ private:
>     void storageAccessRequestResult(bool wasGranted, uint64_t contextId);
>     void allStorageAccessEntriesResult(Vector<String>&& domains, uint64_t contextId);
> #endif
>+    void retrieveCacheStorageParameters(PAL::SessionID);
> 
> #if ENABLE(CONTENT_EXTENSIONS)
>     void contentExtensionRules(UserContentControllerIdentifier);
>@@ -177,6 +182,8 @@ private:
> #if ENABLE(CONTENT_EXTENSIONS)
>     HashSet<WebUserContentControllerProxy*> m_webUserContentControllerProxies;
> #endif
>+
>+    HashMap<PAL::SessionID, RefPtr<WebsiteDataStore>> m_websiteDataStores;
> };
> 
> } // namespace WebKit
>diff --git a/Source/WebKit/UIProcess/Network/NetworkProcessProxy.messages.in b/Source/WebKit/UIProcess/Network/NetworkProcessProxy.messages.in
>index 108862afb63a8524b7c59b25246b3be0d6a9c40b..996a4a595d293537287d2e0a67222983f0c2b505 100644
>--- a/Source/WebKit/UIProcess/Network/NetworkProcessProxy.messages.in
>+++ b/Source/WebKit/UIProcess/Network/NetworkProcessProxy.messages.in
>@@ -53,4 +53,6 @@ messages -> NetworkProcessProxy LegacyReceiver {
> #if ENABLE(CONTENT_EXTENSIONS)
>     ContentExtensionRules(WebKit::UserContentControllerIdentifier identifier)
> #endif
>+
>+    RetrieveCacheStorageParameters(PAL::SessionID sessionID)
> }
>diff --git a/Source/WebKit/UIProcess/WebProcessPool.cpp b/Source/WebKit/UIProcess/WebProcessPool.cpp
>index 9b7ad82c194faa4e087f046d03b570a8d4d98fd7..ac3b913f2d34dacb011389cc75045a0e71b26f0e 100644
>--- a/Source/WebKit/UIProcess/WebProcessPool.cpp
>+++ b/Source/WebKit/UIProcess/WebProcessPool.cpp
>@@ -448,22 +448,19 @@ NetworkProcessProxy& WebProcessPool::ensureNetworkProcess(WebsiteDataStore* with
> {
>     if (m_networkProcess) {
>         if (withWebsiteDataStore) {
>-            m_networkProcess->send(Messages::NetworkProcess::AddWebsiteDataStore(withWebsiteDataStore->parameters()), 0);
>+            m_networkProcess->addSession(makeRef(*withWebsiteDataStore));
>             withWebsiteDataStore->clearPendingCookies();
>         }
>         return *m_networkProcess;
>     }
> 
>-    if (m_websiteDataStore)
>-        m_websiteDataStore->websiteDataStore().resolveDirectoriesIfNecessary();
>-
>     m_networkProcess = NetworkProcessProxy::create(*this);
> 
>     NetworkProcessCreationParameters parameters;
> 
>     if (withWebsiteDataStore) {
>         auto websiteDataStoreParameters = withWebsiteDataStore->parameters();
>-        parameters.defaultSessionParameters = websiteDataStoreParameters.networkSessionParameters;
>+        parameters.defaultSessionParameters = WTFMove(websiteDataStoreParameters.networkSessionParameters);
> 
>         // FIXME: This isn't conceptually correct, but it's needed to preserve behavior introduced in r213241.
>         // We should separate the concept of the default session from the currently used persistent session.
>@@ -482,11 +479,6 @@ NetworkProcessProxy& WebProcessPool::ensureNetworkProcess(WebsiteDataStore* with
>     for (auto& scheme : m_urlSchemesRegisteredForCustomProtocols)
>         parameters.urlSchemesRegisteredForCustomProtocols.append(scheme);
> 
>-    parameters.cacheStorageDirectory = m_websiteDataStore ? m_websiteDataStore->websiteDataStore().cacheStorageDirectory() : API::WebsiteDataStore::defaultCacheStorageDirectory();
>-    if (!parameters.cacheStorageDirectory.isEmpty())
>-        SandboxExtension::createHandleForReadWriteDirectory(parameters.cacheStorageDirectory, parameters.cacheStorageDirectoryExtensionHandle);
>-    parameters.cacheStoragePerOriginQuota = m_websiteDataStore ? m_websiteDataStore->websiteDataStore().cacheStoragePerOriginQuota() : WebsiteDataStore::defaultCacheStoragePerOriginQuota;
>-
>     parameters.diskCacheDirectory = m_configuration->diskCacheDirectory();
>     if (!parameters.diskCacheDirectory.isEmpty())
>         SandboxExtension::createHandleForReadWriteDirectory(parameters.diskCacheDirectory, parameters.diskCacheDirectoryExtensionHandle);
>@@ -539,12 +531,12 @@ NetworkProcessProxy& WebProcessPool::ensureNetworkProcess(WebsiteDataStore* with
>     }
> 
>     if (m_websiteDataStore) {
>-        m_networkProcess->send(Messages::NetworkProcess::AddWebsiteDataStore(m_websiteDataStore->websiteDataStore().parameters()), 0);
>+        m_networkProcess->addSession(makeRef(m_websiteDataStore->websiteDataStore()));
>         m_websiteDataStore->websiteDataStore().clearPendingCookies();
>     }
>     
>     if (withWebsiteDataStore) {
>-        m_networkProcess->send(Messages::NetworkProcess::AddWebsiteDataStore(withWebsiteDataStore->parameters()), 0);
>+        m_networkProcess->addSession(makeRef(*withWebsiteDataStore));
>         withWebsiteDataStore->clearPendingCookies();
>     }
> 
>@@ -725,7 +717,7 @@ void WebProcessPool::setAnyPageGroupMightHavePrivateBrowsingEnabled(bool private
>         if (privateBrowsingEnabled)
>             networkProcess()->send(Messages::NetworkProcess::AddWebsiteDataStore(WebsiteDataStoreParameters::legacyPrivateSessionParameters()), 0);
>         else
>-            networkProcess()->send(Messages::NetworkProcess::DestroySession(PAL::SessionID::legacyPrivateSessionID()), 0);
>+            networkProcess()->removeSession(PAL::SessionID::legacyPrivateSessionID());
>     }
> 
>     if (privateBrowsingEnabled)
>@@ -1202,11 +1194,13 @@ void WebProcessPool::pageBeginUsingWebsiteDataStore(WebPageProxy& page)
>     auto sessionID = page.sessionID();
>     if (sessionID.isEphemeral()) {
>         ASSERT(page.websiteDataStore().parameters().networkSessionParameters.sessionID == sessionID);
>-        sendToNetworkingProcess(Messages::NetworkProcess::AddWebsiteDataStore(page.websiteDataStore().parameters()));
>+        if (m_networkProcess)
>+            m_networkProcess->addSession(makeRef(page.websiteDataStore()));
>         page.process().send(Messages::WebProcess::AddWebsiteDataStore(WebsiteDataStoreParameters::privateSessionParameters(sessionID)), 0);
>         page.websiteDataStore().clearPendingCookies();
>     } else if (sessionID != PAL::SessionID::defaultSessionID()) {
>-        sendToNetworkingProcess(Messages::NetworkProcess::AddWebsiteDataStore(page.websiteDataStore().parameters()));
>+        if (m_networkProcess)
>+            m_networkProcess->addSession(makeRef(page.websiteDataStore()));
>         page.process().send(Messages::WebProcess::AddWebsiteDataStore(page.websiteDataStore().parameters()), 0);
>         page.websiteDataStore().clearPendingCookies();
> 
>@@ -1242,7 +1236,7 @@ void WebProcessPool::pageEndUsingWebsiteDataStore(WebPageProxy& page)
> 
>         // The last user of this non-default PAL::SessionID is gone, so clean it up in the child processes.
>         if (networkProcess())
>-            networkProcess()->send(Messages::NetworkProcess::DestroySession(sessionID), 0);
>+            networkProcess()->removeSession(sessionID);
>         page.process().send(Messages::WebProcess::DestroySession(sessionID), 0);
>     }
> }
>diff --git a/Source/WebKit/UIProcess/WebsiteData/Cocoa/WebsiteDataStoreCocoa.mm b/Source/WebKit/UIProcess/WebsiteData/Cocoa/WebsiteDataStoreCocoa.mm
>index a373f0f787a7e4f8b57446132bacdd001a054e52..c0e1605381f25d8935af1785c3e264fe6d5e733b 100644
>--- a/Source/WebKit/UIProcess/WebsiteData/Cocoa/WebsiteDataStoreCocoa.mm
>+++ b/Source/WebKit/UIProcess/WebsiteData/Cocoa/WebsiteDataStoreCocoa.mm
>@@ -78,11 +78,6 @@ WebsiteDataStoreParameters WebsiteDataStore::parameters()
>     if (!cookieFile.isEmpty())
>         SandboxExtension::createHandleForReadWriteDirectory(WebCore::FileSystem::directoryName(cookieFile), parameters.cookieStoragePathExtensionHandle);
> 
>-    if (!m_configuration.cacheStorageDirectory.isNull()) {
>-        parameters.cacheStorageDirectory = m_configuration.cacheStorageDirectory;
>-        SandboxExtension::createHandleForReadWriteDirectory(parameters.cacheStorageDirectory, parameters.cacheStorageDirectoryExtensionHandle);
>-    }
>-
>     return parameters;
> }
> 
>diff --git a/Source/WebKit/UIProcess/WebsiteData/WebsiteDataStore.cpp b/Source/WebKit/UIProcess/WebsiteData/WebsiteDataStore.cpp
>index 548761a3fc493c91fc733acf1b983c50d9d0e44e..b8324cbae1e29ab5ef748327117d435c45dcbd5a 100644
>--- a/Source/WebKit/UIProcess/WebsiteData/WebsiteDataStore.cpp
>+++ b/Source/WebKit/UIProcess/WebsiteData/WebsiteDataStore.cpp
>@@ -116,8 +116,10 @@ WebsiteDataStore::~WebsiteDataStore()
>     if (m_sessionID.isValid() && m_sessionID != PAL::SessionID::defaultSessionID()) {
>         ASSERT(nonDefaultDataStores().get(m_sessionID) == this);
>         nonDefaultDataStores().remove(m_sessionID);
>-        for (auto& processPool : WebProcessPool::allProcessPools())
>-            processPool->sendToNetworkingProcess(Messages::NetworkProcess::DestroySession(m_sessionID));
>+        for (auto& processPool : WebProcessPool::allProcessPools()) {
>+            if (auto* networkProcess = processPool->networkProcess())
>+                networkProcess->removeSession(m_sessionID);
>+        }
>     }
> }
>

Actions: View | Formatted Diff | Diff

Attachments on bug 186166: 341702 | 341762 | 342777