Attachment 369978 Details for Bug 197636 – Patch

[patch] Patch

bug-197636-20190515115537.patch (text/plain), 287.83 KB, created by Sihui Liu on 2019-05-15 11:55:38 PDT

(hide)

Description:

Filename:

MIME Type:

Creator: Sihui Liu

Created: 2019-05-15 11:55:38 PDT

Size: 287.83 KB

patch

obsolete

>Subversion Revision: 245304
>diff --git a/Source/WebKit/ChangeLog b/Source/WebKit/ChangeLog
>index 44ebe141a21d969570e6f01c9efee99c9a9eb179..bd4a0ce6cc5159eac7c1769199d6b3df49d299ad 100644
>--- a/Source/WebKit/ChangeLog
>+++ b/Source/WebKit/ChangeLog
>@@ -1,3 +1,243 @@
>+2019-05-15  Sihui Liu  <sihui_liu@apple.com>
>+
>+        Move Web Storage to Network Process
>+        https://bugs.webkit.org/show_bug.cgi?id=197636
>+
>+        Reviewed by NOBODY (OOPS!).
>+
>+        * CMakeLists.txt:
>+        * DerivedSources.make:
>+        * NetworkProcess/NetworkConnectionToWebProcess.cpp:
>+        (WebKit::NetworkConnectionToWebProcess::didReceiveMessage):
>+        (WebKit::NetworkConnectionToWebProcess::didReceiveSyncMessage):
>+        (WebKit::NetworkConnectionToWebProcess::didClose):
>+        (WebKit::NetworkConnectionToWebProcess::webPageWasAdded):
>+        (WebKit::NetworkConnectionToWebProcess::webPageWasRemoved):
>+        (WebKit::NetworkConnectionToWebProcess::webProcessSessionChanged):
>+        * NetworkProcess/NetworkConnectionToWebProcess.h:
>+        * NetworkProcess/NetworkConnectionToWebProcess.messages.in:
>+        * NetworkProcess/NetworkProcess.cpp:
>+        (WebKit::NetworkProcess::networkSessionByConnection const):
>+        (WebKit::NetworkProcess::hasLocalStorage):
>+        (WebKit::NetworkProcess::fetchWebsiteData):
>+        (WebKit::NetworkProcess::deleteWebsiteData):
>+        (WebKit::NetworkProcess::deleteWebsiteDataForOrigins):
>+        (WebKit::filterForRegistrableDomains):
>+        (WebKit::NetworkProcess::deleteWebsiteDataForRegistrableDomains):
>+        (WebKit::NetworkProcess::webPageWasAdded):
>+        (WebKit::NetworkProcess::webPageWasRemoved):
>+        (WebKit::NetworkProcess::webProcessWasDisconnected):
>+        (WebKit::NetworkProcess::webProcessSessionChanged):
>+        (WebKit::NetworkProcess::getLocalStorageOriginDetails):
>+        * NetworkProcess/NetworkProcess.h:
>+        * NetworkProcess/NetworkProcess.messages.in:
>+        * NetworkProcess/NetworkSession.cpp:
>+        (WebKit::NetworkSession::NetworkSession):
>+        (WebKit::NetworkSession::~NetworkSession):
>+        * NetworkProcess/NetworkSession.h:
>+        (WebKit::NetworkSession::storageManager):
>+        * NetworkProcess/NetworkSessionCreationParameters.cpp:
>+        (WebKit::NetworkSessionCreationParameters::privateSessionParameters):
>+        (WebKit::NetworkSessionCreationParameters::encode const):
>+        (WebKit::NetworkSessionCreationParameters::decode):
>+        * NetworkProcess/NetworkSessionCreationParameters.h:
>+        * NetworkProcess/WebStorage/LocalStorageDatabase.cpp: Renamed from Source/WebKit/UIProcess/WebStorage/LocalStorageDatabase.cpp.
>+        (WebKit::LocalStorageDatabase::create):
>+        (WebKit::LocalStorageDatabase::LocalStorageDatabase):
>+        (WebKit::LocalStorageDatabase::~LocalStorageDatabase):
>+        (WebKit::LocalStorageDatabase::openDatabase):
>+        (WebKit::LocalStorageDatabase::tryToOpenDatabase):
>+        (WebKit::LocalStorageDatabase::migrateItemTableIfNeeded):
>+        (WebKit::LocalStorageDatabase::importItems):
>+        (WebKit::LocalStorageDatabase::setItem):
>+        (WebKit::LocalStorageDatabase::removeItem):
>+        (WebKit::LocalStorageDatabase::clear):
>+        (WebKit::LocalStorageDatabase::close):
>+        (WebKit::LocalStorageDatabase::itemDidChange):
>+        (WebKit::LocalStorageDatabase::scheduleDatabaseUpdate):
>+        (WebKit::LocalStorageDatabase::updateDatabase):
>+        (WebKit::LocalStorageDatabase::updateDatabaseWithChangedItems):
>+        (WebKit::LocalStorageDatabase::databaseIsEmpty):
>+        * NetworkProcess/WebStorage/LocalStorageDatabase.h: Renamed from Source/WebKit/UIProcess/WebStorage/LocalStorageDatabase.h.
>+        * NetworkProcess/WebStorage/LocalStorageDatabaseTracker.cpp: Renamed from Source/WebKit/UIProcess/WebStorage/LocalStorageDatabaseTracker.cpp.
>+        (WebKit::LocalStorageDatabaseTracker::create):
>+        (WebKit::LocalStorageDatabaseTracker::LocalStorageDatabaseTracker):
>+        (WebKit::LocalStorageDatabaseTracker::~LocalStorageDatabaseTracker):
>+        (WebKit::LocalStorageDatabaseTracker::databasePath const):
>+        (WebKit::LocalStorageDatabaseTracker::didOpenDatabaseWithOrigin):
>+        (WebKit::LocalStorageDatabaseTracker::deleteDatabaseWithOrigin):
>+        (WebKit::LocalStorageDatabaseTracker::deleteAllDatabases):
>+        (WebKit::LocalStorageDatabaseTracker::databasesModifiedSince):
>+        (WebKit::LocalStorageDatabaseTracker::origins const):
>+        (WebKit::LocalStorageDatabaseTracker::originDetails):
>+        * NetworkProcess/WebStorage/LocalStorageDatabaseTracker.h: Renamed from Source/WebKit/UIProcess/WebStorage/LocalStorageDatabaseTracker.h.
>+        (WebKit::LocalStorageDatabaseTracker::OriginDetails::encode const):
>+        (WebKit::LocalStorageDatabaseTracker::OriginDetails::decode):
>+        * NetworkProcess/WebStorage/StorageManager.cpp: Renamed from Source/WebKit/UIProcess/WebStorage/StorageManager.cpp.
>+        (WebKit::StorageManager::StorageArea::securityOrigin const):
>+        (WebKit::StorageManager::StorageArea::isSessionStorage const):
>+        (WebKit::StorageManager::LocalStorageNamespace::storageManager const):
>+        (WebKit::StorageManager::TransientLocalStorageNamespace::create):
>+        (WebKit::StorageManager::TransientLocalStorageNamespace::~TransientLocalStorageNamespace):
>+        (WebKit::StorageManager::TransientLocalStorageNamespace::getOrCreateStorageArea):
>+        (WebKit::StorageManager::TransientLocalStorageNamespace::origins const):
>+        (WebKit::StorageManager::TransientLocalStorageNamespace::clearStorageAreasMatchingOrigin):
>+        (WebKit::StorageManager::TransientLocalStorageNamespace::clearAllStorageAreas):
>+        (WebKit::StorageManager::TransientLocalStorageNamespace::TransientLocalStorageNamespace):
>+        (WebKit::StorageManager::StorageArea::create):
>+        (WebKit::StorageManager::StorageArea::StorageArea):
>+        (WebKit::StorageManager::StorageArea::~StorageArea):
>+        (WebKit::StorageManager::StorageArea::addListener):
>+        (WebKit::StorageManager::StorageArea::removeListener):
>+        (WebKit::StorageManager::StorageArea::hasListener const):
>+        (WebKit::StorageManager::StorageArea::clone const):
>+        (WebKit::StorageManager::StorageArea::setItem):
>+        (WebKit::StorageManager::StorageArea::removeItem):
>+        (WebKit::StorageManager::StorageArea::clear):
>+        (WebKit::StorageManager::StorageArea::items const):
>+        (WebKit::StorageManager::StorageArea::openDatabaseAndImportItemsIfNeeded const):
>+        (WebKit::StorageManager::StorageArea::dispatchEvents const):
>+        (WebKit::StorageManager::LocalStorageNamespace::create):
>+        (WebKit::StorageManager::LocalStorageNamespace::LocalStorageNamespace):
>+        (WebKit::StorageManager::LocalStorageNamespace::~LocalStorageNamespace):
>+        (WebKit::StorageManager::LocalStorageNamespace::getOrCreateStorageArea):
>+        (WebKit::StorageManager::LocalStorageNamespace::didDestroyStorageArea):
>+        (WebKit::StorageManager::LocalStorageNamespace::clearStorageAreasMatchingOrigin):
>+        (WebKit::StorageManager::LocalStorageNamespace::clearAllStorageAreas):
>+        (WebKit::StorageManager::SessionStorageNamespace::isEmpty const):
>+        (WebKit::StorageManager::SessionStorageNamespace::allowedConnections const):
>+        (WebKit::StorageManager::SessionStorageNamespace::origins const):
>+        (WebKit::StorageManager::SessionStorageNamespace::clearStorageAreasMatchingOrigin):
>+        (WebKit::StorageManager::SessionStorageNamespace::clearAllStorageAreas):
>+        (WebKit::StorageManager::SessionStorageNamespace::create):
>+        (WebKit::StorageManager::SessionStorageNamespace::SessionStorageNamespace):
>+        (WebKit::StorageManager::SessionStorageNamespace::~SessionStorageNamespace):
>+        (WebKit::StorageManager::SessionStorageNamespace::addAllowedConnection):
>+        (WebKit::StorageManager::SessionStorageNamespace::removeAllowedConnection):
>+        (WebKit::StorageManager::SessionStorageNamespace::getOrCreateStorageArea):
>+        (WebKit::StorageManager::SessionStorageNamespace::cloneTo):
>+        (WebKit::StorageManager::create):
>+        (WebKit::StorageManager::StorageManager):
>+        (WebKit::StorageManager::~StorageManager):
>+        (WebKit::StorageManager::createSessionStorageNamespace):
>+        (WebKit::StorageManager::destroySessionStorageNamespace):
>+        (WebKit::StorageManager::addAllowedSessionStorageNamespaceConnection):
>+        (WebKit::StorageManager::removeAllowedSessionStorageNamespaceConnection):
>+        (WebKit::StorageManager::cloneSessionStorageNamespace):
>+        (WebKit::StorageManager::processWillOpenConnection):
>+        (WebKit::StorageManager::processDidCloseConnection):
>+        (WebKit::StorageManager::getSessionStorageOrigins):
>+        (WebKit::StorageManager::deleteSessionStorageOrigins):
>+        (WebKit::StorageManager::deleteSessionStorageEntriesForOrigins):
>+        (WebKit::StorageManager::getLocalStorageOrigins):
>+        (WebKit::StorageManager::getLocalStorageOriginDetails):
>+        (WebKit::StorageManager::deleteLocalStorageEntriesForOrigin):
>+        (WebKit::StorageManager::deleteLocalStorageOriginsModifiedSince):
>+        (WebKit::StorageManager::deleteLocalStorageEntriesForOrigins):
>+        (WebKit::StorageManager::createLocalStorageMap):
>+        (WebKit::StorageManager::createTransientLocalStorageMap):
>+        (WebKit::StorageManager::createSessionStorageMap):
>+        (WebKit::StorageManager::destroyStorageMap):
>+        (WebKit::StorageManager::getValues):
>+        (WebKit::StorageManager::setItem):
>+        (WebKit::StorageManager::removeItem):
>+        (WebKit::StorageManager::clear):
>+        (WebKit::StorageManager::waitUntilWritesFinished):
>+        (WebKit::StorageManager::findStorageArea const):
>+        (WebKit::StorageManager::getOrCreateLocalStorageNamespace):
>+        (WebKit::StorageManager::getOrCreateTransientLocalStorageNamespace):
>+        (WebKit::StorageManager::dispatchMessageToQueue):
>+        (WebKit::StorageManager::dispatchSyncMessageToQueue):
>+        * NetworkProcess/WebStorage/StorageManager.h: Renamed from Source/WebKit/UIProcess/WebStorage/StorageManager.h.
>+        * NetworkProcess/WebStorage/StorageManager.messages.in: Renamed from Source/WebKit/UIProcess/WebStorage/StorageManager.messages.in.
>+        * NetworkProcess/WebStorage/ios/LocalStorageDatabaseTrackerIOS.mm: Copied from Source/WebKit/UIProcess/WebStorage/ios/LocalStorageDatabaseTrackerIOS.mm.
>+        (WebKit::LocalStorageDatabaseTracker::platformMaybeExcludeFromBackup const):
>+        * NetworkProcess/WebStorage/ios/LocalStorageDatabaseTrackerIOS.mm.orig: Renamed from Source/WebKit/UIProcess/WebStorage/ios/LocalStorageDatabaseTrackerIOS.mm.
>+        * NetworkProcess/cocoa/NetworkSessionCocoa.mm:
>+        (WebKit::NetworkSessionCocoa::NetworkSessionCocoa):
>+        * NetworkProcess/curl/NetworkSessionCurl.cpp:
>+        (WebKit::NetworkSessionCurl::NetworkSessionCurl):
>+        * NetworkProcess/soup/NetworkSessionSoup.cpp:
>+        (WebKit::NetworkSessionSoup::NetworkSessionSoup):
>+        * PlatformMac.cmake:
>+        * PlatformWin.cmake:
>+        * Shared/WebPageCreationParameters.cpp:
>+        (WebKit::WebPageCreationParameters::encode const):
>+        (WebKit::WebPageCreationParameters::decode):
>+        * Shared/WebPageCreationParameters.h:
>+        * Shared/WebsiteData/WebsiteData.cpp:
>+        (WebKit::WebsiteData::ownerProcess):
>+        * Sources.txt:
>+        * SourcesCocoa.txt:
>+        * SourcesGTK.txt:
>+        * SourcesWPE.txt:
>+        * UIProcess/API/C/WKKeyValueStorageManager.cpp:
>+        (WKKeyValueStorageManagerGetKeyValueStorageOrigins):
>+        (WKKeyValueStorageManagerGetStorageDetailsByOrigin):
>+        (WKKeyValueStorageManagerDeleteEntriesForOrigin):
>+        (WKKeyValueStorageManagerDeleteAllEntries):
>+        * UIProcess/Network/NetworkProcessProxy.cpp:
>+        (WebKit::NetworkProcessProxy::hasLocalStorage):
>+        (WebKit::NetworkProcessProxy::getLocalStorageDetails):
>+        * UIProcess/Network/NetworkProcessProxy.h:
>+        * UIProcess/WebPageProxy.cpp:
>+        (WebKit::WebPageProxy::createNewPage):
>+        * UIProcess/WebProcessPool.cpp:
>+        (WebKit::WebProcessPool::ensureNetworkProcess):
>+        * UIProcess/WebsiteData/Cocoa/WebsiteDataStoreCocoa.mm:
>+        (WebKit::WebsiteDataStore::parameters):
>+        (WebKit::WebsiteDataStore::platformInitialize):
>+        (WebKit::WebsiteDataStore::platformDestroy):
>+        * UIProcess/WebsiteData/WebsiteDataStore.cpp:
>+        (WebKit::WebsiteDataStore::WebsiteDataStore):
>+        (WebKit::computeNetworkProcessAccessTypeForDataFetch):
>+        (WebKit::WebsiteDataStore::fetchDataAndApply):
>+        (WebKit::WebsiteDataStore::removeData):
>+        (WebKit::WebsiteDataStore::hasLocalStorageForTesting const):
>+        (WebKit::WebsiteDataStore::parameters):
>+        (WebKit::WebsiteDataStore::getLocalStorageDetails):
>+        (WebKit::m_client): Deleted.
>+        (WebKit::WebsiteDataStore::cloneSessionData): Deleted.
>+        (WebKit::WebsiteDataStore::webPageWasAdded): Deleted.
>+        (WebKit::WebsiteDataStore::webPageWasInvalidated): Deleted.
>+        (WebKit::WebsiteDataStore::webProcessWillOpenConnection): Deleted.
>+        (WebKit::WebsiteDataStore::webPageWillOpenConnection): Deleted.
>+        (WebKit::WebsiteDataStore::webPageDidCloseConnection): Deleted.
>+        (WebKit::WebsiteDataStore::webProcessDidCloseConnection): Deleted.
>+        * UIProcess/WebsiteData/WebsiteDataStore.h:
>+        (WebKit::WebsiteDataStore::resolvedLocalStorageDirectory const):
>+        (WebKit::WebsiteDataStore::storageManager): Deleted.
>+        * WebKit.xcodeproj/project.pbxproj:
>+        * WebProcess/InjectedBundle/InjectedBundle.cpp:
>+        (WebKit::InjectedBundle::setPrivateBrowsingEnabled):
>+        * WebProcess/Network/NetworkProcessConnection.cpp:
>+        (WebKit::NetworkProcessConnection::didReceiveMessage):
>+        * WebProcess/WebCoreSupport/WebChromeClient.cpp:
>+        (WebKit::WebChromeClient::createWindow):
>+        * WebProcess/WebPage/WebPage.cpp:
>+        (WebKit::WebPage::close):
>+        * WebProcess/WebProcess.cpp:
>+        (WebKit::WebProcess::createWebPage):
>+        (WebKit::WebProcess::removeWebPage):
>+        (WebKit::WebProcess::ensureNetworkProcessConnection):
>+        (WebKit::WebProcess::networkProcessConnectionClosed):
>+        (WebKit::WebProcess::registerStorageAreaMap):
>+        (WebKit::WebProcess::unregisterStorageAreaMap):
>+        (WebKit::WebProcess::storageAreaMap const):
>+        (WebKit::WebProcess::setPrivateBrowsingEnabled):
>+        * WebProcess/WebProcess.h:
>+        * WebProcess/WebStorage/StorageAreaMap.cpp:
>+        (WebKit::StorageAreaMap::StorageAreaMap):
>+        (WebKit::StorageAreaMap::~StorageAreaMap):
>+        (WebKit::StorageAreaMap::setItem):
>+        (WebKit::StorageAreaMap::removeItem):
>+        (WebKit::StorageAreaMap::clear):
>+        (WebKit::StorageAreaMap::loadValuesIfNeeded):
>+        (WebKit::StorageAreaMap::connect):
>+        (WebKit::StorageAreaMap::disconnect):
>+        * WebProcess/WebStorage/StorageAreaMap.h:
>+        (WebKit::StorageAreaMap::identifier const):
>+
> 2019-05-14  Ross Kirsling  <ross.kirsling@sony.com>
> 
>         Unreviewed restoration of non-unified build.
>diff --git a/Source/WebKit/CMakeLists.txt b/Source/WebKit/CMakeLists.txt
>index 4b0bec7cb80056a8c1eab71123d81eb641c966de..831727c91b52343fb366d19821a2e330a8a2eb56 100644
>--- a/Source/WebKit/CMakeLists.txt
>+++ b/Source/WebKit/CMakeLists.txt
>@@ -20,6 +20,7 @@ set(WebKit_INCLUDE_DIRECTORIES
>     "${WEBKIT_DIR}/NetworkProcess/FileAPI"
>     "${WEBKIT_DIR}/NetworkProcess/IndexedDB"
>     "${WEBKIT_DIR}/NetworkProcess/ServiceWorker"
>+    "${WEBKIT_DIR}/NetworkProcess/WebStorage"
>     "${WEBKIT_DIR}/NetworkProcess/cache"
>     "${WEBKIT_DIR}/NetworkProcess/watchos"
>     "${WEBKIT_DIR}/NetworkProcess/webrtc"
>@@ -58,7 +59,6 @@ set(WebKit_INCLUDE_DIRECTORIES
>     "${WEBKIT_DIR}/UIProcess/UserContent"
>     "${WEBKIT_DIR}/UIProcess/WebAuthentication"
>     "${WEBKIT_DIR}/UIProcess/WebAuthentication/Mock"
>-    "${WEBKIT_DIR}/UIProcess/WebStorage"
>     "${WEBKIT_DIR}/UIProcess/WebsiteData"
>     "${WEBKIT_DIR}/WebProcess"
>     "${WEBKIT_DIR}/WebProcess/ApplePay"
>@@ -121,6 +121,8 @@ set(WebKit_MESSAGES_IN_FILES
>     NetworkProcess/ServiceWorker/WebSWServerConnection.messages.in
>     NetworkProcess/ServiceWorker/WebSWServerToContextConnection.messages.in
> 
>+    NetworkProcess/WebStorage/StorageManager.messages.in
>+
>     NetworkProcess/cache/CacheStorageEngineConnection.messages.in
> 
>     NetworkProcess/webrtc/NetworkMDNSRegister.messages.in
>@@ -161,8 +163,6 @@ set(WebKit_MESSAGES_IN_FILES
> 
>     UIProcess/UserContent/WebUserContentControllerProxy.messages.in
> 
>-    UIProcess/WebStorage/StorageManager.messages.in
>-
>     WebProcess/WebProcess.messages.in
> 
>     WebProcess/Automation/WebAutomationSessionProxy.messages.in
>diff --git a/Source/WebKit/DerivedSources.make b/Source/WebKit/DerivedSources.make
>index 8fbaf0e358be5dca7081b4579eb435b324143ed4..6ba0c9fd9a5a1ba7a8f17f666615be0386de43d5 100644
>--- a/Source/WebKit/DerivedSources.make
>+++ b/Source/WebKit/DerivedSources.make
>@@ -30,6 +30,7 @@ VPATH = \
>     $(WebKit2)/NetworkProcess/webrtc \
>     $(WebKit2)/NetworkProcess/IndexedDB \
>     $(WebKit2)/NetworkProcess/ServiceWorker \
>+    $(WebKit2)/NetworkProcess/WebStorage \
>     $(WebKit2)/PluginProcess \
>     $(WebKit2)/PluginProcess/mac \
>     $(WebKit2)/Shared/Plugins \
>@@ -79,7 +80,6 @@ VPATH = \
>     $(WebKit2)/UIProcess/Storage \
>     $(WebKit2)/UIProcess/UserContent \
>     $(WebKit2)/UIProcess/WebAuthentication \
>-    $(WebKit2)/UIProcess/WebStorage \
>     $(WebKit2)/UIProcess/mac \
>     $(WebKit2)/UIProcess/ios \
>     $(WEBKITADDITIONS_HEADER_SEARCH_PATHS) \
>diff --git a/Source/WebKit/NetworkProcess/NetworkConnectionToWebProcess.cpp b/Source/WebKit/NetworkProcess/NetworkConnectionToWebProcess.cpp
>index e9c98f2e2227fe1c5251770d060d2ed2e3ccde5b..e49db68c4ce1d3316f944150cec74c18cf5932c3 100644
>--- a/Source/WebKit/NetworkProcess/NetworkConnectionToWebProcess.cpp
>+++ b/Source/WebKit/NetworkProcess/NetworkConnectionToWebProcess.cpp
>@@ -46,6 +46,8 @@
> #include "PingLoad.h"
> #include "PreconnectTask.h"
> #include "ServiceWorkerFetchTaskMessages.h"
>+#include "StorageManager.h"
>+#include "StorageManagerMessages.h"
> #include "WebCoreArgumentCoders.h"
> #include "WebErrors.h"
> #include "WebIDBConnectionToClient.h"
>@@ -222,6 +224,13 @@ void NetworkConnectionToWebProcess::didReceiveMessage(IPC::Connection& connectio
>     if (decoder.messageReceiverName() == Messages::WebPaymentCoordinatorProxy::messageReceiverName())
>         return paymentCoordinator().didReceiveMessage(connection, decoder);
> #endif
>+    
>+    if (decoder.messageReceiverName() == Messages::StorageManager::messageReceiverName()) {
>+        if (auto* session = m_networkProcess->networkSessionByConnection(connection)) {
>+            session->storageManager().dispatchMessageToQueue(connection, decoder);
>+            return;
>+        }
>+    }
> 
>     ASSERT_NOT_REACHED();
> }
>@@ -262,6 +271,13 @@ void NetworkConnectionToWebProcess::didReceiveSyncMessage(IPC::Connection& conne
>         return paymentCoordinator().didReceiveSyncMessage(connection, decoder, reply);
> #endif
> 
>+    if (decoder.messageReceiverName() == Messages::StorageManager::messageReceiverName()) {
>+        if (auto* session = m_networkProcess->networkSessionByConnection(connection)) {
>+            session->storageManager().dispatchSyncMessageToQueue(connection, decoder, reply);
>+            return;
>+        }
>+    }
>+        
>     ASSERT_NOT_REACHED();
> }
> 
>@@ -288,6 +304,8 @@ void NetworkConnectionToWebProcess::didClose(IPC::Connection& connection)
>     // root activity trackers.
>     stopAllNetworkActivityTracking();
> 
>+    m_networkProcess->webProcessWasDisconnected(connection);
>+
>     m_networkProcess->networkBlobRegistry().connectionToWebProcessDidClose(*this);
>     m_networkProcess->removeNetworkConnectionToWebProcess(*this);
> 
>@@ -877,4 +895,19 @@ void NetworkConnectionToWebProcess::clearConnectionHasUploads()
>     m_networkProcess->parentProcessConnection()->send(Messages::WebProcessPool::ClearWebProcessHasUploads(m_webProcessIdentifier), 0);
> }
> 
>+void NetworkConnectionToWebProcess::webPageWasAdded(PAL::SessionID sessionID, uint64_t pageID, uint64_t oldPageID)
>+{
>+    m_networkProcess->webPageWasAdded(m_connection.get(), sessionID, pageID, oldPageID);
>+}
>+
>+void NetworkConnectionToWebProcess::webPageWasRemoved(PAL::SessionID sessionID, uint64_t pageID)
>+{
>+    m_networkProcess->webPageWasRemoved(m_connection.get(), sessionID, pageID);
>+}
>+
>+void NetworkConnectionToWebProcess::webProcessSessionChanged(PAL::SessionID newSessionID, const Vector<uint64_t>& pages)
>+{
>+    m_networkProcess->webProcessSessionChanged(m_connection.get(), newSessionID, pages);
>+}
>+
> } // namespace WebKit
>diff --git a/Source/WebKit/NetworkProcess/NetworkConnectionToWebProcess.h b/Source/WebKit/NetworkProcess/NetworkConnectionToWebProcess.h
>index 0903a164589da1954ce63fc31bed20beb21aed87..cbc7bbfe8f57d75413158104f88a54400942076b 100644
>--- a/Source/WebKit/NetworkProcess/NetworkConnectionToWebProcess.h
>+++ b/Source/WebKit/NetworkProcess/NetworkConnectionToWebProcess.h
>@@ -144,6 +144,10 @@ public:
>     void setConnectionHasUploads();
>     void clearConnectionHasUploads();
> 
>+    void webPageWasAdded(PAL::SessionID, uint64_t pageID, uint64_t oldPageID);
>+    void webPageWasRemoved(PAL::SessionID, uint64_t pageID);
>+    void webProcessSessionChanged(PAL::SessionID newSessionID, const Vector<uint64_t>& pages);
>+
> private:
>     NetworkConnectionToWebProcess(NetworkProcess&, IPC::Connection::Identifier);
> 
>diff --git a/Source/WebKit/NetworkProcess/NetworkConnectionToWebProcess.messages.in b/Source/WebKit/NetworkProcess/NetworkConnectionToWebProcess.messages.in
>index fd848e3ad046c80c3ae3f46d39015a02f003c951..f7c97eebb213cd783caf4e20469bfa3ce194c8ce 100644
>--- a/Source/WebKit/NetworkProcess/NetworkConnectionToWebProcess.messages.in
>+++ b/Source/WebKit/NetworkProcess/NetworkConnectionToWebProcess.messages.in
>@@ -86,4 +86,8 @@ messages -> NetworkConnectionToWebProcess LegacyReceiver {
> #endif
> 
>     SetWebProcessIdentifier(WebCore::ProcessIdentifier processIdentifier)
>+
>+    WebPageWasAdded(PAL::SessionID sessionID, uint64_t pageID, uint64_t oldPageID)
>+    WebPageWasRemoved(PAL::SessionID sessionID, uint64_t pageID)
>+    WebProcessSessionChanged(PAL::SessionID newSessionID, Vector<uint64_t> pages)
> }
>diff --git a/Source/WebKit/NetworkProcess/NetworkProcess.cpp b/Source/WebKit/NetworkProcess/NetworkProcess.cpp
>index 9c6484449c6ba27503c8bc05c70709b3e43f8943..1aa8b46312ba6d5eee0b0670c9e7083b869121e9 100644
>--- a/Source/WebKit/NetworkProcess/NetworkProcess.cpp
>+++ b/Source/WebKit/NetworkProcess/NetworkProcess.cpp
>@@ -53,6 +53,8 @@
> #include "ShouldGrandfatherStatistics.h"
> #include "StatisticsData.h"
> #include "StorageAccessStatus.h"
>+#include "StorageManager.h"
>+#include "StorageManagerMessages.h"
> #include "WebCookieManager.h"
> #include "WebPageProxyMessages.h"
> #include "WebProcessPoolMessages.h"
>@@ -560,6 +562,14 @@ NetworkSession* NetworkProcess::networkSession(const PAL::SessionID& sessionID)
>     return m_networkSessions.get(sessionID);
> }
> 
>+NetworkSession* NetworkProcess::networkSessionByConnection(IPC::Connection& connection) const
>+{
>+    if (!m_sessionByConnection.contains(connection.uniqueID()))
>+        return nullptr;
>+
>+    return networkSession(m_sessionByConnection.get(connection.uniqueID()));
>+}
>+
> void NetworkProcess::setSession(const PAL::SessionID& sessionID, Ref<NetworkSession>&& session)
> {
>     m_networkSessions.set(sessionID, WTFMove(session));
>@@ -1011,6 +1021,19 @@ void NetworkProcess::clearUserInteraction(PAL::SessionID sessionID, const Regist
>     }
> }
> 
>+void NetworkProcess::hasLocalStorage(PAL::SessionID sessionID, const RegistrableDomain& domain, CompletionHandler<void(bool)>&& completionHandler)
>+{
>+    if (auto* session = networkSession(sessionID)) {
>+        session->storageManager().getLocalStorageOrigins([domain, completionHandler = WTFMove(completionHandler)](auto&& origins) mutable {
>+            completionHandler(WTF::anyOf(origins, [&domain](auto& origin) {
>+                return RegistrableDomain::uncheckedCreateFromHost(origin.host) == domain;
>+            }));
>+        });
>+        return;
>+    }
>+    completionHandler(false);
>+}
>+
> void NetworkProcess::removePrevalentDomains(PAL::SessionID sessionID, const Vector<RegistrableDomain>& domains)
> {
>     if (auto* networkStorageSession = storageSession(sessionID))
>@@ -1260,6 +1283,22 @@ void NetworkProcess::fetchWebsiteData(PAL::SessionID sessionID, OptionSet<Websit
>         });
>     }
> 
>+    auto* session = networkSession(sessionID);
>+    if (websiteDataTypes.contains(WebsiteDataType::SessionStorage) && session) {
>+        session->storageManager().getSessionStorageOrigins([callbackAggregator = callbackAggregator.copyRef()](auto&& origins) {
>+            while (!origins.isEmpty())
>+                callbackAggregator->m_websiteData.entries.append(WebsiteData::Entry { origins.takeAny(), WebsiteDataType::SessionStorage, 0 });
>+        });
>+    }
>+    
>+    if (websiteDataTypes.contains(WebsiteDataType::LocalStorage) && session) {
>+        session->storageManager().getLocalStorageOrigins([callbackAggregator = callbackAggregator.copyRef()](auto&& origins) {
>+            while (!origins.isEmpty())
>+                callbackAggregator->m_websiteData.entries.append(WebsiteData::Entry { origins.takeAny(), WebsiteDataType::LocalStorage, 0 });
>+        });
>+    }
>+
>+
> #if PLATFORM(COCOA)
>     if (websiteDataTypes.contains(WebsiteDataType::HSTSCache)) {
>         if (auto* networkStorageSession = storageSession(sessionID))
>@@ -1323,6 +1362,13 @@ void NetworkProcess::deleteWebsiteData(PAL::SessionID sessionID, OptionSet<Websi
>     if (websiteDataTypes.contains(WebsiteDataType::DOMCache))
>         CacheStorage::Engine::clearAllCaches(*this, sessionID, [clearTasksHandler = clearTasksHandler.copyRef()] { });
> 
>+    auto* session = networkSession(sessionID);
>+    if (websiteDataTypes.contains(WebsiteDataType::SessionStorage) && session)
>+        session->storageManager().deleteSessionStorageOrigins([clearTasksHandler = clearTasksHandler.copyRef()] { });
>+    
>+    if (websiteDataTypes.contains(WebsiteDataType::LocalStorage) && session)
>+        session->storageManager().deleteLocalStorageOriginsModifiedSince(modifiedSince, [clearTasksHandler = clearTasksHandler.copyRef()] { });
>+
> #if ENABLE(INDEXED_DATABASE)
>     if (websiteDataTypes.contains(WebsiteDataType::IndexedDBDatabases) && !sessionID.isEphemeral())
>         idbServer(sessionID).closeAndDeleteDatabasesModifiedSince(modifiedSince, [clearTasksHandler = clearTasksHandler.copyRef()] { });
>@@ -1416,6 +1462,13 @@ void NetworkProcess::deleteWebsiteDataForOrigins(PAL::SessionID sessionID, Optio
>             CacheStorage::Engine::clearCachesForOrigin(*this, sessionID, SecurityOriginData { originData }, [clearTasksHandler = clearTasksHandler.copyRef()] { });
>     }
> 
>+    auto* session = networkSession(sessionID);
>+    if (websiteDataTypes.contains(WebsiteDataType::SessionStorage) && session)
>+        session->storageManager().deleteSessionStorageEntriesForOrigins(originDatas, [clearTasksHandler = clearTasksHandler.copyRef()] { });
>+    
>+    if (websiteDataTypes.contains(WebsiteDataType::LocalStorage) && session)
>+        session->storageManager().deleteLocalStorageEntriesForOrigins(originDatas, [clearTasksHandler = clearTasksHandler.copyRef()] { });
>+
> #if ENABLE(INDEXED_DATABASE)
>     if (websiteDataTypes.contains(WebsiteDataType::IndexedDBDatabases) && !sessionID.isEphemeral())
>         idbServer(sessionID).closeAndDeleteDatabasesForOrigins(originDatas, [clearTasksHandler = clearTasksHandler.copyRef()] { });
>@@ -1476,6 +1529,20 @@ static Vector<WebsiteData::Entry> filterForRegistrableDomains(const Vector<Regis
>     return result;
> }
> 
>+static Vector<WebCore::SecurityOriginData> filterForRegistrableDomains(const HashSet<WebCore::SecurityOriginData>& origins, const Vector<RegistrableDomain>& domainsToDelete, HashSet<RegistrableDomain>& domainsDeleted)
>+{
>+    Vector<SecurityOriginData> originsDeleted;
>+    for (const auto& origin : origins) {
>+        auto domain = RegistrableDomain::uncheckedCreateFromHost(origin.host);
>+        if (!domainsToDelete.contains(domain))
>+            continue;
>+        originsDeleted.append(origin);
>+        domainsDeleted.add(domain);
>+    }
>+
>+    return originsDeleted;
>+}
>+
> void NetworkProcess::deleteWebsiteDataForRegistrableDomains(PAL::SessionID sessionID, OptionSet<WebsiteDataType> websiteDataTypes, HashMap<RegistrableDomain, WebsiteDataToRemove>&& domains, bool shouldNotifyPage, CompletionHandler<void(const HashSet<RegistrableDomain>&)>&& completionHandler)
> {
>     OptionSet<WebsiteDataFetchOption> fetchOptions = WebsiteDataFetchOption::DoNotCreateProcesses;
>@@ -1584,7 +1651,25 @@ void NetworkProcess::deleteWebsiteDataForRegistrableDomains(PAL::SessionID sessi
>                 CacheStorage::Engine::clearCachesForOrigin(*this, sessionID, SecurityOriginData { entry.origin }, [callbackAggregator = callbackAggregator.copyRef()] { });
>         });
>     }
>-    
>+
>+    auto* session = networkSession(sessionID);
>+    if (session) {
>+        auto& storageManager = session->storageManager();
>+        if (websiteDataTypes.contains(WebsiteDataType::SessionStorage)) {
>+            storageManager.getSessionStorageOrigins([storageManager = makeRefPtr(storageManager), callbackAggregator = callbackAggregator.copyRef(), domainsToDeleteAllButCookiesFor](auto&& origins) {
>+                auto originsToDelete = filterForRegistrableDomains(origins, domainsToDeleteAllButCookiesFor, callbackAggregator->m_domains);
>+                storageManager->deleteSessionStorageEntriesForOrigins(originsToDelete, [callbackAggregator = callbackAggregator.copyRef()] { });
>+            });
>+        }
>+        
>+        if (websiteDataTypes.contains(WebsiteDataType::LocalStorage)) {
>+            storageManager.getLocalStorageOrigins([storageManager = makeRefPtr(storageManager), callbackAggregator = callbackAggregator.copyRef(), domainsToDeleteAllButCookiesFor](auto&& origins) {
>+                auto originsToDelete = filterForRegistrableDomains(origins, domainsToDeleteAllButCookiesFor, callbackAggregator->m_domains);
>+                storageManager->deleteLocalStorageEntriesForOrigins(originsToDelete, [callbackAggregator = callbackAggregator.copyRef()] { });
>+            });
>+        }
>+    }
>+
> #if ENABLE(INDEXED_DATABASE)
>     auto path = m_idbDatabasePaths.get(sessionID);
>     if (!path.isEmpty() && websiteDataTypes.contains(WebsiteDataType::IndexedDBDatabases)) {
>@@ -2535,4 +2620,75 @@ void NetworkProcess::removeKeptAliveLoad(NetworkResourceLoader& loader)
>         session->removeKeptAliveLoad(loader);
> }
> 
>+void NetworkProcess::webPageWasAdded(IPC::Connection& connection, PAL::SessionID sessionID, uint64_t pageID, uint64_t oldPageID)
>+{
>+    auto* session = networkSession(sessionID);
>+    if (!session) {
>+        LOG_ERROR("Cannot add page to an unknown session");
>+        return;
>+    }
>+    auto& storageManager = session->storageManager();
>+
>+    auto connectionID = connection.uniqueID();
>+
>+    m_sessionByConnection.ensure(connectionID, [&]() {
>+        storageManager.processWillOpenConnection(connection);
>+        return sessionID;
>+    });
>+    ASSERT(m_sessionByConnection.get(connectionID) == sessionID);
>+
>+    storageManager.createSessionStorageNamespace(pageID, std::numeric_limits<unsigned>::max());
>+    storageManager.addAllowedSessionStorageNamespaceConnection(pageID, connection);
>+    if (pageID != oldPageID)
>+        storageManager.cloneSessionStorageNamespace(oldPageID, pageID);
>+}
>+
>+void NetworkProcess::webPageWasRemoved(IPC::Connection& connection, PAL::SessionID sessionID, uint64_t pageID)
>+{
>+    auto* session = networkSession(sessionID);
>+    if (!session) {
>+        LOG_ERROR("Cannot remove page from an unknown session");
>+        return;
>+    }
>+
>+    auto& storageManager = session->storageManager();
>+    storageManager.removeAllowedSessionStorageNamespaceConnection(pageID, connection);
>+    storageManager.destroySessionStorageNamespace(pageID);
>+}
>+
>+void NetworkProcess::webProcessWasDisconnected(IPC::Connection& connection)
>+{
>+    auto connectionID = connection.uniqueID();
>+    if (!m_sessionByConnection.contains(connectionID))
>+        return;
>+
>+    networkSession(m_sessionByConnection.take(connectionID))->storageManager().processDidCloseConnection(connection);
>+}
>+
>+void NetworkProcess::webProcessSessionChanged(IPC::Connection& connection, PAL::SessionID newSessionID, const Vector<uint64_t>& pageIDs)
>+{
>+    auto connectionID = connection.uniqueID();
>+    ASSERT(m_sessionByConnection.contains(connectionID));
>+    if (m_sessionByConnection.get(connectionID) == newSessionID)
>+        return;
>+
>+    webProcessWasDisconnected(connection);
>+    for (auto& pageID : pageIDs)
>+        webPageWasAdded(connection, newSessionID, pageID, pageID);
>+}
>+
>+void NetworkProcess::getLocalStorageOriginDetails(PAL::SessionID sessionID, CompletionHandler<void(Vector<LocalStorageDatabaseTracker::OriginDetails>)>&& completionHandler)
>+{
>+    auto* session = networkSession(sessionID);
>+    if (!session) {
>+        LOG_ERROR("Cannot get local storage information for an unknown session");
>+        return;
>+    }
>+
>+    auto& storageManager = session->storageManager();
>+    storageManager.getLocalStorageOriginDetails([completionHandler = WTFMove(completionHandler)](auto details) mutable {
>+        completionHandler(details);
>+    });
>+}
>+
> } // namespace WebKit
>diff --git a/Source/WebKit/NetworkProcess/NetworkProcess.h b/Source/WebKit/NetworkProcess/NetworkProcess.h
>index d8563d22ab4f9c31ed5cf1943c53d15bd42abbeb..87b9faa0aa913ab92deb13b89ef0689ec4da5f7f 100644
>--- a/Source/WebKit/NetworkProcess/NetworkProcess.h
>+++ b/Source/WebKit/NetworkProcess/NetworkProcess.h
>@@ -28,6 +28,7 @@
> #include "AuxiliaryProcess.h"
> #include "CacheModel.h"
> #include "DownloadManager.h"
>+#include "LocalStorageDatabaseTracker.h"
> #include "NetworkBlobRegistry.h"
> #include "NetworkContentRuleListManager.h"
> #include "NetworkHTTPSUpgradeChecker.h"
>@@ -164,6 +165,7 @@ public:
> 
>     void setSession(const PAL::SessionID&, Ref<NetworkSession>&&);
>     NetworkSession* networkSession(const PAL::SessionID&) const override;
>+    NetworkSession* networkSessionByConnection(IPC::Connection&) const;
>     void destroySession(const PAL::SessionID&);
> 
>     // Needed for test infrastructure
>@@ -227,6 +229,7 @@ public:
>     void setVeryPrevalentResource(PAL::SessionID, const RegistrableDomain&, CompletionHandler<void()>&&);
>     void setPruneEntriesDownTo(PAL::SessionID, uint64_t pruneTargetCount, CompletionHandler<void()>&&);
>     void hadUserInteraction(PAL::SessionID, const RegistrableDomain&, CompletionHandler<void(bool)>&&);
>+    void hasLocalStorage(PAL::SessionID, const RegistrableDomain&, CompletionHandler<void(bool)>&&);
>     void getAllStorageAccessEntries(PAL::SessionID, CompletionHandler<void(Vector<String> domains)>&&);
>     void logFrameNavigation(PAL::SessionID, const NavigatedToDomain&, const TopFrameDomain&, const NavigatedFromDomain&, bool isRedirect, bool isMainFrame);
>     void logUserInteraction(PAL::SessionID, const TopFrameDomain&, CompletionHandler<void()>&&);
>@@ -268,6 +271,12 @@ public:
>     void setSessionIsControlledByAutomation(PAL::SessionID, bool);
>     bool sessionIsControlledByAutomation(PAL::SessionID) const;
> 
>+    void webPageWasAdded(IPC::Connection&, PAL::SessionID, uint64_t pageID, uint64_t oldPageID);
>+    void webPageWasRemoved(IPC::Connection&, PAL::SessionID, uint64_t pageID);
>+    void webProcessWasDisconnected(IPC::Connection&);
>+    void webProcessSessionChanged(IPC::Connection&, PAL::SessionID, const Vector<uint64_t>&);
>+    void getLocalStorageOriginDetails(PAL::SessionID, CompletionHandler<void(Vector<LocalStorageDatabaseTracker::OriginDetails>)>&&);
>+
> #if ENABLE(CONTENT_EXTENSIONS)
>     NetworkContentRuleListManager& networkContentRuleListManager() { return m_networkContentRuleListManager; }
> #endif
>@@ -558,6 +567,8 @@ private:
>     };
>     HashMap<PAL::SessionID, StorageQuotaManagers> m_storageQuotaManagers;
>     uint32_t m_downloadMonitorSpeedMultiplier { 1 };
>+
>+    HashMap<IPC::Connection::UniqueID, PAL::SessionID> m_sessionByConnection;
> };
> 
> } // namespace WebKit
>diff --git a/Source/WebKit/NetworkProcess/NetworkProcess.messages.in b/Source/WebKit/NetworkProcess/NetworkProcess.messages.in
>index 35bc82b28f1f7e8e2641a3421f24706de22ac5f9..79581994a23767925a5c6b80759bfe2a73ca9c27 100644
>--- a/Source/WebKit/NetworkProcess/NetworkProcess.messages.in
>+++ b/Source/WebKit/NetworkProcess/NetworkProcess.messages.in
>@@ -98,6 +98,7 @@ messages -> NetworkProcess LegacyReceiver {
>     SetPrevalentResource(PAL::SessionID sessionID, WebCore::RegistrableDomain resourceDomain) -> () Async
>     SetPrevalentResourceForDebugMode(PAL::SessionID sessionID, WebCore::RegistrableDomain resourceDomain) -> () Async
>     HadUserInteraction(PAL::SessionID sessionID, WebCore::RegistrableDomain resourceDomain) -> (bool hadUserInteraction) Async
>+    HasLocalStorage(PAL::SessionID sessionID, WebCore::RegistrableDomain resourceDomain) -> (bool hadUserInteraction) Async
>     GetAllStorageAccessEntries(PAL::SessionID sessionID) -> (Vector<String> domains) Async
>     IsRegisteredAsRedirectingTo(PAL::SessionID sessionID, WebCore::RegistrableDomain redirectedFromDomain, WebCore::RegistrableDomain redirectedToDomain) -> (bool isRedirectingTo) Async
>     IsRegisteredAsSubFrameUnder(PAL::SessionID sessionID, WebCore::RegistrableDomain subFrameDomain, WebCore::RegistrableDomain topFrameDomain) -> (bool isSubframeUnder) Async
>@@ -169,4 +170,5 @@ messages -> NetworkProcess LegacyReceiver {
>     MarkAdClickAttributionsAsExpiredForTesting(PAL::SessionID sessionID) -> () Async
>     OriginsWithPersistentCredentials() -> (Vector<WebCore::SecurityOriginData> origins) Async
>     RemoveCredentialsWithOrigins(Vector<WebCore::SecurityOriginData> origins) -> () Async
>+    GetLocalStorageOriginDetails(PAL::SessionID sessionID) -> (Vector<WebKit::LocalStorageDatabaseTracker::OriginDetails> details) Async
> }
>diff --git a/Source/WebKit/NetworkProcess/NetworkSession.cpp b/Source/WebKit/NetworkProcess/NetworkSession.cpp
>index 9d354b1aa80622d76383eef36f6f90b48fbcf10e..94a123700e5f1709995439e29cb5f7c42b8ddd88 100644
>--- a/Source/WebKit/NetworkProcess/NetworkSession.cpp
>+++ b/Source/WebKit/NetworkProcess/NetworkSession.cpp
>@@ -32,6 +32,7 @@
> #include "NetworkResourceLoadParameters.h"
> #include "NetworkResourceLoader.h"
> #include "PingLoad.h"
>+#include "StorageManager.h"
> #include "WebPageProxy.h"
> #include "WebPageProxyMessages.h"
> #include "WebProcessProxy.h"
>@@ -72,11 +73,13 @@ NetworkStorageSession& NetworkSession::networkStorageSession() const
>     return *storageSession;
> }
> 
>-NetworkSession::NetworkSession(NetworkProcess& networkProcess, PAL::SessionID sessionID)
>+NetworkSession::NetworkSession(NetworkProcess& networkProcess, PAL::SessionID sessionID, const String& localStorageDirectory, SandboxExtension::Handle& handle)
>     : m_sessionID(sessionID)
>     , m_networkProcess(networkProcess)
>     , m_adClickAttribution(makeUniqueRef<AdClickAttributionManager>(sessionID))
>+    , m_storageManager(StorageManager::create(localStorageDirectory))
> {
>+    SandboxExtension::consumePermanently(handle);
>     m_adClickAttribution->setPingLoadFunction([this, weakThis = makeWeakPtr(this)](NetworkResourceLoadParameters&& loadParameters, CompletionHandler<void(const WebCore::ResourceError&, const WebCore::ResourceResponse&)>&& completionHandler) {
>         if (!weakThis)
>             return;
>@@ -87,6 +90,7 @@ NetworkSession::NetworkSession(NetworkProcess& networkProcess, PAL::SessionID se
> 
> NetworkSession::~NetworkSession()
> {
>+    m_storageManager->waitUntilWritesFinished();
> }
> 
> void NetworkSession::invalidateAndCancel()
>diff --git a/Source/WebKit/NetworkProcess/NetworkSession.h b/Source/WebKit/NetworkProcess/NetworkSession.h
>index 2205a998a184ce58aee799d8242e6fbcdbcb353f..7d07400b6d51719ee8fbe7dae4ef84a2f9012794 100644
>--- a/Source/WebKit/NetworkProcess/NetworkSession.h
>+++ b/Source/WebKit/NetworkProcess/NetworkSession.h
>@@ -26,6 +26,7 @@
> #pragma once
> 
> #include "PrefetchCache.h"
>+#include "SandboxExtension.h"
> #include "WebResourceLoadStatisticsStore.h"
> #include <WebCore/AdClickAttribution.h>
> #include <WebCore/RegistrableDomain.h>
>@@ -51,6 +52,7 @@ class AdClickAttributionManager;
> class NetworkDataTask;
> class NetworkProcess;
> class NetworkResourceLoader;
>+class StorageManager;
> class WebResourceLoadStatisticsStore;
> struct NetworkSessionCreationParameters;
> 
>@@ -72,6 +74,8 @@ public:
> 
>     void registerNetworkDataTask(NetworkDataTask& task) { m_dataTaskSet.add(&task); }
>     void unregisterNetworkDataTask(NetworkDataTask& task) { m_dataTaskSet.remove(&task); }
>+    
>+    StorageManager& storageManager() { return *m_storageManager; }
> 
> #if ENABLE(RESOURCE_LOAD_STATISTICS)
>     WebResourceLoadStatisticsStore* resourceLoadStatistics() const { return m_resourceLoadStatistics.get(); }
>@@ -98,7 +102,7 @@ public:
>     void clearPrefetchCache() { m_prefetchCache.clear(); }
> 
> protected:
>-    NetworkSession(NetworkProcess&, PAL::SessionID);
>+    NetworkSession(NetworkProcess&, PAL::SessionID, const String& localStorageDirectory, SandboxExtension::Handle&);
> 
>     PAL::SessionID m_sessionID;
>     Ref<NetworkProcess> m_networkProcess;
>@@ -115,6 +119,8 @@ protected:
>     HashSet<Ref<NetworkResourceLoader>> m_keptAliveLoads;
> 
>     PrefetchCache m_prefetchCache;
>+
>+    RefPtr<StorageManager> m_storageManager;
> };
> 
> } // namespace WebKit
>diff --git a/Source/WebKit/NetworkProcess/NetworkSessionCreationParameters.cpp b/Source/WebKit/NetworkProcess/NetworkSessionCreationParameters.cpp
>index 3a9982677aae54d0bb2eb74c80371f3fcaf3d0e7..ce4f1d9011cb344ac4df29fa05243b9561477e72 100644
>--- a/Source/WebKit/NetworkProcess/NetworkSessionCreationParameters.cpp
>+++ b/Source/WebKit/NetworkProcess/NetworkSessionCreationParameters.cpp
>@@ -50,7 +50,7 @@ NetworkSessionCreationParameters NetworkSessionCreationParameters::privateSessio
> #if USE(CURL)
>         , { }, { }
> #endif
>-        , { }, { }, false
>+        , { }, { }, false, { }, { }, { }, { }, { }
>     };
> }
> 
>@@ -83,6 +83,8 @@ void NetworkSessionCreationParameters::encode(IPC::Encoder& encoder) const
>     encoder << shouldIncludeLocalhostInResourceLoadStatistics;
>     encoder << enableResourceLoadStatisticsDebugMode;
>     encoder << resourceLoadStatisticsManualPrevalentResource;
>+
>+    encoder << localStorageDirectory <<  localStorageDirectoryExtensionHandle;
> }
> 
> Optional<NetworkSessionCreationParameters> NetworkSessionCreationParameters::decode(IPC::Decoder& decoder)
>@@ -195,6 +197,16 @@ Optional<NetworkSessionCreationParameters> NetworkSessionCreationParameters::dec
>     decoder >> resourceLoadStatisticsManualPrevalentResource;
>     if (!resourceLoadStatisticsManualPrevalentResource)
>         return WTF::nullopt;
>+    
>+    Optional<String> localStorageDirectory;
>+    decoder >> localStorageDirectory;
>+    if (!localStorageDirectory)
>+        return WTF::nullopt;
>+    
>+    Optional<SandboxExtension::Handle> localStorageDirectoryExtensionHandle;
>+    decoder >> localStorageDirectoryExtensionHandle;
>+    if (!localStorageDirectoryExtensionHandle)
>+        return WTF::nullopt;
> 
>     return {{
>         sessionID
>@@ -224,6 +236,8 @@ Optional<NetworkSessionCreationParameters> NetworkSessionCreationParameters::dec
>         , WTFMove(*shouldIncludeLocalhostInResourceLoadStatistics)
>         , WTFMove(*enableResourceLoadStatisticsDebugMode)
>         , WTFMove(*resourceLoadStatisticsManualPrevalentResource)
>+        , WTFMove(*localStorageDirectory)
>+        , WTFMove(*localStorageDirectoryExtensionHandle)
>     }};
> }
> 
>diff --git a/Source/WebKit/NetworkProcess/NetworkSessionCreationParameters.h b/Source/WebKit/NetworkProcess/NetworkSessionCreationParameters.h
>index be9820ce377be71501e7dc85f6509b2feb47a9d4..6fc07aed24b40a67daf4c176e4f7dbf15b0b70c5 100644
>--- a/Source/WebKit/NetworkProcess/NetworkSessionCreationParameters.h
>+++ b/Source/WebKit/NetworkProcess/NetworkSessionCreationParameters.h
>@@ -87,6 +87,9 @@ struct NetworkSessionCreationParameters {
>     bool shouldIncludeLocalhostInResourceLoadStatistics { true };
>     bool enableResourceLoadStatisticsDebugMode { false };
>     WebCore::RegistrableDomain resourceLoadStatisticsManualPrevalentResource { };
>+
>+    String localStorageDirectory;
>+    SandboxExtension::Handle localStorageDirectoryExtensionHandle;
> };
> 
> } // namespace WebKit
>diff --git a/Source/WebKit/NetworkProcess/WebStorage/LocalStorageDatabase.cpp b/Source/WebKit/NetworkProcess/WebStorage/LocalStorageDatabase.cpp
>new file mode 100644
>index 0000000000000000000000000000000000000000..46fb6c77294f3c631d4fffdfc24a148f708a44ce
>--- /dev/null
>+++ b/Source/WebKit/NetworkProcess/WebStorage/LocalStorageDatabase.cpp
>@@ -0,0 +1,366 @@
>+/*
>+ * Copyright (C) 2008, 2009, 2010, 2013 Apple Inc. All rights reserved.
>+ *
>+ * Redistribution and use in source and binary forms, with or without
>+ * modification, are permitted provided that the following conditions
>+ * are met:
>+ * 1. Redistributions of source code must retain the above copyright
>+ *    notice, this list of conditions and the following disclaimer.
>+ * 2. Redistributions in binary form must reproduce the above copyright
>+ *    notice, this list of conditions and the following disclaimer in the
>+ *    documentation and/or other materials provided with the distribution.
>+ *
>+ * THIS SOFTWARE IS PROVIDED BY APPLE INC. AND ITS CONTRIBUTORS ``AS IS''
>+ * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO,
>+ * THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
>+ * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL APPLE INC. OR ITS CONTRIBUTORS
>+ * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
>+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
>+ * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
>+ * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
>+ * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
>+ * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF
>+ * THE POSSIBILITY OF SUCH DAMAGE.
>+ */
>+
>+#include "config.h"
>+#include "LocalStorageDatabase.h"
>+
>+#include "LocalStorageDatabaseTracker.h"
>+#include <WebCore/SQLiteStatement.h>
>+#include <WebCore/SQLiteTransaction.h>
>+#include <WebCore/SecurityOrigin.h>
>+#include <WebCore/StorageMap.h>
>+#include <WebCore/SuddenTermination.h>
>+#include <wtf/FileSystem.h>
>+#include <wtf/RefPtr.h>
>+#include <wtf/WorkQueue.h>
>+#include <wtf/text/StringHash.h>
>+#include <wtf/text/WTFString.h>
>+
>+static const auto databaseUpdateInterval = 1_s;
>+
>+static const int maximumItemsToUpdate = 100;
>+
>+namespace WebKit {
>+using namespace WebCore;
>+
>+Ref<LocalStorageDatabase> LocalStorageDatabase::create(Ref<WorkQueue>&& queue, Ref<LocalStorageDatabaseTracker>&& tracker, const SecurityOriginData& securityOrigin)
>+{
>+    return adoptRef(*new LocalStorageDatabase(WTFMove(queue), WTFMove(tracker), securityOrigin));
>+}
>+
>+LocalStorageDatabase::LocalStorageDatabase(Ref<WorkQueue>&& queue, Ref<LocalStorageDatabaseTracker>&& tracker, const SecurityOriginData& securityOrigin)
>+    : m_queue(WTFMove(queue))
>+    , m_tracker(WTFMove(tracker))
>+    , m_securityOrigin(securityOrigin)
>+    , m_databasePath(m_tracker->databasePath(m_securityOrigin))
>+    , m_failedToOpenDatabase(false)
>+    , m_didImportItems(false)
>+    , m_isClosed(false)
>+    , m_didScheduleDatabaseUpdate(false)
>+    , m_shouldClearItems(false)
>+{
>+}
>+
>+LocalStorageDatabase::~LocalStorageDatabase()
>+{
>+    ASSERT(m_isClosed);
>+}
>+
>+void LocalStorageDatabase::openDatabase(DatabaseOpeningStrategy openingStrategy)
>+{
>+    ASSERT(!m_database.isOpen());
>+    ASSERT(!m_failedToOpenDatabase);
>+
>+    if (!tryToOpenDatabase(openingStrategy)) {
>+        m_failedToOpenDatabase = true;
>+        return;
>+    }
>+
>+    if (m_database.isOpen())
>+        m_tracker->didOpenDatabaseWithOrigin(m_securityOrigin);
>+}
>+
>+bool LocalStorageDatabase::tryToOpenDatabase(DatabaseOpeningStrategy openingStrategy)
>+{
>+    if (!FileSystem::fileExists(m_databasePath) && openingStrategy == SkipIfNonExistent)
>+        return true;
>+
>+    if (m_databasePath.isEmpty()) {
>+        LOG_ERROR("Filename for local storage database is empty - cannot open for persistent storage");
>+        return false;
>+    }
>+
>+    if (!m_database.open(m_databasePath)) {
>+        LOG_ERROR("Failed to open database file %s for local storage", m_databasePath.utf8().data());
>+        return false;
>+    }
>+
>+    // Since a WorkQueue isn't bound to a specific thread, we have to disable threading checks
>+    // even though we never access the database from different threads simultaneously.
>+    m_database.disableThreadingChecks();
>+
>+    if (!migrateItemTableIfNeeded()) {
>+        // We failed to migrate the item table. In order to avoid trying to migrate the table over and over,
>+        // just delete it and start from scratch.
>+        if (!m_database.executeCommand("DROP TABLE ItemTable"))
>+            LOG_ERROR("Failed to delete table ItemTable for local storage");
>+    }
>+
>+    if (!m_database.executeCommand("CREATE TABLE IF NOT EXISTS ItemTable (key TEXT UNIQUE ON CONFLICT REPLACE, value BLOB NOT NULL ON CONFLICT FAIL)")) {
>+        LOG_ERROR("Failed to create table ItemTable for local storage");
>+        return false;
>+    }
>+
>+    return true;
>+}
>+
>+bool LocalStorageDatabase::migrateItemTableIfNeeded()
>+{
>+    if (!m_database.tableExists("ItemTable"))
>+        return true;
>+
>+    SQLiteStatement query(m_database, "SELECT value FROM ItemTable LIMIT 1");
>+
>+    // This query isn't ever executed, it's just used to check the column type.
>+    if (query.isColumnDeclaredAsBlob(0))
>+        return true;
>+
>+    // Create a new table with the right type, copy all the data over to it and then replace the new table with the old table.
>+    static const char* commands[] = {
>+        "DROP TABLE IF EXISTS ItemTable2",
>+        "CREATE TABLE ItemTable2 (key TEXT UNIQUE ON CONFLICT REPLACE, value BLOB NOT NULL ON CONFLICT FAIL)",
>+        "INSERT INTO ItemTable2 SELECT * from ItemTable",
>+        "DROP TABLE ItemTable",
>+        "ALTER TABLE ItemTable2 RENAME TO ItemTable",
>+        0,
>+    };
>+
>+    SQLiteTransaction transaction(m_database, false);
>+    transaction.begin();
>+
>+    for (size_t i = 0; commands[i]; ++i) {
>+        if (m_database.executeCommand(commands[i]))
>+            continue;
>+
>+        LOG_ERROR("Failed to migrate table ItemTable for local storage when executing: %s", commands[i]);
>+        transaction.rollback();
>+
>+        return false;
>+    }
>+
>+    transaction.commit();
>+    return true;
>+}
>+
>+void LocalStorageDatabase::importItems(StorageMap& storageMap)
>+{
>+    if (m_didImportItems)
>+        return;
>+
>+    // FIXME: If it can't import, then the default WebKit behavior should be that of private browsing,
>+    // not silently ignoring it. https://bugs.webkit.org/show_bug.cgi?id=25894
>+
>+    // We set this to true even if we don't end up importing any items due to failure because
>+    // there's really no good way to recover other than not importing anything.
>+    m_didImportItems = true;
>+
>+    openDatabase(SkipIfNonExistent);
>+    if (!m_database.isOpen())
>+        return;
>+
>+    SQLiteStatement query(m_database, "SELECT key, value FROM ItemTable");
>+    if (query.prepare() != SQLITE_OK) {
>+        LOG_ERROR("Unable to select items from ItemTable for local storage");
>+        return;
>+    }
>+
>+    HashMap<String, String> items;
>+
>+    int result = query.step();
>+    while (result == SQLITE_ROW) {
>+        String key = query.getColumnText(0);
>+        String value = query.getColumnBlobAsString(1);
>+        if (!key.isNull() && !value.isNull())
>+            items.set(key, value);
>+        result = query.step();
>+    }
>+
>+    if (result != SQLITE_DONE) {
>+        LOG_ERROR("Error reading items from ItemTable for local storage");
>+        return;
>+    }
>+
>+    storageMap.importItems(items);
>+}
>+
>+void LocalStorageDatabase::setItem(const String& key, const String& value)
>+{
>+    itemDidChange(key, value);
>+}
>+
>+void LocalStorageDatabase::removeItem(const String& key)
>+{
>+    itemDidChange(key, String());
>+}
>+
>+void LocalStorageDatabase::clear()
>+{
>+    m_changedItems.clear();
>+    m_shouldClearItems = true;
>+
>+    scheduleDatabaseUpdate();
>+}
>+
>+void LocalStorageDatabase::close()
>+{
>+    ASSERT(!m_isClosed);
>+    m_isClosed = true;
>+
>+    if (m_didScheduleDatabaseUpdate) {
>+        updateDatabaseWithChangedItems(m_changedItems);
>+        m_changedItems.clear();
>+    }
>+
>+    bool isEmpty = databaseIsEmpty();
>+
>+    if (m_database.isOpen())
>+        m_database.close();
>+
>+    if (isEmpty)
>+        m_tracker->deleteDatabaseWithOrigin(m_securityOrigin);
>+}
>+
>+void LocalStorageDatabase::itemDidChange(const String& key, const String& value)
>+{
>+    m_changedItems.set(key, value);
>+    scheduleDatabaseUpdate();
>+}
>+
>+void LocalStorageDatabase::scheduleDatabaseUpdate()
>+{
>+    if (m_didScheduleDatabaseUpdate)
>+        return;
>+
>+    if (!m_disableSuddenTerminationWhileWritingToLocalStorage)
>+        m_disableSuddenTerminationWhileWritingToLocalStorage = std::make_unique<SuddenTerminationDisabler>();
>+
>+    m_didScheduleDatabaseUpdate = true;
>+
>+    m_queue->dispatchAfter(databaseUpdateInterval, [protectedThis = makeRef(*this)] {
>+        protectedThis->updateDatabase();
>+    });
>+}
>+
>+void LocalStorageDatabase::updateDatabase()
>+{
>+    if (m_isClosed)
>+        return;
>+
>+    ASSERT(m_didScheduleDatabaseUpdate);
>+    m_didScheduleDatabaseUpdate = false;
>+
>+    HashMap<String, String> changedItems;
>+    if (m_changedItems.size() <= maximumItemsToUpdate) {
>+        // There are few enough changed items that we can just always write all of them.
>+        m_changedItems.swap(changedItems);
>+        updateDatabaseWithChangedItems(changedItems);
>+        m_disableSuddenTerminationWhileWritingToLocalStorage = nullptr;
>+    } else {
>+        for (int i = 0; i < maximumItemsToUpdate; ++i) {
>+            auto it = m_changedItems.begin();
>+            changedItems.add(it->key, it->value);
>+
>+            m_changedItems.remove(it);
>+        }
>+
>+        ASSERT(changedItems.size() <= maximumItemsToUpdate);
>+
>+        // Reschedule the update for the remaining items.
>+        scheduleDatabaseUpdate();
>+        updateDatabaseWithChangedItems(changedItems);
>+    }
>+}
>+
>+void LocalStorageDatabase::updateDatabaseWithChangedItems(const HashMap<String, String>& changedItems)
>+{
>+    if (!m_database.isOpen())
>+        openDatabase(CreateIfNonExistent);
>+    if (!m_database.isOpen())
>+        return;
>+
>+    if (m_shouldClearItems) {
>+        m_shouldClearItems = false;
>+
>+        SQLiteStatement clearStatement(m_database, "DELETE FROM ItemTable");
>+        if (clearStatement.prepare() != SQLITE_OK) {
>+            LOG_ERROR("Failed to prepare clear statement - cannot write to local storage database");
>+            return;
>+        }
>+
>+        int result = clearStatement.step();
>+        if (result != SQLITE_DONE) {
>+            LOG_ERROR("Failed to clear all items in the local storage database - %i", result);
>+            return;
>+        }
>+    }
>+
>+    SQLiteStatement insertStatement(m_database, "INSERT INTO ItemTable VALUES (?, ?)");
>+    if (insertStatement.prepare() != SQLITE_OK) {
>+        LOG_ERROR("Failed to prepare insert statement - cannot write to local storage database");
>+        return;
>+    }
>+
>+    SQLiteStatement deleteStatement(m_database, "DELETE FROM ItemTable WHERE key=?");
>+    if (deleteStatement.prepare() != SQLITE_OK) {
>+        LOG_ERROR("Failed to prepare delete statement - cannot write to local storage database");
>+        return;
>+    }
>+
>+    SQLiteTransaction transaction(m_database);
>+    transaction.begin();
>+
>+    for (auto it = changedItems.begin(), end = changedItems.end(); it != end; ++it) {
>+        // A null value means that the key/value pair should be deleted.
>+        SQLiteStatement& statement = it->value.isNull() ? deleteStatement : insertStatement;
>+
>+        statement.bindText(1, it->key);
>+
>+        // If we're inserting a key/value pair, bind the value as well.
>+        if (!it->value.isNull())
>+            statement.bindBlob(2, it->value);
>+
>+        int result = statement.step();
>+        if (result != SQLITE_DONE) {
>+            LOG_ERROR("Failed to update item in the local storage database - %i", result);
>+            break;
>+        }
>+
>+        statement.reset();
>+    }
>+
>+    transaction.commit();
>+}
>+
>+bool LocalStorageDatabase::databaseIsEmpty()
>+{
>+    if (!m_database.isOpen())
>+        return false;
>+
>+    SQLiteStatement query(m_database, "SELECT COUNT(*) FROM ItemTable");
>+    if (query.prepare() != SQLITE_OK) {
>+        LOG_ERROR("Unable to count number of rows in ItemTable for local storage");
>+        return false;
>+    }
>+
>+    int result = query.step();
>+    if (result != SQLITE_ROW) {
>+        LOG_ERROR("No results when counting number of rows in ItemTable for local storage");
>+        return false;
>+    }
>+
>+    return !query.getColumnInt(0);
>+}
>+
>+} // namespace WebKit
>diff --git a/Source/WebKit/NetworkProcess/WebStorage/LocalStorageDatabase.h b/Source/WebKit/NetworkProcess/WebStorage/LocalStorageDatabase.h
>new file mode 100644
>index 0000000000000000000000000000000000000000..9992031f448fb3d91580186d8860a12d84859562
>--- /dev/null
>+++ b/Source/WebKit/NetworkProcess/WebStorage/LocalStorageDatabase.h
>@@ -0,0 +1,99 @@
>+/*
>+ * Copyright (C) 2008, 2009, 2010, 2013 Apple Inc. All rights reserved.
>+ *
>+ * Redistribution and use in source and binary forms, with or without
>+ * modification, are permitted provided that the following conditions
>+ * are met:
>+ * 1. Redistributions of source code must retain the above copyright
>+ *    notice, this list of conditions and the following disclaimer.
>+ * 2. Redistributions in binary form must reproduce the above copyright
>+ *    notice, this list of conditions and the following disclaimer in the
>+ *    documentation and/or other materials provided with the distribution.
>+ *
>+ * THIS SOFTWARE IS PROVIDED BY APPLE INC. AND ITS CONTRIBUTORS ``AS IS''
>+ * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO,
>+ * THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
>+ * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL APPLE INC. OR ITS CONTRIBUTORS
>+ * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
>+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
>+ * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
>+ * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
>+ * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
>+ * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF
>+ * THE POSSIBILITY OF SUCH DAMAGE.
>+ */
>+
>+#pragma once
>+
>+#include <WebCore/SQLiteDatabase.h>
>+#include <WebCore/SecurityOriginData.h>
>+#include <wtf/Forward.h>
>+#include <wtf/HashMap.h>
>+#include <wtf/RefPtr.h>
>+#include <wtf/ThreadSafeRefCounted.h>
>+#include <wtf/WorkQueue.h>
>+
>+namespace WebCore {
>+class SecurityOrigin;
>+class StorageMap;
>+class SuddenTerminationDisabler;
>+}
>+
>+namespace WebKit {
>+
>+class LocalStorageDatabaseTracker;
>+
>+class LocalStorageDatabase : public ThreadSafeRefCounted<LocalStorageDatabase> {
>+public:
>+    static Ref<LocalStorageDatabase> create(Ref<WorkQueue>&&, Ref<LocalStorageDatabaseTracker>&&, const WebCore::SecurityOriginData&);
>+    ~LocalStorageDatabase();
>+
>+    // Will block until the import is complete.
>+    void importItems(WebCore::StorageMap&);
>+
>+    void setItem(const String& key, const String& value);
>+    void removeItem(const String& key);
>+    void clear();
>+
>+    // Will block until all pending changes have been written to disk.
>+    void close();
>+
>+private:
>+    LocalStorageDatabase(Ref<WorkQueue>&&, Ref<LocalStorageDatabaseTracker>&&, const WebCore::SecurityOriginData&);
>+
>+    enum DatabaseOpeningStrategy {
>+        CreateIfNonExistent,
>+        SkipIfNonExistent
>+    };
>+    bool tryToOpenDatabase(DatabaseOpeningStrategy);
>+    void openDatabase(DatabaseOpeningStrategy);
>+
>+    bool migrateItemTableIfNeeded();
>+
>+    void itemDidChange(const String& key, const String& value);
>+
>+    void scheduleDatabaseUpdate();
>+    void updateDatabase();
>+    void updateDatabaseWithChangedItems(const HashMap<String, String>&);
>+
>+    bool databaseIsEmpty();
>+
>+    Ref<WorkQueue> m_queue;
>+    Ref<LocalStorageDatabaseTracker> m_tracker;
>+    WebCore::SecurityOriginData m_securityOrigin;
>+
>+    String m_databasePath;
>+    WebCore::SQLiteDatabase m_database;
>+    bool m_failedToOpenDatabase;
>+    bool m_didImportItems;
>+    bool m_isClosed;
>+
>+    bool m_didScheduleDatabaseUpdate;
>+    bool m_shouldClearItems;
>+    HashMap<String, String> m_changedItems;
>+
>+    std::unique_ptr<WebCore::SuddenTerminationDisabler> m_disableSuddenTerminationWhileWritingToLocalStorage;
>+};
>+
>+
>+} // namespace WebKit
>diff --git a/Source/WebKit/NetworkProcess/WebStorage/LocalStorageDatabaseTracker.cpp b/Source/WebKit/NetworkProcess/WebStorage/LocalStorageDatabaseTracker.cpp
>new file mode 100644
>index 0000000000000000000000000000000000000000..d084d62877c02269d7addaf5ade3b4fa149741f9
>--- /dev/null
>+++ b/Source/WebKit/NetworkProcess/WebStorage/LocalStorageDatabaseTracker.cpp
>@@ -0,0 +1,166 @@
>+/*
>+ * Copyright (C) 2011, 2013 Apple Inc. All rights reserved.
>+ *
>+ * Redistribution and use in source and binary forms, with or without
>+ * modification, are permitted provided that the following conditions
>+ * are met:
>+ * 1. Redistributions of source code must retain the above copyright
>+ *    notice, this list of conditions and the following disclaimer.
>+ * 2. Redistributions in binary form must reproduce the above copyright
>+ *    notice, this list of conditions and the following disclaimer in the
>+ *    documentation and/or other materials provided with the distribution.
>+ *
>+ * THIS SOFTWARE IS PROVIDED BY APPLE INC. AND ITS CONTRIBUTORS ``AS IS''
>+ * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO,
>+ * THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
>+ * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL APPLE INC. OR ITS CONTRIBUTORS
>+ * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
>+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
>+ * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
>+ * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
>+ * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
>+ * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF
>+ * THE POSSIBILITY OF SUCH DAMAGE.
>+ */
>+
>+#include "config.h"
>+#include "LocalStorageDatabaseTracker.h"
>+
>+#include "Logging.h"
>+#include <WebCore/SQLiteFileSystem.h>
>+#include <WebCore/SQLiteStatement.h>
>+#include <WebCore/TextEncoding.h>
>+#include <wtf/FileSystem.h>
>+#include <wtf/MainThread.h>
>+#include <wtf/RunLoop.h>
>+#include <wtf/WorkQueue.h>
>+#include <wtf/text/CString.h>
>+
>+namespace WebKit {
>+using namespace WebCore;
>+
>+Ref<LocalStorageDatabaseTracker> LocalStorageDatabaseTracker::create(Ref<WorkQueue>&& queue, const String& localStorageDirectory)
>+{
>+    return adoptRef(*new LocalStorageDatabaseTracker(WTFMove(queue), localStorageDirectory));
>+}
>+
>+LocalStorageDatabaseTracker::LocalStorageDatabaseTracker(Ref<WorkQueue>&& queue, const String& localStorageDirectory)
>+    : m_queue(WTFMove(queue))
>+    , m_localStorageDirectory(localStorageDirectory.isolatedCopy())
>+{
>+    // Make sure the encoding is initialized before we start dispatching things to the queue.
>+    UTF8Encoding();
>+
>+    m_queue->dispatch([protectedThis = makeRef(*this)]() mutable {
>+        // Delete legacy storageTracker database file.
>+        SQLiteFileSystem::deleteDatabaseFile(protectedThis->databasePath("StorageTracker.db"));
>+    });
>+}
>+
>+LocalStorageDatabaseTracker::~LocalStorageDatabaseTracker()
>+{
>+}
>+
>+String LocalStorageDatabaseTracker::databasePath(const SecurityOriginData& securityOrigin) const
>+{
>+    return databasePath(securityOrigin.databaseIdentifier() + ".localstorage");
>+}
>+
>+void LocalStorageDatabaseTracker::didOpenDatabaseWithOrigin(const SecurityOriginData& securityOrigin)
>+{
>+    // FIXME: Tell clients that the origin was added.
>+}
>+
>+void LocalStorageDatabaseTracker::deleteDatabaseWithOrigin(const SecurityOriginData& securityOrigin)
>+{
>+    auto path = databasePath(securityOrigin);
>+    if (!path.isEmpty())
>+        SQLiteFileSystem::deleteDatabaseFile(path);
>+
>+    // FIXME: Tell clients that the origin was removed.
>+}
>+
>+void LocalStorageDatabaseTracker::deleteAllDatabases()
>+{
>+    auto paths = FileSystem::listDirectory(m_localStorageDirectory, "*.localstorage");
>+    for (const auto& path : paths) {
>+        SQLiteFileSystem::deleteDatabaseFile(path);
>+
>+        // FIXME: Call out to the client.
>+    }
>+
>+    SQLiteFileSystem::deleteEmptyDatabaseDirectory(m_localStorageDirectory);
>+}
>+
>+Vector<SecurityOriginData> LocalStorageDatabaseTracker::databasesModifiedSince(WallTime time)
>+{
>+    Vector<SecurityOriginData> databaseOriginsModified;
>+    auto databaseOrigins = origins();
>+    
>+    for (auto origin : databaseOrigins) {
>+        auto path = databasePath(origin);
>+        
>+        auto modificationTime = SQLiteFileSystem::databaseModificationTime(path);
>+        if (!modificationTime)
>+            continue;
>+
>+        if (modificationTime.value() >= time)
>+            databaseOriginsModified.append(origin);
>+    }
>+
>+    return databaseOriginsModified;
>+}
>+
>+Vector<SecurityOriginData> LocalStorageDatabaseTracker::origins() const
>+{
>+    Vector<SecurityOriginData> databaseOrigins;
>+    auto paths = FileSystem::listDirectory(m_localStorageDirectory, "*.localstorage");
>+    
>+    for (const auto& path : paths) {
>+        auto filename = FileSystem::pathGetFileName(path);
>+        auto originIdentifier = filename.substring(0, filename.length() - strlen(".localstorage"));
>+        auto origin = SecurityOriginData::fromDatabaseIdentifier(originIdentifier);
>+        if (origin)
>+            databaseOrigins.append(origin.value());
>+        else
>+            RELEASE_LOG_ERROR(LocalStorageDatabaseTracker, "Unable to extract origin from path %s", path.utf8().data());
>+    }
>+
>+    return databaseOrigins;
>+}
>+
>+Vector<LocalStorageDatabaseTracker::OriginDetails> LocalStorageDatabaseTracker::originDetails()
>+{
>+    Vector<OriginDetails> result;
>+    auto databaseOrigins = origins();
>+    result.reserveInitialCapacity(databaseOrigins.size());
>+
>+    for (const auto& origin : databaseOrigins) {
>+        String path = databasePath(origin);
>+
>+        OriginDetails details;
>+        details.originIdentifier = origin.databaseIdentifier();
>+        details.creationTime = SQLiteFileSystem::databaseCreationTime(path);
>+        details.modificationTime = SQLiteFileSystem::databaseModificationTime(path);
>+        result.uncheckedAppend(details);
>+    }
>+
>+    return result;
>+}
>+
>+String LocalStorageDatabaseTracker::databasePath(const String& filename) const
>+{
>+    if (!SQLiteFileSystem::ensureDatabaseDirectoryExists(m_localStorageDirectory)) {
>+        if (!m_localStorageDirectory.isNull())
>+            LOG_ERROR("Unable to create LocalStorage database path %s", m_localStorageDirectory.utf8().data());
>+        return String();
>+    }
>+
>+#if PLATFORM(IOS_FAMILY)
>+    platformMaybeExcludeFromBackup();
>+#endif
>+
>+    return SQLiteFileSystem::appendDatabaseFileNameToPath(m_localStorageDirectory, filename);
>+}
>+
>+} // namespace WebKit
>diff --git a/Source/WebKit/NetworkProcess/WebStorage/LocalStorageDatabaseTracker.h b/Source/WebKit/NetworkProcess/WebStorage/LocalStorageDatabaseTracker.h
>new file mode 100644
>index 0000000000000000000000000000000000000000..6a7dd919352ebeaa8b484b5dcd8c66bebe55a9f9
>--- /dev/null
>+++ b/Source/WebKit/NetworkProcess/WebStorage/LocalStorageDatabaseTracker.h
>@@ -0,0 +1,106 @@
>+/*
>+ * Copyright (C) 2011, 2013, 2019 Apple Inc. All rights reserved.
>+ *
>+ * Redistribution and use in source and binary forms, with or without
>+ * modification, are permitted provided that the following conditions
>+ * are met:
>+ * 1. Redistributions of source code must retain the above copyright
>+ *    notice, this list of conditions and the following disclaimer.
>+ * 2. Redistributions in binary form must reproduce the above copyright
>+ *    notice, this list of conditions and the following disclaimer in the
>+ *    documentation and/or other materials provided with the distribution.
>+ *
>+ * THIS SOFTWARE IS PROVIDED BY APPLE INC. AND ITS CONTRIBUTORS ``AS IS''
>+ * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO,
>+ * THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
>+ * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL APPLE INC. OR ITS CONTRIBUTORS
>+ * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
>+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
>+ * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
>+ * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
>+ * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
>+ * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF
>+ * THE POSSIBILITY OF SUCH DAMAGE.
>+ */
>+
>+#pragma once
>+
>+#include <WebCore/SecurityOriginData.h>
>+#include <wtf/Markable.h>
>+#include <wtf/RefPtr.h>
>+#include <wtf/ThreadSafeRefCounted.h>
>+#include <wtf/WallTime.h>
>+#include <wtf/WorkQueue.h>
>+#include <wtf/text/WTFString.h>
>+
>+namespace WebKit {
>+
>+class LocalStorageDatabaseTracker : public ThreadSafeRefCounted<LocalStorageDatabaseTracker> {
>+public:
>+    static Ref<LocalStorageDatabaseTracker> create(Ref<WorkQueue>&&, const String& localStorageDirectory);
>+    ~LocalStorageDatabaseTracker();
>+
>+    String databasePath(const WebCore::SecurityOriginData&) const;
>+
>+    void didOpenDatabaseWithOrigin(const WebCore::SecurityOriginData&);
>+    void deleteDatabaseWithOrigin(const WebCore::SecurityOriginData&);
>+    void deleteAllDatabases();
>+
>+    // Returns a vector of the origins whose databases should be deleted.
>+    Vector<WebCore::SecurityOriginData> databasesModifiedSince(WallTime);
>+
>+    Vector<WebCore::SecurityOriginData> origins() const;
>+
>+    struct OriginDetails {
>+        String originIdentifier;
>+        Optional<WallTime> creationTime;
>+        Optional<WallTime> modificationTime;
>+
>+        template<class Encoder> void encode(Encoder&) const;
>+        template<class Decoder> static Optional<OriginDetails> decode(Decoder&);
>+    };
>+    Vector<OriginDetails> originDetails();
>+
>+private:
>+    LocalStorageDatabaseTracker(Ref<WorkQueue>&&, const String& localStorageDirectory);
>+
>+    String databasePath(const String& filename) const;
>+
>+    enum DatabaseOpeningStrategy {
>+        CreateIfNonExistent,
>+        SkipIfNonExistent
>+    };
>+
>+    RefPtr<WorkQueue> m_queue;
>+    String m_localStorageDirectory;
>+
>+#if PLATFORM(IOS_FAMILY)
>+    void platformMaybeExcludeFromBackup() const;
>+
>+    mutable bool m_hasExcludedFromBackup { false };
>+#endif
>+};
>+
>+template<class Encoder>
>+void LocalStorageDatabaseTracker::OriginDetails::encode(Encoder& encoder) const
>+{
>+    encoder << originIdentifier << creationTime << modificationTime;
>+}
>+
>+template<class Decoder>
>+Optional<LocalStorageDatabaseTracker::OriginDetails> LocalStorageDatabaseTracker::OriginDetails::decode(Decoder& decoder)
>+{
>+    LocalStorageDatabaseTracker::OriginDetails result;
>+    if (!decoder.decode(result.originIdentifier))
>+        return WTF::nullopt;
>+    
>+    if (!decoder.decode(result.creationTime))
>+        return WTF::nullopt;
>+    
>+    if (!decoder.decode(result.modificationTime))
>+        return WTF::nullopt;
>+    
>+    return result;
>+}
>+
>+} // namespace WebKit
>diff --git a/Source/WebKit/NetworkProcess/WebStorage/StorageManager.cpp b/Source/WebKit/NetworkProcess/WebStorage/StorageManager.cpp
>new file mode 100644
>index 0000000000000000000000000000000000000000..eccb5746197236eef5d99077970c553ded1e8120
>--- /dev/null
>+++ b/Source/WebKit/NetworkProcess/WebStorage/StorageManager.cpp
>@@ -0,0 +1,950 @@
>+/*
>+ * Copyright (C) 2013-2019 Apple Inc. All rights reserved.
>+ *
>+ * Redistribution and use in source and binary forms, with or without
>+ * modification, are permitted provided that the following conditions
>+ * are met:
>+ * 1. Redistributions of source code must retain the above copyright
>+ *    notice, this list of conditions and the following disclaimer.
>+ * 2. Redistributions in binary form must reproduce the above copyright
>+ *    notice, this list of conditions and the following disclaimer in the
>+ *    documentation and/or other materials provided with the distribution.
>+ *
>+ * THIS SOFTWARE IS PROVIDED BY APPLE INC. AND ITS CONTRIBUTORS ``AS IS''
>+ * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO,
>+ * THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
>+ * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL APPLE INC. OR ITS CONTRIBUTORS
>+ * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
>+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
>+ * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
>+ * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
>+ * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
>+ * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF
>+ * THE POSSIBILITY OF SUCH DAMAGE.
>+ */
>+
>+#include "config.h"
>+#include "StorageManager.h"
>+
>+#include "LocalStorageDatabase.h"
>+#include "LocalStorageDatabaseTracker.h"
>+#include "StorageAreaMapMessages.h"
>+#include "StorageManagerMessages.h"
>+#include "WebProcessProxy.h"
>+#include <WebCore/SecurityOriginData.h>
>+#include <WebCore/SecurityOriginHash.h>
>+#include <WebCore/StorageMap.h>
>+#include <WebCore/TextEncoding.h>
>+#include <memory>
>+#include <wtf/WorkQueue.h>
>+#include <wtf/threads/BinarySemaphore.h>
>+
>+namespace WebKit {
>+using namespace WebCore;
>+
>+class StorageManager::StorageArea : public ThreadSafeRefCounted<StorageManager::StorageArea> {
>+public:
>+    static Ref<StorageArea> create(LocalStorageNamespace*, const SecurityOriginData&, unsigned quotaInBytes);
>+    ~StorageArea();
>+
>+    const WebCore::SecurityOriginData& securityOrigin() const { return m_securityOrigin; }
>+
>+    void addListener(IPC::Connection::UniqueID, uint64_t storageMapID);
>+    void removeListener(IPC::Connection::UniqueID, uint64_t storageMapID);
>+    bool hasListener(IPC::Connection::UniqueID, uint64_t storageMapID) const;
>+
>+    Ref<StorageArea> clone() const;
>+
>+    void setItem(IPC::Connection::UniqueID sourceConnection, uint64_t sourceStorageAreaID, const String& key, const String& value, const String& urlString, bool& quotaException);
>+    void removeItem(IPC::Connection::UniqueID sourceConnection, uint64_t sourceStorageAreaID, const String& key, const String& urlString);
>+    void clear(IPC::Connection::UniqueID sourceConnection, uint64_t sourceStorageAreaID, const String& urlString);
>+
>+    const HashMap<String, String>& items() const;
>+    void clear();
>+
>+    bool isSessionStorage() const { return !m_localStorageNamespace; }
>+
>+private:
>+    explicit StorageArea(LocalStorageNamespace*, const SecurityOriginData&, unsigned quotaInBytes);
>+
>+    void openDatabaseAndImportItemsIfNeeded() const;
>+
>+    void dispatchEvents(IPC::Connection::UniqueID sourceConnection, uint64_t sourceStorageAreaID, const String& key, const String& oldValue, const String& newValue, const String& urlString) const;
>+
>+    // Will be null if the storage area belongs to a session storage namespace.
>+    LocalStorageNamespace* m_localStorageNamespace;
>+    mutable RefPtr<LocalStorageDatabase> m_localStorageDatabase;
>+    mutable bool m_didImportItemsFromDatabase { false };
>+
>+    SecurityOriginData m_securityOrigin;
>+    unsigned m_quotaInBytes;
>+
>+    RefPtr<StorageMap> m_storageMap;
>+    HashSet<std::pair<IPC::Connection::UniqueID, uint64_t>> m_eventListeners;
>+};
>+
>+class StorageManager::LocalStorageNamespace : public ThreadSafeRefCounted<LocalStorageNamespace> {
>+public:
>+    static Ref<LocalStorageNamespace> create(StorageManager*, uint64_t storageManagerID);
>+    ~LocalStorageNamespace();
>+
>+    StorageManager* storageManager() const { return m_storageManager; }
>+
>+    Ref<StorageArea> getOrCreateStorageArea(SecurityOriginData&&);
>+    void didDestroyStorageArea(StorageArea*);
>+
>+    void clearStorageAreasMatchingOrigin(const SecurityOriginData&);
>+    void clearAllStorageAreas();
>+
>+private:
>+    explicit LocalStorageNamespace(StorageManager*, uint64_t storageManagerID);
>+
>+    StorageManager* m_storageManager;
>+    uint64_t m_storageNamespaceID;
>+    unsigned m_quotaInBytes;
>+
>+    // We don't hold an explicit reference to the StorageAreas; they are kept alive by the m_storageAreasByConnection map in StorageManager.
>+    HashMap<SecurityOriginData, StorageArea*> m_storageAreaMap;
>+};
>+
>+// Suggested by https://www.w3.org/TR/webstorage/#disk-space
>+const unsigned localStorageDatabaseQuotaInBytes = 5 * 1024 * 1024;
>+
>+class StorageManager::TransientLocalStorageNamespace : public ThreadSafeRefCounted<TransientLocalStorageNamespace> {
>+public:
>+    static Ref<TransientLocalStorageNamespace> create()
>+    {
>+        return adoptRef(*new TransientLocalStorageNamespace());
>+    }
>+
>+    ~TransientLocalStorageNamespace()
>+    {
>+    }
>+
>+    Ref<StorageArea> getOrCreateStorageArea(SecurityOriginData&& securityOrigin)
>+    {
>+        return *m_storageAreaMap.ensure(securityOrigin, [this, securityOrigin]() mutable {
>+            return StorageArea::create(nullptr, WTFMove(securityOrigin), m_quotaInBytes);
>+        }).iterator->value.copyRef();
>+    }
>+
>+    Vector<SecurityOriginData> origins() const
>+    {
>+        Vector<SecurityOriginData> origins;
>+
>+        for (const auto& storageArea : m_storageAreaMap.values()) {
>+            if (!storageArea->items().isEmpty())
>+                origins.append(storageArea->securityOrigin());
>+        }
>+
>+        return origins;
>+    }
>+
>+    void clearStorageAreasMatchingOrigin(const SecurityOriginData& securityOrigin)
>+    {
>+        for (auto& storageArea : m_storageAreaMap.values()) {
>+            if (storageArea->securityOrigin() == securityOrigin)
>+                storageArea->clear();
>+        }
>+    }
>+
>+    void clearAllStorageAreas()
>+    {
>+        for (auto& storageArea : m_storageAreaMap.values())
>+            storageArea->clear();
>+    }
>+
>+private:
>+    explicit TransientLocalStorageNamespace()
>+    {
>+    }
>+
>+    const unsigned m_quotaInBytes = localStorageDatabaseQuotaInBytes;
>+
>+    HashMap<SecurityOriginData, RefPtr<StorageArea>> m_storageAreaMap;
>+};
>+
>+auto StorageManager::StorageArea::create(LocalStorageNamespace* localStorageNamespace, const SecurityOriginData& securityOrigin, unsigned quotaInBytes) -> Ref<StorageManager::StorageArea>
>+{
>+    return adoptRef(*new StorageArea(localStorageNamespace, securityOrigin, quotaInBytes));
>+}
>+
>+StorageManager::StorageArea::StorageArea(LocalStorageNamespace* localStorageNamespace, const SecurityOriginData& securityOrigin, unsigned quotaInBytes)
>+    : m_localStorageNamespace(localStorageNamespace)
>+    , m_securityOrigin(securityOrigin)
>+    , m_quotaInBytes(quotaInBytes)
>+    , m_storageMap(StorageMap::create(m_quotaInBytes))
>+{
>+}
>+
>+StorageManager::StorageArea::~StorageArea()
>+{
>+    ASSERT(m_eventListeners.isEmpty());
>+
>+    if (m_localStorageDatabase)
>+        m_localStorageDatabase->close();
>+
>+    if (m_localStorageNamespace)
>+        m_localStorageNamespace->didDestroyStorageArea(this);
>+}
>+
>+void StorageManager::StorageArea::addListener(IPC::Connection::UniqueID connectionID, uint64_t storageMapID)
>+{
>+    ASSERT(!m_eventListeners.contains(std::make_pair(connectionID, storageMapID)));
>+    m_eventListeners.add(std::make_pair(connectionID, storageMapID));
>+}
>+
>+void StorageManager::StorageArea::removeListener(IPC::Connection::UniqueID connectionID, uint64_t storageMapID)
>+{
>+    ASSERT(isSessionStorage() || m_eventListeners.contains(std::make_pair(connectionID, storageMapID)));
>+    m_eventListeners.remove(std::make_pair(connectionID, storageMapID));
>+}
>+
>+bool StorageManager::StorageArea::hasListener(IPC::Connection::UniqueID connectionID, uint64_t storageMapID) const
>+{
>+    return m_eventListeners.contains(std::make_pair(connectionID, storageMapID));
>+}
>+
>+Ref<StorageManager::StorageArea> StorageManager::StorageArea::clone() const
>+{
>+    ASSERT(!m_localStorageNamespace);
>+
>+    auto storageArea = StorageArea::create(nullptr, m_securityOrigin, m_quotaInBytes);
>+    storageArea->m_storageMap = m_storageMap;
>+
>+    return storageArea;
>+}
>+
>+void StorageManager::StorageArea::setItem(IPC::Connection::UniqueID sourceConnection, uint64_t sourceStorageAreaID, const String& key, const String& value, const String& urlString, bool& quotaException)
>+{
>+    openDatabaseAndImportItemsIfNeeded();
>+
>+    String oldValue;
>+
>+    auto newStorageMap = m_storageMap->setItem(key, value, oldValue, quotaException);
>+    if (newStorageMap)
>+        m_storageMap = WTFMove(newStorageMap);
>+
>+    if (quotaException)
>+        return;
>+
>+    if (m_localStorageDatabase)
>+        m_localStorageDatabase->setItem(key, value);
>+
>+    dispatchEvents(sourceConnection, sourceStorageAreaID, key, oldValue, value, urlString);
>+}
>+
>+void StorageManager::StorageArea::removeItem(IPC::Connection::UniqueID sourceConnection, uint64_t sourceStorageAreaID, const String& key, const String& urlString)
>+{
>+    openDatabaseAndImportItemsIfNeeded();
>+
>+    String oldValue;
>+    auto newStorageMap = m_storageMap->removeItem(key, oldValue);
>+    if (newStorageMap)
>+        m_storageMap = WTFMove(newStorageMap);
>+
>+    if (oldValue.isNull())
>+        return;
>+
>+    if (m_localStorageDatabase)
>+        m_localStorageDatabase->removeItem(key);
>+
>+    dispatchEvents(sourceConnection, sourceStorageAreaID, key, oldValue, String(), urlString);
>+}
>+
>+void StorageManager::StorageArea::clear(IPC::Connection::UniqueID sourceConnection, uint64_t sourceStorageAreaID, const String& urlString)
>+{
>+    openDatabaseAndImportItemsIfNeeded();
>+
>+    if (!m_storageMap->length())
>+        return;
>+
>+    m_storageMap = StorageMap::create(m_quotaInBytes);
>+
>+    if (m_localStorageDatabase)
>+        m_localStorageDatabase->clear();
>+
>+    dispatchEvents(sourceConnection, sourceStorageAreaID, String(), String(), String(), urlString);
>+}
>+
>+const HashMap<String, String>& StorageManager::StorageArea::items() const
>+{
>+    openDatabaseAndImportItemsIfNeeded();
>+
>+    return m_storageMap->items();
>+}
>+
>+void StorageManager::StorageArea::clear()
>+{
>+    m_storageMap = StorageMap::create(m_quotaInBytes);
>+
>+    if (m_localStorageDatabase) {
>+        m_localStorageDatabase->close();
>+        m_localStorageDatabase = nullptr;
>+    }
>+
>+    for (auto it = m_eventListeners.begin(), end = m_eventListeners.end(); it != end; ++it) {
>+        RunLoop::main().dispatch([connectionID = it->first, destinationStorageAreaID = it->second] {
>+            if (auto* connection = IPC::Connection::connection(connectionID))
>+                connection->send(Messages::StorageAreaMap::ClearCache(), destinationStorageAreaID);
>+        });
>+    }
>+}
>+
>+void StorageManager::StorageArea::openDatabaseAndImportItemsIfNeeded() const
>+{
>+    if (!m_localStorageNamespace)
>+        return;
>+
>+    // We open the database here even if we've already imported our items to ensure that the database is open if we need to write to it.
>+    if (!m_localStorageDatabase)
>+        m_localStorageDatabase = LocalStorageDatabase::create(m_localStorageNamespace->storageManager()->m_queue.copyRef(), m_localStorageNamespace->storageManager()->m_localStorageDatabaseTracker.copyRef(), m_securityOrigin);
>+
>+    if (m_didImportItemsFromDatabase)
>+        return;
>+
>+    m_localStorageDatabase->importItems(*m_storageMap);
>+    m_didImportItemsFromDatabase = true;
>+}
>+
>+void StorageManager::StorageArea::dispatchEvents(IPC::Connection::UniqueID sourceConnection, uint64_t sourceStorageAreaID, const String& key, const String& oldValue, const String& newValue, const String& urlString) const
>+{
>+    for (auto it = m_eventListeners.begin(), end = m_eventListeners.end(); it != end; ++it) {
>+        sourceStorageAreaID = it->first == sourceConnection ? sourceStorageAreaID : 0;
>+
>+        RunLoop::main().dispatch([connectionID = it->first, sourceStorageAreaID, destinationStorageAreaID = it->second, key = key.isolatedCopy(), oldValue = oldValue.isolatedCopy(), newValue = newValue.isolatedCopy(), urlString = urlString.isolatedCopy()] {
>+            if (auto* connection = IPC::Connection::connection(connectionID))
>+                connection->send(Messages::StorageAreaMap::DispatchStorageEvent(sourceStorageAreaID, key, oldValue, newValue, urlString), destinationStorageAreaID);
>+        });
>+    }
>+}
>+
>+Ref<StorageManager::LocalStorageNamespace> StorageManager::LocalStorageNamespace::create(StorageManager* storageManager, uint64_t storageNamespaceID)
>+{
>+    return adoptRef(*new LocalStorageNamespace(storageManager, storageNamespaceID));
>+}
>+
>+// FIXME: The quota value is copied from GroupSettings.cpp.
>+// We should investigate a way to share it with WebCore.
>+StorageManager::LocalStorageNamespace::LocalStorageNamespace(StorageManager* storageManager, uint64_t storageNamespaceID)
>+    : m_storageManager(storageManager)
>+    , m_storageNamespaceID(storageNamespaceID)
>+    , m_quotaInBytes(localStorageDatabaseQuotaInBytes)
>+{
>+}
>+
>+StorageManager::LocalStorageNamespace::~LocalStorageNamespace()
>+{
>+    ASSERT(m_storageAreaMap.isEmpty());
>+}
>+
>+auto StorageManager::LocalStorageNamespace::getOrCreateStorageArea(SecurityOriginData&& securityOrigin) -> Ref<StorageArea>
>+{
>+    auto& slot = m_storageAreaMap.add(securityOrigin, nullptr).iterator->value;
>+    if (slot)
>+        return *slot;
>+
>+    auto storageArea = StorageArea::create(this, WTFMove(securityOrigin), m_quotaInBytes);
>+    slot = &storageArea.get();
>+
>+    return storageArea;
>+}
>+
>+void StorageManager::LocalStorageNamespace::didDestroyStorageArea(StorageArea* storageArea)
>+{
>+    ASSERT(m_storageAreaMap.contains(storageArea->securityOrigin()));
>+
>+    m_storageAreaMap.remove(storageArea->securityOrigin());
>+    if (!m_storageAreaMap.isEmpty())
>+        return;
>+
>+    ASSERT(m_storageManager->m_localStorageNamespaces.contains(m_storageNamespaceID));
>+    m_storageManager->m_localStorageNamespaces.remove(m_storageNamespaceID);
>+}
>+
>+void StorageManager::LocalStorageNamespace::clearStorageAreasMatchingOrigin(const SecurityOriginData& securityOrigin)
>+{
>+    for (const auto& originAndStorageArea : m_storageAreaMap) {
>+        if (originAndStorageArea.key == securityOrigin)
>+            originAndStorageArea.value->clear();
>+    }
>+}
>+
>+void StorageManager::LocalStorageNamespace::clearAllStorageAreas()
>+{
>+    for (auto* storageArea : m_storageAreaMap.values())
>+        storageArea->clear();
>+}
>+
>+class StorageManager::SessionStorageNamespace : public ThreadSafeRefCounted<SessionStorageNamespace> {
>+public:
>+    static Ref<SessionStorageNamespace> create(unsigned quotaInBytes);
>+    ~SessionStorageNamespace();
>+
>+    bool isEmpty() const { return m_storageAreaMap.isEmpty(); }
>+
>+    HashSet<IPC::Connection::UniqueID> allowedConnections() const { return m_allowedConnections; }
>+    void addAllowedConnection(IPC::Connection::UniqueID);
>+    void removeAllowedConnection(IPC::Connection::UniqueID);
>+
>+    Ref<StorageArea> getOrCreateStorageArea(SecurityOriginData&&);
>+
>+    void cloneTo(SessionStorageNamespace& newSessionStorageNamespace);
>+
>+    Vector<SecurityOriginData> origins() const
>+    {
>+        Vector<SecurityOriginData> origins;
>+
>+        for (const auto& storageArea : m_storageAreaMap.values()) {
>+            if (!storageArea->items().isEmpty())
>+                origins.append(storageArea->securityOrigin());
>+        }
>+
>+        return origins;
>+    }
>+
>+    void clearStorageAreasMatchingOrigin(const SecurityOriginData& securityOrigin)
>+    {
>+        for (auto& storageArea : m_storageAreaMap.values()) {
>+            if (storageArea->securityOrigin() == securityOrigin)
>+                storageArea->clear();
>+        }
>+    }
>+
>+    void clearAllStorageAreas()
>+    {
>+        for (auto& storageArea : m_storageAreaMap.values())
>+            storageArea->clear();
>+    }
>+
>+private:
>+    explicit SessionStorageNamespace(unsigned quotaInBytes);
>+
>+    HashSet<IPC::Connection::UniqueID> m_allowedConnections;
>+    unsigned m_quotaInBytes;
>+
>+    HashMap<SecurityOriginData, RefPtr<StorageArea>> m_storageAreaMap;
>+};
>+
>+Ref<StorageManager::SessionStorageNamespace> StorageManager::SessionStorageNamespace::create(unsigned quotaInBytes)
>+{
>+    return adoptRef(*new SessionStorageNamespace(quotaInBytes));
>+}
>+
>+StorageManager::SessionStorageNamespace::SessionStorageNamespace(unsigned quotaInBytes)
>+    : m_quotaInBytes(quotaInBytes)
>+{
>+}
>+
>+StorageManager::SessionStorageNamespace::~SessionStorageNamespace()
>+{
>+}
>+
>+void StorageManager::SessionStorageNamespace::addAllowedConnection(IPC::Connection::UniqueID allowedConnection)
>+{
>+    m_allowedConnections.add(allowedConnection);
>+}
>+
>+
>+void StorageManager::SessionStorageNamespace::removeAllowedConnection(IPC::Connection::UniqueID allowedConnection)
>+{
>+    ASSERT(m_allowedConnections.contains(allowedConnection));
>+    m_allowedConnections.remove(allowedConnection);
>+}
>+auto StorageManager::SessionStorageNamespace::getOrCreateStorageArea(SecurityOriginData&& securityOrigin) -> Ref<StorageArea>
>+{
>+    return *m_storageAreaMap.ensure(securityOrigin, [this, securityOrigin]() mutable {
>+        return StorageArea::create(nullptr, WTFMove(securityOrigin), m_quotaInBytes);
>+    }).iterator->value.copyRef();
>+}
>+
>+void StorageManager::SessionStorageNamespace::cloneTo(SessionStorageNamespace& newSessionStorageNamespace)
>+{
>+    ASSERT_UNUSED(newSessionStorageNamespace, newSessionStorageNamespace.isEmpty());
>+
>+    for (auto& pair : m_storageAreaMap)
>+        newSessionStorageNamespace.m_storageAreaMap.add(pair.key, pair.value->clone());
>+}
>+
>+Ref<StorageManager> StorageManager::create(const String& localStorageDirectory)
>+{
>+    return adoptRef(*new StorageManager(localStorageDirectory));
>+}
>+
>+StorageManager::StorageManager(const String& localStorageDirectory)
>+    : m_queue(WorkQueue::create("com.apple.WebKit.StorageManager"))
>+    , m_localStorageDatabaseTracker(LocalStorageDatabaseTracker::create(m_queue.copyRef(), localStorageDirectory))
>+    , m_isEphemeral(localStorageDirectory.isNull())
>+{
>+    // Make sure the encoding is initialized before we start dispatching things to the queue.
>+    UTF8Encoding();
>+}
>+
>+StorageManager::~StorageManager()
>+{
>+}
>+
>+void StorageManager::createSessionStorageNamespace(uint64_t storageNamespaceID, unsigned quotaInBytes)
>+{
>+    m_queue->dispatch([this, protectedThis = makeRef(*this), storageNamespaceID, quotaInBytes]() mutable {
>+        if (m_sessionStorageNamespaces.contains(storageNamespaceID))
>+            return;
>+
>+        m_sessionStorageNamespaces.set(storageNamespaceID, SessionStorageNamespace::create(quotaInBytes));
>+    });
>+}
>+
>+void StorageManager::destroySessionStorageNamespace(uint64_t storageNamespaceID)
>+{
>+    m_queue->dispatch([this, protectedThis = makeRef(*this), storageNamespaceID] {
>+        ASSERT(m_sessionStorageNamespaces.contains(storageNamespaceID));
>+        if (m_sessionStorageNamespaces.get(storageNamespaceID)->allowedConnections().isEmpty())
>+            m_sessionStorageNamespaces.remove(storageNamespaceID);
>+    });
>+}
>+
>+void StorageManager::addAllowedSessionStorageNamespaceConnection(uint64_t storageNamespaceID, IPC::Connection& allowedConnection)
>+{
>+    auto allowedConnectionID = allowedConnection.uniqueID();
>+    m_queue->dispatch([this, protectedThis = makeRef(*this), allowedConnectionID, storageNamespaceID]() mutable {
>+        ASSERT(m_sessionStorageNamespaces.contains(storageNamespaceID));
>+
>+        m_sessionStorageNamespaces.get(storageNamespaceID)->addAllowedConnection(allowedConnectionID);
>+    });
>+}
>+
>+void StorageManager::removeAllowedSessionStorageNamespaceConnection(uint64_t storageNamespaceID, IPC::Connection& allowedConnection)
>+{
>+    auto allowedConnectionID = allowedConnection.uniqueID();
>+    m_queue->dispatch([this, protectedThis = makeRef(*this), allowedConnectionID, storageNamespaceID]() mutable {
>+        ASSERT(m_sessionStorageNamespaces.contains(storageNamespaceID));
>+
>+        m_sessionStorageNamespaces.get(storageNamespaceID)->removeAllowedConnection(allowedConnectionID);
>+    });
>+}
>+
>+void StorageManager::cloneSessionStorageNamespace(uint64_t storageNamespaceID, uint64_t newStorageNamespaceID)
>+{
>+    m_queue->dispatch([this, protectedThis = makeRef(*this), storageNamespaceID, newStorageNamespaceID] {
>+        SessionStorageNamespace* sessionStorageNamespace = m_sessionStorageNamespaces.get(storageNamespaceID);
>+        if (!sessionStorageNamespace) {
>+            // FIXME: We can get into this situation if someone closes the originating page from within a
>+            // createNewPage callback. We bail for now, but we should really find a way to keep the session storage alive
>+            // so we we'll clone the session storage correctly.
>+            return;
>+        }
>+
>+        SessionStorageNamespace* newSessionStorageNamespace = m_sessionStorageNamespaces.get(newStorageNamespaceID);
>+        ASSERT(newSessionStorageNamespace);
>+
>+        sessionStorageNamespace->cloneTo(*newSessionStorageNamespace);
>+    });
>+}
>+
>+void StorageManager::processWillOpenConnection(IPC::Connection& connection)
>+{
>+    connection.addWorkQueueMessageReceiver(Messages::StorageManager::messageReceiverName(), m_queue.get(), this);
>+}
>+
>+void StorageManager::processDidCloseConnection(IPC::Connection& connection)
>+{
>+    connection.removeWorkQueueMessageReceiver(Messages::StorageManager::messageReceiverName());
>+
>+    m_queue->dispatch([this, protectedThis = makeRef(*this), connectionID = connection.uniqueID()]() mutable {
>+        Vector<std::pair<IPC::Connection::UniqueID, uint64_t>> connectionAndStorageMapIDPairsToRemove;
>+        for (auto& storageArea : m_storageAreasByConnection) {
>+            if (storageArea.key.first != connectionID)
>+                continue;
>+            
>+            storageArea.value->removeListener(storageArea.key.first, storageArea.key.second);
>+            connectionAndStorageMapIDPairsToRemove.append(storageArea.key);
>+        }
>+        
>+        for (auto& pair : connectionAndStorageMapIDPairsToRemove)
>+            m_storageAreasByConnection.remove(pair);
>+    });
>+}
>+
>+void StorageManager::getSessionStorageOrigins(Function<void(HashSet<WebCore::SecurityOriginData>&&)>&& completionHandler)
>+{
>+    m_queue->dispatch([this, protectedThis = makeRef(*this), completionHandler = WTFMove(completionHandler)]() mutable {
>+        HashSet<SecurityOriginData> origins;
>+
>+        for (const auto& sessionStorageNamespace : m_sessionStorageNamespaces.values()) {
>+            for (auto& origin : sessionStorageNamespace->origins())
>+                origins.add(origin);
>+        }
>+
>+        RunLoop::main().dispatch([origins = WTFMove(origins), completionHandler = WTFMove(completionHandler)]() mutable {
>+            completionHandler(WTFMove(origins));
>+        });
>+    });
>+}
>+
>+void StorageManager::deleteSessionStorageOrigins(Function<void()>&& completionHandler)
>+{
>+    m_queue->dispatch([this, protectedThis = makeRef(*this), completionHandler = WTFMove(completionHandler)]() mutable {
>+        for (auto& sessionStorageNamespace : m_sessionStorageNamespaces.values())
>+            sessionStorageNamespace->clearAllStorageAreas();
>+
>+        RunLoop::main().dispatch(WTFMove(completionHandler));
>+    });
>+}
>+
>+void StorageManager::deleteSessionStorageEntriesForOrigins(const Vector<WebCore::SecurityOriginData>& origins, Function<void()>&& completionHandler)
>+{
>+    Vector<WebCore::SecurityOriginData> copiedOrigins;
>+    copiedOrigins.reserveInitialCapacity(origins.size());
>+
>+    for (auto& origin : origins)
>+        copiedOrigins.uncheckedAppend(origin.isolatedCopy());
>+
>+    m_queue->dispatch([this, protectedThis = makeRef(*this), copiedOrigins = WTFMove(copiedOrigins), completionHandler = WTFMove(completionHandler)]() mutable {
>+        for (auto& origin : copiedOrigins) {
>+            for (auto& sessionStorageNamespace : m_sessionStorageNamespaces.values())
>+                sessionStorageNamespace->clearStorageAreasMatchingOrigin(origin);
>+        }
>+
>+        RunLoop::main().dispatch(WTFMove(completionHandler));
>+    });
>+}
>+
>+void StorageManager::getLocalStorageOrigins(Function<void(HashSet<WebCore::SecurityOriginData>&&)>&& completionHandler)
>+{
>+    m_queue->dispatch([this, protectedThis = makeRef(*this), completionHandler = WTFMove(completionHandler)]() mutable {
>+        HashSet<SecurityOriginData> origins;
>+
>+        for (auto& origin : m_localStorageDatabaseTracker->origins())
>+            origins.add(origin);
>+
>+        for (auto& transientLocalStorageNamespace : m_transientLocalStorageNamespaces.values()) {
>+            for (auto& origin : transientLocalStorageNamespace->origins())
>+                origins.add(origin);
>+        }
>+
>+        RunLoop::main().dispatch([origins = WTFMove(origins), completionHandler = WTFMove(completionHandler)]() mutable {
>+            completionHandler(WTFMove(origins));
>+        });
>+    });
>+}
>+
>+void StorageManager::getLocalStorageOriginDetails(Function<void(Vector<LocalStorageDatabaseTracker::OriginDetails>)>&& completionHandler)
>+{
>+    m_queue->dispatch([this, protectedThis = makeRef(*this), completionHandler = WTFMove(completionHandler)]() mutable {
>+        auto originDetails = m_localStorageDatabaseTracker->originDetails();
>+
>+        RunLoop::main().dispatch([originDetails = WTFMove(originDetails), completionHandler = WTFMove(completionHandler)]() mutable {
>+            completionHandler(WTFMove(originDetails));
>+        });
>+    });
>+}
>+
>+void StorageManager::deleteLocalStorageEntriesForOrigin(const SecurityOriginData& securityOrigin)
>+{
>+    m_queue->dispatch([this, protectedThis = makeRef(*this), copiedOrigin = securityOrigin.isolatedCopy()]() mutable {
>+        for (auto& localStorageNamespace : m_localStorageNamespaces.values())
>+            localStorageNamespace->clearStorageAreasMatchingOrigin(copiedOrigin);
>+
>+        for (auto& transientLocalStorageNamespace : m_transientLocalStorageNamespaces.values())
>+            transientLocalStorageNamespace->clearStorageAreasMatchingOrigin(copiedOrigin);
>+
>+        m_localStorageDatabaseTracker->deleteDatabaseWithOrigin(copiedOrigin);
>+    });
>+}
>+
>+void StorageManager::deleteLocalStorageOriginsModifiedSince(WallTime time, Function<void()>&& completionHandler)
>+{
>+    m_queue->dispatch([this, protectedThis = makeRef(*this), time, completionHandler = WTFMove(completionHandler)]() mutable {
>+        auto originsToDelete = m_localStorageDatabaseTracker->databasesModifiedSince(time);
>+        
>+        for (auto& transientLocalStorageNamespace : m_transientLocalStorageNamespaces.values())
>+            transientLocalStorageNamespace->clearAllStorageAreas();
>+
>+        for (const auto& origin : originsToDelete) {
>+            for (auto& localStorageNamespace : m_localStorageNamespaces.values())
>+                localStorageNamespace->clearStorageAreasMatchingOrigin(origin);
>+            
>+            m_localStorageDatabaseTracker->deleteDatabaseWithOrigin(origin);
>+        }
>+
>+        RunLoop::main().dispatch(WTFMove(completionHandler));
>+    });
>+}
>+
>+void StorageManager::deleteLocalStorageEntriesForOrigins(const Vector<WebCore::SecurityOriginData>& origins, Function<void()>&& completionHandler)
>+{
>+    Vector<SecurityOriginData> copiedOrigins;
>+    copiedOrigins.reserveInitialCapacity(origins.size());
>+
>+    for (auto& origin : origins)
>+        copiedOrigins.uncheckedAppend(origin.isolatedCopy());
>+
>+    m_queue->dispatch([this, protectedThis = makeRef(*this), copiedOrigins = WTFMove(copiedOrigins), completionHandler = WTFMove(completionHandler)]() mutable {
>+        for (auto& origin : copiedOrigins) {
>+            for (auto& localStorageNamespace : m_localStorageNamespaces.values())
>+                localStorageNamespace->clearStorageAreasMatchingOrigin(origin);
>+
>+            for (auto& transientLocalStorageNamespace : m_transientLocalStorageNamespaces.values())
>+                transientLocalStorageNamespace->clearStorageAreasMatchingOrigin(origin);
>+
>+            m_localStorageDatabaseTracker->deleteDatabaseWithOrigin(origin);
>+        }
>+
>+        RunLoop::main().dispatch(WTFMove(completionHandler));
>+    });
>+}
>+
>+void StorageManager::createLocalStorageMap(IPC::Connection& connection, uint64_t storageMapID, uint64_t storageNamespaceID, SecurityOriginData&& securityOriginData)
>+{
>+    ASSERT(!m_isEphemeral);
>+    std::pair<IPC::Connection::UniqueID, uint64_t> connectionAndStorageMapIDPair(connection.uniqueID(), storageMapID);
>+
>+    // FIXME: This should be a message check.
>+    ASSERT((HashMap<std::pair<IPC::Connection::UniqueID, uint64_t>, RefPtr<StorageArea>>::isValidKey(connectionAndStorageMapIDPair)));
>+
>+    auto result = m_storageAreasByConnection.add(connectionAndStorageMapIDPair, nullptr);
>+
>+    // FIXME: These should be a message checks.
>+    ASSERT(result.isNewEntry);
>+    ASSERT((HashMap<uint64_t, RefPtr<LocalStorageNamespace>>::isValidKey(storageNamespaceID)));
>+
>+    LocalStorageNamespace* localStorageNamespace = getOrCreateLocalStorageNamespace(storageNamespaceID);
>+
>+    // FIXME: This should be a message check.
>+    ASSERT(localStorageNamespace);
>+
>+    auto storageArea = localStorageNamespace->getOrCreateStorageArea(WTFMove(securityOriginData));
>+    storageArea->addListener(connection.uniqueID(), storageMapID);
>+
>+    result.iterator->value = WTFMove(storageArea);
>+}
>+
>+void StorageManager::createTransientLocalStorageMap(IPC::Connection& connection, uint64_t storageMapID, uint64_t storageNamespaceID, SecurityOriginData&& topLevelOriginData, SecurityOriginData&& origin)
>+{
>+    // FIXME: This should be a message check.
>+    ASSERT(m_storageAreasByConnection.isValidKey({ connection.uniqueID(), storageMapID }));
>+
>+    // See if we already have session storage for this connection/origin combo.
>+    // If so, update the map with the new ID, otherwise keep on trucking.
>+    for (auto it = m_storageAreasByConnection.begin(), end = m_storageAreasByConnection.end(); it != end; ++it) {
>+        if (it->key.first != connection.uniqueID())
>+            continue;
>+        Ref<StorageArea> area = *it->value;
>+        if (!area->isSessionStorage())
>+            continue;
>+        if (!origin.securityOrigin()->isSameSchemeHostPort(area->securityOrigin().securityOrigin().get()))
>+            continue;
>+        area->addListener(connection.uniqueID(), storageMapID);
>+        // If the storageMapID used as key in m_storageAreasByConnection is no longer one of the StorageArea's listeners, then this means
>+        // that destroyStorageMap() was already called for that storageMapID but it decided not to remove it from m_storageAreasByConnection
>+        // so that we could reuse it later on for the same connection/origin combo. In this case, it is safe to remove the previous
>+        // storageMapID from m_storageAreasByConnection.
>+        if (!area->hasListener(connection.uniqueID(), it->key.second))
>+            m_storageAreasByConnection.remove(it);
>+        m_storageAreasByConnection.add({ connection.uniqueID(), storageMapID }, WTFMove(area));
>+        return;
>+    }
>+
>+    auto& slot = m_storageAreasByConnection.add({ connection.uniqueID(), storageMapID }, nullptr).iterator->value;
>+
>+    // FIXME: This should be a message check.
>+    ASSERT(!slot);
>+
>+    TransientLocalStorageNamespace* transientLocalStorageNamespace = getOrCreateTransientLocalStorageNamespace(storageNamespaceID, WTFMove(topLevelOriginData));
>+
>+    auto storageArea = transientLocalStorageNamespace->getOrCreateStorageArea(WTFMove(origin));
>+    storageArea->addListener(connection.uniqueID(), storageMapID);
>+
>+    slot = WTFMove(storageArea);
>+}
>+
>+void StorageManager::createSessionStorageMap(IPC::Connection& connection, uint64_t storageMapID, uint64_t storageNamespaceID, SecurityOriginData&& securityOriginData)
>+{
>+    if (m_isEphemeral) {
>+        m_ephemeralStorage.add(securityOriginData, WebCore::StorageMap::create(localStorageDatabaseQuotaInBytes));
>+        return;
>+    }
>+    // FIXME: This should be a message check.
>+    ASSERT(m_sessionStorageNamespaces.isValidKey(storageNamespaceID));
>+
>+    SessionStorageNamespace* sessionStorageNamespace = m_sessionStorageNamespaces.get(storageNamespaceID);
>+    if (!sessionStorageNamespace) {
>+        // We're getting an incoming message from the web process that's for session storage for a web page
>+        // that has already been closed, just ignore it.
>+        return;
>+    }
>+
>+    // FIXME: This should be a message check.
>+    ASSERT(m_storageAreasByConnection.isValidKey({ connection.uniqueID(), storageMapID }));
>+
>+    auto& slot = m_storageAreasByConnection.add({ connection.uniqueID(), storageMapID }, nullptr).iterator->value;
>+
>+    // FIXME: This should be a message check.
>+    ASSERT(!slot);
>+
>+    // FIXME: This should be a message check.
>+    ASSERT(sessionStorageNamespace->allowedConnections().contains(connection.uniqueID()));
>+
>+    auto storageArea = sessionStorageNamespace->getOrCreateStorageArea(WTFMove(securityOriginData));
>+    storageArea->addListener(connection.uniqueID(), storageMapID);
>+
>+    slot = WTFMove(storageArea);
>+}
>+
>+void StorageManager::destroyStorageMap(IPC::Connection& connection, uint64_t storageMapID)
>+{
>+    std::pair<IPC::Connection::UniqueID, uint64_t> connectionAndStorageMapIDPair(connection.uniqueID(), storageMapID);
>+
>+    // FIXME: This should be a message check.
>+    ASSERT(m_storageAreasByConnection.isValidKey(connectionAndStorageMapIDPair));
>+
>+    auto it = m_storageAreasByConnection.find(connectionAndStorageMapIDPair);
>+    if (it == m_storageAreasByConnection.end()) {
>+        // The connection has been removed because the last page was closed.
>+        return;
>+    }
>+
>+    it->value->removeListener(connection.uniqueID(), storageMapID);
>+
>+    // Don't remove session storage maps. The web process may reconnect and expect the data to still be around.
>+    if (it->value->isSessionStorage())
>+        return;
>+
>+    m_storageAreasByConnection.remove(connectionAndStorageMapIDPair);
>+}
>+
>+void StorageManager::getValues(IPC::Connection& connection, WebCore::SecurityOriginData&& securityOriginData, uint64_t storageMapID, uint64_t storageMapSeed, CompletionHandler<void(const HashMap<String, String>&)>&& completionHandler)
>+{
>+    StorageArea* storageArea = findStorageArea(connection, storageMapID);
>+    if (!storageArea) {
>+        if (m_isEphemeral) {
>+            if (auto storageMap = m_ephemeralStorage.get(securityOriginData))
>+                return completionHandler(storageMap->items());
>+        }
>+        // This is a session storage area for a page that has already been closed. Ignore it.
>+        return completionHandler({ });
>+    }
>+
>+    completionHandler(storageArea->items());
>+    connection.send(Messages::StorageAreaMap::DidGetValues(storageMapSeed), storageMapID);
>+}
>+
>+void StorageManager::setItem(IPC::Connection& connection, WebCore::SecurityOriginData&& securityOriginData, uint64_t storageMapID, uint64_t sourceStorageAreaID, uint64_t storageMapSeed, const String& key, const String& value, const String& urlString)
>+{
>+    StorageArea* storageArea = findStorageArea(connection, storageMapID);
>+    if (!storageArea) {
>+        if (m_isEphemeral) {
>+            if (auto storageMap = m_ephemeralStorage.get(securityOriginData)) {
>+                String oldValue;
>+                bool quotaException;
>+                storageMap->setItem(key, value, oldValue, quotaException);
>+            }
>+        }
>+        // This is a session storage area for a page that has already been closed. Ignore it.
>+        return;
>+    }
>+
>+    bool quotaError;
>+    storageArea->setItem(connection.uniqueID(), sourceStorageAreaID, key, value, urlString, quotaError);
>+    connection.send(Messages::StorageAreaMap::DidSetItem(storageMapSeed, key, quotaError), storageMapID);
>+}
>+
>+void StorageManager::removeItem(IPC::Connection& connection, WebCore::SecurityOriginData&& securityOriginData, uint64_t storageMapID, uint64_t sourceStorageAreaID, uint64_t storageMapSeed, const String& key, const String& urlString)
>+{
>+    StorageArea* storageArea = findStorageArea(connection, storageMapID);
>+    if (!storageArea) {
>+        if (m_isEphemeral) {
>+            if (auto storageMap = m_ephemeralStorage.get(securityOriginData)) {
>+                String oldValue;
>+                storageMap->removeItem(key, oldValue);
>+            }
>+        }
>+        // This is a session storage area for a page that has already been closed. Ignore it.
>+        return;
>+    }
>+
>+    storageArea->removeItem(connection.uniqueID(), sourceStorageAreaID, key, urlString);
>+    connection.send(Messages::StorageAreaMap::DidRemoveItem(storageMapSeed, key), storageMapID);
>+}
>+
>+void StorageManager::clear(IPC::Connection& connection, WebCore::SecurityOriginData&& securityOriginData, uint64_t storageMapID, uint64_t sourceStorageAreaID, uint64_t storageMapSeed, const String& urlString)
>+{
>+    StorageArea* storageArea = findStorageArea(connection, storageMapID);
>+    if (!storageArea) {
>+        if (m_isEphemeral)
>+            m_ephemeralStorage.remove(securityOriginData);
>+        // This is a session storage area for a page that has already been closed. Ignore it.
>+        return;
>+    }
>+
>+    storageArea->clear(connection.uniqueID(), sourceStorageAreaID, urlString);
>+    connection.send(Messages::StorageAreaMap::DidClear(storageMapSeed), storageMapID);
>+}
>+
>+void StorageManager::waitUntilWritesFinished()
>+{
>+    BinarySemaphore semaphore;
>+    m_queue->dispatch([this, &semaphore] {
>+        Vector<std::pair<IPC::Connection::UniqueID, uint64_t>> connectionAndStorageMapIDPairsToRemove;
>+        for (auto& connectionStorageAreaPair : m_storageAreasByConnection) {
>+            connectionStorageAreaPair.value->removeListener(connectionStorageAreaPair.key.first, connectionStorageAreaPair.key.second);
>+            connectionAndStorageMapIDPairsToRemove.append(connectionStorageAreaPair.key);
>+        }
>+
>+        for (auto& connectionStorageAreaPair : connectionAndStorageMapIDPairsToRemove)
>+            m_storageAreasByConnection.remove(connectionStorageAreaPair);
>+
>+        semaphore.signal();
>+    });
>+    semaphore.wait();
>+}
>+
>+StorageManager::StorageArea* StorageManager::findStorageArea(IPC::Connection& connection, uint64_t storageMapID) const
>+{
>+    std::pair<IPC::Connection::UniqueID, uint64_t> connectionAndStorageMapIDPair(connection.uniqueID(), storageMapID);
>+
>+    if (!m_storageAreasByConnection.isValidKey(connectionAndStorageMapIDPair))
>+        return nullptr;
>+
>+    return m_storageAreasByConnection.get(connectionAndStorageMapIDPair);
>+}
>+
>+StorageManager::LocalStorageNamespace* StorageManager::getOrCreateLocalStorageNamespace(uint64_t storageNamespaceID)
>+{
>+    if (!m_localStorageNamespaces.isValidKey(storageNamespaceID))
>+        return nullptr;
>+
>+    auto& slot = m_localStorageNamespaces.add(storageNamespaceID, nullptr).iterator->value;
>+    if (!slot)
>+        slot = LocalStorageNamespace::create(this, storageNamespaceID);
>+
>+    return slot.get();
>+}
>+
>+StorageManager::TransientLocalStorageNamespace* StorageManager::getOrCreateTransientLocalStorageNamespace(uint64_t storageNamespaceID, WebCore::SecurityOriginData&& topLevelOrigin)
>+{
>+    if (!m_transientLocalStorageNamespaces.isValidKey({ storageNamespaceID, topLevelOrigin }))
>+        return nullptr;
>+
>+    auto& slot = m_transientLocalStorageNamespaces.add({ storageNamespaceID, WTFMove(topLevelOrigin) }, nullptr).iterator->value;
>+    if (!slot)
>+        slot = TransientLocalStorageNamespace::create();
>+
>+    return slot.get();
>+}
>+
>+void StorageManager::dispatchMessageToQueue(IPC::Connection& connection, IPC::Decoder& decoder)
>+{
>+    m_queue->dispatch([this, protectedThis = makeRef(*this), &connection, &decoder] {
>+        didReceiveMessage(connection, decoder);
>+    });
>+}
>+
>+void StorageManager::dispatchSyncMessageToQueue(IPC::Connection& connection, IPC::Decoder& decoder, std::unique_ptr<IPC::Encoder>& replyEncoder)
>+{
>+    m_queue->dispatch([this, protectedThis = makeRef(*this), &connection, &decoder, replyEncoder = WTFMove(replyEncoder)] () mutable {
>+        didReceiveSyncMessage(connection, decoder, replyEncoder);
>+    });
>+}
>+
>+} // namespace WebKit
>diff --git a/Source/WebKit/NetworkProcess/WebStorage/StorageManager.h b/Source/WebKit/NetworkProcess/WebStorage/StorageManager.h
>new file mode 100644
>index 0000000000000000000000000000000000000000..49fdbe3f30a7cc0241c6d1e79d394f3316da8688
>--- /dev/null
>+++ b/Source/WebKit/NetworkProcess/WebStorage/StorageManager.h
>@@ -0,0 +1,121 @@
>+/*
>+ * Copyright (C) 2013-2019 Apple Inc. All rights reserved.
>+ *
>+ * Redistribution and use in source and binary forms, with or without
>+ * modification, are permitted provided that the following conditions
>+ * are met:
>+ * 1. Redistributions of source code must retain the above copyright
>+ *    notice, this list of conditions and the following disclaimer.
>+ * 2. Redistributions in binary form must reproduce the above copyright
>+ *    notice, this list of conditions and the following disclaimer in the
>+ *    documentation and/or other materials provided with the distribution.
>+ *
>+ * THIS SOFTWARE IS PROVIDED BY APPLE INC. AND ITS CONTRIBUTORS ``AS IS''
>+ * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO,
>+ * THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
>+ * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL APPLE INC. OR ITS CONTRIBUTORS
>+ * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
>+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
>+ * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
>+ * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
>+ * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
>+ * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF
>+ * THE POSSIBILITY OF SUCH DAMAGE.
>+ */
>+
>+#pragma once
>+
>+#include "Connection.h"
>+#include "LocalStorageDatabaseTracker.h"
>+#include <WebCore/SecurityOriginData.h>
>+#include <WebCore/StorageMap.h>
>+#include <wtf/Forward.h>
>+#include <wtf/Function.h>
>+#include <wtf/HashSet.h>
>+#include <wtf/ThreadSafeRefCounted.h>
>+#include <wtf/text/StringHash.h>
>+
>+namespace WebCore {
>+class SecurityOrigin;
>+}
>+
>+namespace WebKit {
>+
>+class LocalStorageDatabaseTracker;
>+class WebProcessProxy;
>+
>+class StorageManager : public IPC::Connection::WorkQueueMessageReceiver {
>+public:
>+    static Ref<StorageManager> create(const String& localStorageDirectory);
>+    ~StorageManager();
>+
>+    void createSessionStorageNamespace(uint64_t storageNamespaceID, unsigned quotaInBytes);
>+    void destroySessionStorageNamespace(uint64_t storageNamespaceID);
>+    void addAllowedSessionStorageNamespaceConnection(uint64_t storageNamespaceID, IPC::Connection&);
>+    void removeAllowedSessionStorageNamespaceConnection(uint64_t storageNamespaceID, IPC::Connection&);
>+    void cloneSessionStorageNamespace(uint64_t storageNamespaceID, uint64_t newStorageNamespaceID);
>+
>+    void processWillOpenConnection(IPC::Connection&);
>+    void processDidCloseConnection(IPC::Connection&);
>+    void waitUntilWritesFinished();
>+
>+    void getSessionStorageOrigins(Function<void(HashSet<WebCore::SecurityOriginData>&&)>&& completionHandler);
>+    void deleteSessionStorageOrigins(Function<void()>&& completionHandler);
>+    void deleteSessionStorageEntriesForOrigins(const Vector<WebCore::SecurityOriginData>&, Function<void()>&& completionHandler);
>+
>+    void getLocalStorageOrigins(Function<void(HashSet<WebCore::SecurityOriginData>&&)>&& completionHandler);
>+    void deleteLocalStorageEntriesForOrigin(const WebCore::SecurityOriginData&);
>+
>+    void deleteLocalStorageOriginsModifiedSince(WallTime, Function<void()>&& completionHandler);
>+    void deleteLocalStorageEntriesForOrigins(const Vector<WebCore::SecurityOriginData>&, Function<void()>&& completionHandler);
>+
>+    void getLocalStorageOriginDetails(Function<void(Vector<LocalStorageDatabaseTracker::OriginDetails>)>&& completionHandler);
>+
>+    void dispatchMessageToQueue(IPC::Connection&, IPC::Decoder&);
>+    void dispatchSyncMessageToQueue(IPC::Connection&, IPC::Decoder&, std::unique_ptr<IPC::Encoder>& replyEncoder);
>+
>+private:
>+    explicit StorageManager(const String& localStorageDirectory);
>+
>+    // IPC::Connection::WorkQueueMessageReceiver.
>+    void didReceiveMessage(IPC::Connection&, IPC::Decoder&) override;
>+    void didReceiveSyncMessage(IPC::Connection&, IPC::Decoder&, std::unique_ptr<IPC::Encoder>& replyEncoder) override;
>+
>+    // Message handlers.
>+    void createLocalStorageMap(IPC::Connection&, uint64_t storageMapID, uint64_t storageNamespaceID, WebCore::SecurityOriginData&&);
>+    void createTransientLocalStorageMap(IPC::Connection&, uint64_t storageMapID, uint64_t storageNamespaceID, WebCore::SecurityOriginData&& topLevelOriginData, WebCore::SecurityOriginData&&);
>+    void createSessionStorageMap(IPC::Connection&, uint64_t storageMapID, uint64_t storageNamespaceID, WebCore::SecurityOriginData&&);
>+    void destroyStorageMap(IPC::Connection&, uint64_t storageMapID);
>+
>+    void getValues(IPC::Connection&, WebCore::SecurityOriginData&&, uint64_t storageMapID, uint64_t storageMapSeed, CompletionHandler<void(const HashMap<String, String>&)>&&);
>+    void setItem(IPC::Connection&, WebCore::SecurityOriginData&&, uint64_t storageMapID, uint64_t sourceStorageAreaID, uint64_t storageMapSeed, const String& key, const String& value, const String& urlString);
>+    void removeItem(IPC::Connection&, WebCore::SecurityOriginData&&, uint64_t storageMapID, uint64_t sourceStorageAreaID, uint64_t storageMapSeed, const String& key, const String& urlString);
>+    void clear(IPC::Connection&, WebCore::SecurityOriginData&&, uint64_t storageMapID, uint64_t sourceStorageAreaID, uint64_t storageMapSeed, const String& urlString);
>+
>+    class StorageArea;
>+    StorageArea* findStorageArea(IPC::Connection&, uint64_t) const;
>+
>+    class LocalStorageNamespace;
>+    LocalStorageNamespace* getOrCreateLocalStorageNamespace(uint64_t storageNamespaceID);
>+
>+    class TransientLocalStorageNamespace;
>+    TransientLocalStorageNamespace* getOrCreateTransientLocalStorageNamespace(uint64_t storageNamespaceID, WebCore::SecurityOriginData&& topLevelOrigin);
>+
>+    Ref<WorkQueue> m_queue;
>+
>+    Ref<LocalStorageDatabaseTracker> m_localStorageDatabaseTracker;
>+    HashMap<uint64_t, RefPtr<LocalStorageNamespace>> m_localStorageNamespaces;
>+
>+    HashMap<std::pair<uint64_t, WebCore::SecurityOriginData>, RefPtr<TransientLocalStorageNamespace>> m_transientLocalStorageNamespaces;
>+
>+    class SessionStorageNamespace;
>+    HashMap<uint64_t, RefPtr<SessionStorageNamespace>> m_sessionStorageNamespaces;
>+
>+    HashMap<std::pair<IPC::Connection::UniqueID, uint64_t>, RefPtr<StorageArea>> m_storageAreasByConnection;
>+
>+    HashMap<WebCore::SecurityOriginData, Ref<WebCore::StorageMap>> m_ephemeralStorage;
>+    bool m_isEphemeral { false };
>+
>+};
>+
>+} // namespace WebKit
>diff --git a/Source/WebKit/NetworkProcess/WebStorage/StorageManager.messages.in b/Source/WebKit/NetworkProcess/WebStorage/StorageManager.messages.in
>new file mode 100644
>index 0000000000000000000000000000000000000000..b3b6dbf279803514e535b1e0374db7dbe9969cba
>--- /dev/null
>+++ b/Source/WebKit/NetworkProcess/WebStorage/StorageManager.messages.in
>@@ -0,0 +1,34 @@
>+# Copyright (C) 2013 Apple Inc. All rights reserved.
>+#
>+# Redistribution and use in source and binary forms, with or without
>+# modification, are permitted provided that the following conditions
>+# are met:
>+# 1.  Redistributions of source code must retain the above copyright
>+#     notice, this list of conditions and the following disclaimer.
>+# 2.  Redistributions in binary form must reproduce the above copyright
>+#     notice, this list of conditions and the following disclaimer in the
>+#     documentation and/or other materials provided with the distribution.
>+#
>+# THIS SOFTWARE IS PROVIDED BY APPLE INC. AND ITS CONTRIBUTORS ``AS IS'' AND
>+# ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
>+# WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
>+# DISCLAIMED. IN NO EVENT SHALL APPLE INC. OR ITS CONTRIBUTORS BE LIABLE FOR
>+# ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
>+# DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
>+# SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
>+# CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
>+# OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
>+# OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
>+
>+messages -> StorageManager {
>+    CreateLocalStorageMap(uint64_t storageMapID, uint64_t storageNamespaceID, struct WebCore::SecurityOriginData securityOriginData) WantsConnection
>+    CreateTransientLocalStorageMap(uint64_t storageMapID, uint64_t storageNamespaceID, struct WebCore::SecurityOriginData topLevelSecurityOriginData, struct WebCore::SecurityOriginData securityOriginData) WantsConnection
>+    CreateSessionStorageMap(uint64_t storageMapID, uint64_t storageNamespaceID, struct WebCore::SecurityOriginData securityOriginData) WantsConnection
>+    DestroyStorageMap(uint64_t storageMapID) WantsConnection
>+
>+    GetValues(struct WebCore::SecurityOriginData securityOriginData, uint64_t storageMapID, uint64_t storageMapSeed) -> (HashMap<String, String> values) Synchronous WantsConnection
>+
>+    SetItem(struct WebCore::SecurityOriginData securityOriginData, uint64_t storageMapID, uint64_t sourceStorageAreaID, uint64_t storageMapSeed, String key, String value, String urlString) WantsConnection
>+    RemoveItem(struct WebCore::SecurityOriginData securityOriginData, uint64_t storageMapID, uint64_t sourceStorageAreaID, uint64_t storageMapSeed, String key, String urlString) WantsConnection
>+    Clear(struct WebCore::SecurityOriginData securityOriginData, uint64_t storageMapID, uint64_t sourceStorageAreaID, uint64_t storageMapSeed, String urlString) WantsConnection
>+}
>diff --git a/Source/WebKit/NetworkProcess/WebStorage/ios/LocalStorageDatabaseTrackerIOS.mm b/Source/WebKit/NetworkProcess/WebStorage/ios/LocalStorageDatabaseTrackerIOS.mm
>new file mode 100644
>index 0000000000000000000000000000000000000000..9b01e896360f42c9f5097ff280b7ff615e65414f
>--- /dev/null
>+++ b/Source/WebKit/NetworkProcess/WebStorage/ios/LocalStorageDatabaseTrackerIOS.mm
>@@ -0,0 +1,48 @@
>+/*
>+ * Copyright (C) 2017 Apple Inc. All rights reserved.
>+ *
>+ * Redistribution and use in source and binary forms, with or without
>+ * modification, are permitted provided that the following conditions
>+ * are met:
>+ * 1. Redistributions of source code must retain the above copyright
>+ *    notice, this list of conditions and the following disclaimer.
>+ * 2. Redistributions in binary form must reproduce the above copyright
>+ *    notice, this list of conditions and the following disclaimer in the
>+ *    documentation and/or other materials provided with the distribution.
>+ *
>+ * THIS SOFTWARE IS PROVIDED BY APPLE INC. AND ITS CONTRIBUTORS ``AS IS''
>+ * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO,
>+ * THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
>+ * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL APPLE INC. OR ITS CONTRIBUTORS
>+ * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
>+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
>+ * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
>+ * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
>+ * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
>+ * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF
>+ * THE POSSIBILITY OF SUCH DAMAGE.
>+ */
>+
>+#include "config.h"
>+#include "LocalStorageDatabaseTracker.h"
>+
>+#if PLATFORM(IOS_FAMILY)
>+
>+#include "VersionChecks.h"
>+
>+namespace WebKit {
>+
>+void LocalStorageDatabaseTracker::platformMaybeExcludeFromBackup() const
>+{
>+    if (m_hasExcludedFromBackup)
>+        return;
>+
>+    m_hasExcludedFromBackup = true;
>+
>+    if (linkedOnOrAfter(SDKVersion::FirstToExcludeLocalStorageFromBackup))
>+        [[NSURL fileURLWithPath:(NSString *)m_localStorageDirectory isDirectory:YES] setResourceValue:@YES forKey:NSURLIsExcludedFromBackupKey error:nil];
>+}
>+
>+} // namespace WebKit
>+
>+#endif
>diff --git a/Source/WebKit/NetworkProcess/WebStorage/ios/LocalStorageDatabaseTrackerIOS.mm.orig b/Source/WebKit/NetworkProcess/WebStorage/ios/LocalStorageDatabaseTrackerIOS.mm.orig
>new file mode 100644
>index 0000000000000000000000000000000000000000..a179f8cf942aacb3b4f29f3ddf26062a6bbfd508
>--- /dev/null
>+++ b/Source/WebKit/NetworkProcess/WebStorage/ios/LocalStorageDatabaseTrackerIOS.mm.orig
>@@ -0,0 +1,48 @@
>+/*
>+ * Copyright (C) 2017-2019 Apple Inc. All rights reserved.
>+ *
>+ * Redistribution and use in source and binary forms, with or without
>+ * modification, are permitted provided that the following conditions
>+ * are met:
>+ * 1. Redistributions of source code must retain the above copyright
>+ *    notice, this list of conditions and the following disclaimer.
>+ * 2. Redistributions in binary form must reproduce the above copyright
>+ *    notice, this list of conditions and the following disclaimer in the
>+ *    documentation and/or other materials provided with the distribution.
>+ *
>+ * THIS SOFTWARE IS PROVIDED BY APPLE INC. AND ITS CONTRIBUTORS ``AS IS''
>+ * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO,
>+ * THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
>+ * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL APPLE INC. OR ITS CONTRIBUTORS
>+ * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
>+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
>+ * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
>+ * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
>+ * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
>+ * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF
>+ * THE POSSIBILITY OF SUCH DAMAGE.
>+ */
>+
>+#include "config.h"
>+#include "LocalStorageDatabaseTracker.h"
>+
>+#if PLATFORM(IOS_FAMILY)
>+
>+#include "VersionChecks.h"
>+
>+namespace WebKit {
>+
>+void LocalStorageDatabaseTracker::platformMaybeExcludeFromBackup() const
>+{
>+    if (m_hasExcludedFromBackup)
>+        return;
>+
>+    m_hasExcludedFromBackup = true;
>+
>+    if (linkedOnOrAfter(SDKVersion::FirstToExcludeLocalStorageFromBackup))
>+        [[NSURL fileURLWithPath:(NSString *)m_localStorageDirectory isDirectory:YES] setResourceValue:@YES forKey:NSURLIsExcludedFromBackupKey error:nil];
>+}
>+
>+} // namespace WebKit
>+
>+#endif
>diff --git a/Source/WebKit/NetworkProcess/cocoa/NetworkSessionCocoa.mm b/Source/WebKit/NetworkProcess/cocoa/NetworkSessionCocoa.mm
>index 60bca0b3d9ecc37fedccfc93b10a37ae01362f65..c4ca391df7eb819a686dbbcf01fbcd647cee71db 100644
>--- a/Source/WebKit/NetworkProcess/cocoa/NetworkSessionCocoa.mm
>+++ b/Source/WebKit/NetworkProcess/cocoa/NetworkSessionCocoa.mm
>@@ -875,7 +875,7 @@ static NSDictionary *proxyDictionary(const URL& httpProxy, const URL& httpsProxy
> }
> 
> NetworkSessionCocoa::NetworkSessionCocoa(NetworkProcess& networkProcess, NetworkSessionCreationParameters&& parameters)
>-    : NetworkSession(networkProcess, parameters.sessionID)
>+    : NetworkSession(networkProcess, parameters.sessionID, parameters.localStorageDirectory, parameters.localStorageDirectoryExtensionHandle)
>     , m_boundInterfaceIdentifier(parameters.boundInterfaceIdentifier)
>     , m_sourceApplicationBundleIdentifier(parameters.sourceApplicationBundleIdentifier)
>     , m_sourceApplicationSecondaryIdentifier(parameters.sourceApplicationSecondaryIdentifier)
>diff --git a/Source/WebKit/NetworkProcess/curl/NetworkSessionCurl.cpp b/Source/WebKit/NetworkProcess/curl/NetworkSessionCurl.cpp
>index ec8abcb7960a8490593139f81608733f510b787d..660e9b02cb386a68692b28cfbaa9e6e57dc65f48 100644
>--- a/Source/WebKit/NetworkProcess/curl/NetworkSessionCurl.cpp
>+++ b/Source/WebKit/NetworkProcess/curl/NetworkSessionCurl.cpp
>@@ -38,7 +38,7 @@ namespace WebKit {
> using namespace WebCore;
> 
> NetworkSessionCurl::NetworkSessionCurl(NetworkProcess& networkProcess, NetworkSessionCreationParameters&& parameters)
>-    : NetworkSession(networkProcess, parameters.sessionID)
>+    : NetworkSession(networkProcess, parameters.sessionID, parameters.localStorageDirectory, parameters.localStorageDirectoryExtensionHandle)
> {
>     if (!parameters.cookiePersistentStorageFile.isEmpty())
>         networkStorageSession().setCookieDatabase(makeUniqueRef<CookieJarDB>(parameters.cookiePersistentStorageFile));
>diff --git a/Source/WebKit/NetworkProcess/soup/NetworkSessionSoup.cpp b/Source/WebKit/NetworkProcess/soup/NetworkSessionSoup.cpp
>index 20acb1f8a41e56af69ae945f0f3bfd8d4361d4da..e14c9817252aadb2025657be9c08ac9f0c06b21c 100644
>--- a/Source/WebKit/NetworkProcess/soup/NetworkSessionSoup.cpp
>+++ b/Source/WebKit/NetworkProcess/soup/NetworkSessionSoup.cpp
>@@ -37,7 +37,7 @@ namespace WebKit {
> using namespace WebCore;
> 
> NetworkSessionSoup::NetworkSessionSoup(NetworkProcess& networkProcess, NetworkSessionCreationParameters&& parameters)
>-    : NetworkSession(networkProcess, parameters.sessionID)
>+    : NetworkSession(networkProcess, parameters.sessionID, parameters.localStorageDirectory, parameters.localStorageDirectoryExtensionHandle)
> {
>     networkStorageSession().setCookieObserverHandler([this] {
>         this->networkProcess().supplement<WebCookieManager>()->notifyCookiesDidChange(m_sessionID);
>diff --git a/Source/WebKit/PlatformMac.cmake b/Source/WebKit/PlatformMac.cmake
>index 6bc163e3f89b4e9c4a129c328fc96d9038fea9c3..7aec6b5a3bdb09ccf4673c43c767e5c49735105e 100644
>--- a/Source/WebKit/PlatformMac.cmake
>+++ b/Source/WebKit/PlatformMac.cmake
>@@ -32,6 +32,8 @@ list(APPEND WebKit_SOURCES
> 
>     NetworkProcess/Downloads/cocoa/DownloadCocoa.mm
> 
>+    NetworkProcess/WebStorage/StorageManager.cpp
>+
>     NetworkProcess/cache/NetworkCacheDataCocoa.mm
>     NetworkProcess/cache/NetworkCacheIOChannelCocoa.mm
> 
>diff --git a/Source/WebKit/PlatformWin.cmake b/Source/WebKit/PlatformWin.cmake
>index c3514e83a0258ab7c21073a09ca81d6d209ab1ed..7c9df220a9d2a6ff526c390244e04dba885d3808 100644
>--- a/Source/WebKit/PlatformWin.cmake
>+++ b/Source/WebKit/PlatformWin.cmake
>@@ -9,6 +9,8 @@ list(APPEND WebKit_SOURCES
>     NetworkProcess/Classifier/WebResourceLoadStatisticsStore.cpp
>     NetworkProcess/Classifier/WebResourceLoadStatisticsTelemetry.cpp
> 
>+    NetworkProcess/WebStorage/StorageManager.cpp
>+
>     NetworkProcess/win/NetworkProcessMainWin.cpp
> 
>     Platform/IPC/win/AttachmentWin.cpp
>diff --git a/Source/WebKit/Shared/WebPageCreationParameters.cpp b/Source/WebKit/Shared/WebPageCreationParameters.cpp
>index 89f535d4e299244dca6bbee7c102d6ea39fa42a6..e9da60aeebeff1da691e1e453373577a3a940a25 100644
>--- a/Source/WebKit/Shared/WebPageCreationParameters.cpp
>+++ b/Source/WebKit/Shared/WebPageCreationParameters.cpp
>@@ -131,6 +131,7 @@ void WebPageCreationParameters::encode(IPC::Encoder& encoder) const
>     encoder << contentRuleLists;
> #endif
>     encoder << backgroundColor;
>+    encoder << oldPageID;
> }
> 
> Optional<WebPageCreationParameters> WebPageCreationParameters::decode(IPC::Decoder& decoder)
>@@ -391,6 +392,12 @@ Optional<WebPageCreationParameters> WebPageCreationParameters::decode(IPC::Decod
>         return WTF::nullopt;
>     parameters.backgroundColor = WTFMove(*backgroundColor);
> 
>+    Optional<Optional<uint64_t>> oldPageID;
>+    decoder >> oldPageID;
>+    if (!oldPageID)
>+        return WTF::nullopt;
>+    parameters.oldPageID = WTFMove(*oldPageID);
>+
>     return parameters;
> }
> 
>diff --git a/Source/WebKit/Shared/WebPageCreationParameters.h b/Source/WebKit/Shared/WebPageCreationParameters.h
>index 43af461a730c79c563d38f1e6962033995f04e26..c2be84146b34ea756197075ac8b2cbc38bec42e0 100644
>--- a/Source/WebKit/Shared/WebPageCreationParameters.h
>+++ b/Source/WebKit/Shared/WebPageCreationParameters.h
>@@ -201,6 +201,8 @@ struct WebPageCreationParameters {
> #endif
> 
>     Optional<WebCore::Color> backgroundColor;
>+
>+    Optional<uint64_t> oldPageID;
> };
> 
> } // namespace WebKit
>diff --git a/Source/WebKit/Shared/WebsiteData/WebsiteData.cpp b/Source/WebKit/Shared/WebsiteData/WebsiteData.cpp
>index 5191cce13c4fccb099bac90b161b1459fdae6f0f..90c7d754580d86a5f417c1c55a9fa874ba9e277a 100644
>--- a/Source/WebKit/Shared/WebsiteData/WebsiteData.cpp
>+++ b/Source/WebKit/Shared/WebsiteData/WebsiteData.cpp
>@@ -99,9 +99,9 @@ WebsiteDataProcessType WebsiteData::ownerProcess(WebsiteDataType dataType)
>     case WebsiteDataType::OfflineWebApplicationCache:
>         return WebsiteDataProcessType::UI;
>     case WebsiteDataType::SessionStorage:
>-        return WebsiteDataProcessType::UI;
>+        return WebsiteDataProcessType::Network;
>     case WebsiteDataType::LocalStorage:
>-        return WebsiteDataProcessType::UI;
>+        return WebsiteDataProcessType::Network;
>     case WebsiteDataType::WebSQLDatabases:
>         return WebsiteDataProcessType::UI;
>     case WebsiteDataType::IndexedDBDatabases:
>diff --git a/Source/WebKit/Sources.txt b/Source/WebKit/Sources.txt
>index 42ce098f39fbc09744f11902a6c575d81c36aebd..75982f7268a9a6bd45936cd35471f21c43c3edfa 100644
>--- a/Source/WebKit/Sources.txt
>+++ b/Source/WebKit/Sources.txt
>@@ -65,6 +65,10 @@ NetworkProcess/ServiceWorker/WebSWOriginStore.cpp @no-unify
> NetworkProcess/ServiceWorker/WebSWServerConnection.cpp @no-unify
> NetworkProcess/ServiceWorker/WebSWServerToContextConnection.cpp @no-unify
> 
>+NetworkProcess/WebStorage/LocalStorageDatabase.cpp
>+NetworkProcess/WebStorage/LocalStorageDatabaseTracker.cpp
>+NetworkProcess/WebStorage/StorageManager.cpp
>+
> NetworkProcess/cache/CacheStorageEngine.cpp
> NetworkProcess/cache/CacheStorageEngineCache.cpp
> NetworkProcess/cache/CacheStorageEngineCaches.cpp
>@@ -410,10 +414,6 @@ UIProcess/WebAuthentication/AuthenticatorTransportService.cpp
> UIProcess/WebAuthentication/Authenticator.cpp
> UIProcess/WebAuthentication/WebAuthenticatorCoordinatorProxy.cpp
> 
>-UIProcess/WebStorage/LocalStorageDatabase.cpp
>-UIProcess/WebStorage/LocalStorageDatabaseTracker.cpp
>-UIProcess/WebStorage/StorageManager.cpp
>-
> UIProcess/WebsiteData/WebDeviceOrientationAndMotionAccessController.cpp
> UIProcess/WebsiteData/WebsiteDataRecord.cpp
> UIProcess/WebsiteData/WebsiteDataStore.cpp
>diff --git a/Source/WebKit/SourcesCocoa.txt b/Source/WebKit/SourcesCocoa.txt
>index b81088ef13346ffc84622c203fcd4440f82065b5..2434c3922e3e7909e1fe95bfe4a554b61882e6b0 100644
>--- a/Source/WebKit/SourcesCocoa.txt
>+++ b/Source/WebKit/SourcesCocoa.txt
>@@ -42,6 +42,8 @@ NetworkProcess/Downloads/cocoa/DownloadCocoa.mm
> NetworkProcess/EntryPoint/Cocoa/Daemon/DaemonEntryPoint.mm
> NetworkProcess/EntryPoint/Cocoa/XPCService/NetworkServiceEntryPoint.mm
> 
>+NetworkProcess/WebStorage/ios/LocalStorageDatabaseTrackerIOS.mm
>+
> NetworkProcess/ios/NetworkConnectionToWebProcessIOS.mm
> NetworkProcess/ios/NetworkProcessIOS.mm
> 
>@@ -488,8 +490,6 @@ UIProcess/WebAuthentication/Mock/MockLocalService.mm
> 
> UIProcess/WebsiteData/Cocoa/WebsiteDataStoreCocoa.mm
> 
>-UIProcess/WebStorage/ios/LocalStorageDatabaseTrackerIOS.mm
>-
> WebProcess/API/Cocoa/WKWebProcess.cpp
> 
> WebProcess/ApplePay/WebPaymentCoordinator.cpp
>diff --git a/Source/WebKit/SourcesGTK.txt b/Source/WebKit/SourcesGTK.txt
>index 7c3d86ffb5d9d567dc6cb54ae3541874077c2449..bf386ce871e4b11e4c3ef69360804c180ecf434c 100644
>--- a/Source/WebKit/SourcesGTK.txt
>+++ b/Source/WebKit/SourcesGTK.txt
>@@ -34,6 +34,8 @@ NetworkProcess/CustomProtocols/LegacyCustomProtocolManager.cpp
> 
> NetworkProcess/CustomProtocols/soup/LegacyCustomProtocolManagerSoup.cpp
> 
>+NetworkProcess/WebStorage/StorageManager.cpp
>+
> NetworkProcess/cache/NetworkCacheDataSoup.cpp
> NetworkProcess/cache/NetworkCacheIOChannelSoup.cpp
> 
>diff --git a/Source/WebKit/SourcesWPE.txt b/Source/WebKit/SourcesWPE.txt
>index cbf299c8c28c196abce007d023a26465138571f5..b8920847e7e800e0994398570787a1a6cc667548 100644
>--- a/Source/WebKit/SourcesWPE.txt
>+++ b/Source/WebKit/SourcesWPE.txt
>@@ -30,6 +30,8 @@ NetworkProcess/CustomProtocols/LegacyCustomProtocolManager.cpp
> 
> NetworkProcess/CustomProtocols/soup/LegacyCustomProtocolManagerSoup.cpp
> 
>+NetworkProcess/WebStorage/StorageManager.cpp
>+
> NetworkProcess/cache/NetworkCacheDataSoup.cpp
> NetworkProcess/cache/NetworkCacheIOChannelSoup.cpp
> 
>diff --git a/Source/WebKit/UIProcess/API/C/WKKeyValueStorageManager.cpp b/Source/WebKit/UIProcess/API/C/WKKeyValueStorageManager.cpp
>index efaebf7e66c3b22d3450ac1b9b211949ad0fd340..65ef7d6676833a77aaafab5d103dea3682284e53 100644
>--- a/Source/WebKit/UIProcess/API/C/WKKeyValueStorageManager.cpp
>+++ b/Source/WebKit/UIProcess/API/C/WKKeyValueStorageManager.cpp
>@@ -31,6 +31,7 @@
> #include "APIWebsiteDataStore.h"
> #include "StorageManager.h"
> #include "WKAPICast.h"
>+#include "WebsiteDataRecord.h"
> #include "WebsiteDataStore.h"
> #include <wtf/RunLoop.h>
> 
>@@ -62,51 +63,36 @@ WKStringRef WKKeyValueStorageManagerGetModificationTimeKey()
> void WKKeyValueStorageManagerGetKeyValueStorageOrigins(WKKeyValueStorageManagerRef keyValueStorageManager, void* context, WKKeyValueStorageManagerGetKeyValueStorageOriginsFunction callback)
> 
> {
>-    StorageManager* storageManager = toImpl(reinterpret_cast<WKWebsiteDataStoreRef>(keyValueStorageManager))->websiteDataStore().storageManager();
>-    if (!storageManager) {
>-        RunLoop::main().dispatch([context, callback] {
>-            callback(toAPI(API::Array::create().ptr()), nullptr, context);
>-        });
>-        return;
>-    }
>-
>-    storageManager->getLocalStorageOrigins([context, callback](auto&& securityOrigins) {
>-        Vector<RefPtr<API::Object>> webSecurityOrigins;
>-        webSecurityOrigins.reserveInitialCapacity(securityOrigins.size());
>-        for (auto& origin : securityOrigins)
>-            webSecurityOrigins.uncheckedAppend(API::SecurityOrigin::create(origin.securityOrigin()));
>-
>-        callback(toAPI(API::Array::create(WTFMove(webSecurityOrigins)).ptr()), nullptr, context);
>+    auto& websiteDataStore = WebKit::toImpl(reinterpret_cast<WKWebsiteDataStoreRef>(keyValueStorageManager))->websiteDataStore();
>+    websiteDataStore.fetchData({ WebKit::WebsiteDataType::LocalStorage, WebKit::WebsiteDataType::SessionStorage }, { }, [context, callback](auto dataRecords) {
>+        Vector<RefPtr<API::Object>> securityOrigins;
>+        for (const auto& dataRecord : dataRecords) {
>+            for (const auto& origin : dataRecord.origins)
>+                securityOrigins.append(API::SecurityOrigin::create(origin.securityOrigin()));
>+        }
>+        
>+        callback(WebKit::toAPI(API::Array::create(WTFMove(securityOrigins)).ptr()), nullptr, context);
>     });
> }
> 
> void WKKeyValueStorageManagerGetStorageDetailsByOrigin(WKKeyValueStorageManagerRef keyValueStorageManager, void* context, WKKeyValueStorageManagerGetStorageDetailsByOriginFunction callback)
> {
>-    StorageManager* storageManager = toImpl(reinterpret_cast<WKWebsiteDataStoreRef>(keyValueStorageManager))->websiteDataStore().storageManager();
>-    if (!storageManager) {
>-        RunLoop::main().dispatch([context, callback] {
>-            callback(toAPI(API::Array::create().ptr()), nullptr, context);
>-        });
>-        return;
>-    }
>-
>-    storageManager->getLocalStorageOriginDetails([context, callback](auto storageDetails) {
>-        HashMap<String, RefPtr<API::Object>> detailsMap;
>+    auto& websiteDataStore = WebKit::toImpl(reinterpret_cast<WKWebsiteDataStoreRef>(keyValueStorageManager))->websiteDataStore();
>+    websiteDataStore.getLocalStorageDetails([context, callback](auto details) {
>         Vector<RefPtr<API::Object>> result;
>-        result.reserveInitialCapacity(storageDetails.size());
>-
>-        for (const auto& originDetails : storageDetails) {
>-            HashMap<String, RefPtr<API::Object>> detailsMap;
>+        result.reserveInitialCapacity(details.size());
> 
>-            RefPtr<API::Object> origin = API::SecurityOrigin::create(WebCore::SecurityOriginData::fromDatabaseIdentifier(originDetails.originIdentifier)->securityOrigin());
>+        for (const auto& detail : details) {
>+            HashMap<String, RefPtr<API::Object>> detailMap;
>+            RefPtr<API::Object> origin = API::SecurityOrigin::create(WebCore::SecurityOriginData::fromDatabaseIdentifier(detail.originIdentifier)->securityOrigin());
> 
>-            detailsMap.set(toImpl(WKKeyValueStorageManagerGetOriginKey())->string(), origin);
>-            if (originDetails.creationTime)
>-                detailsMap.set(toImpl(WKKeyValueStorageManagerGetCreationTimeKey())->string(), API::Double::create(originDetails.creationTime->secondsSinceEpoch().value()));
>-            if (originDetails.modificationTime)
>-                detailsMap.set(toImpl(WKKeyValueStorageManagerGetModificationTimeKey())->string(), API::Double::create(originDetails.modificationTime->secondsSinceEpoch().value()));
>+            detailMap.set(toImpl(WKKeyValueStorageManagerGetOriginKey())->string(), origin);
>+            if (detail.creationTime)
>+                detailMap.set(toImpl(WKKeyValueStorageManagerGetCreationTimeKey())->string(), API::Double::create(detail.creationTime->secondsSinceEpoch().value()));
>+            if (detail.modificationTime)
>+                detailMap.set(toImpl(WKKeyValueStorageManagerGetModificationTimeKey())->string(), API::Double::create(detail.modificationTime->secondsSinceEpoch().value()));
> 
>-            result.uncheckedAppend(API::Dictionary::create(WTFMove(detailsMap)));
>+            result.uncheckedAppend(API::Dictionary::create(WTFMove(detailMap)));
>         }
> 
>         callback(toAPI(API::Array::create(WTFMove(result)).ptr()), nullptr, context);
>@@ -115,18 +101,15 @@ void WKKeyValueStorageManagerGetStorageDetailsByOrigin(WKKeyValueStorageManagerR
> 
> void WKKeyValueStorageManagerDeleteEntriesForOrigin(WKKeyValueStorageManagerRef keyValueStorageManager, WKSecurityOriginRef origin)
> {
>-    StorageManager* storageManager = toImpl(reinterpret_cast<WKWebsiteDataStoreRef>(keyValueStorageManager))->websiteDataStore().storageManager();
>-    if (!storageManager)
>-        return;
>-
>-    storageManager->deleteLocalStorageEntriesForOrigin(toImpl(origin)->securityOrigin().data());
>+    auto& websiteDataStore = WebKit::toImpl(reinterpret_cast<WKWebsiteDataStoreRef>(keyValueStorageManager))->websiteDataStore();
>+    WebKit::WebsiteDataRecord dataRecord;
>+    dataRecord.add(WebKit::WebsiteDataType::LocalStorage, WebKit::toImpl(origin)->securityOrigin().data());
>+    dataRecord.add(WebKit::WebsiteDataType::SessionStorage, WebKit::toImpl(origin)->securityOrigin().data());
>+    websiteDataStore.removeData({ WebKit::WebsiteDataType::LocalStorage, WebKit::WebsiteDataType::SessionStorage }, { dataRecord }, [] { });
> }
> 
> void WKKeyValueStorageManagerDeleteAllEntries(WKKeyValueStorageManagerRef keyValueStorageManager)
> {
>-    StorageManager* storageManager = toImpl(reinterpret_cast<WKWebsiteDataStoreRef>(keyValueStorageManager))->websiteDataStore().storageManager();
>-    if (!storageManager)
>-        return;
>-
>-    storageManager->deleteLocalStorageOriginsModifiedSince(-WallTime::infinity(), [] { });
>+    auto& websiteDataStore = WebKit::toImpl(reinterpret_cast<WKWebsiteDataStoreRef>(keyValueStorageManager))->websiteDataStore();
>+    websiteDataStore.removeData({ WebKit::WebsiteDataType::LocalStorage, WebKit::WebsiteDataType::SessionStorage }, -WallTime::infinity(), [] { });
> }
>diff --git a/Source/WebKit/UIProcess/Network/NetworkProcessProxy.cpp b/Source/WebKit/UIProcess/Network/NetworkProcessProxy.cpp
>index af859aec0362e91f930b286b8f42fc20fa883043..693bde4f43b198a0942893b1853ceb554a5f25ac 100644
>--- a/Source/WebKit/UIProcess/Network/NetworkProcessProxy.cpp
>+++ b/Source/WebKit/UIProcess/Network/NetworkProcessProxy.cpp
>@@ -566,6 +566,16 @@ void NetworkProcessProxy::clearUserInteraction(PAL::SessionID sessionID, const R
>     sendWithAsyncReply(Messages::NetworkProcess::ClearUserInteraction(sessionID, resourceDomain), WTFMove(completionHandler));
> }
> 
>+void NetworkProcessProxy::hasLocalStorage(PAL::SessionID sessionID, const RegistrableDomain& resourceDomain, CompletionHandler<void(bool)>&& completionHandler)
>+{
>+    if (!canSendMessage()) {
>+        completionHandler(false);
>+        return;
>+    }
>+
>+    sendWithAsyncReply(Messages::NetworkProcess::HasLocalStorage(sessionID, resourceDomain), WTFMove(completionHandler));
>+}
>+
> void NetworkProcessProxy::setAgeCapForClientSideCookies(PAL::SessionID sessionID, Optional<Seconds> seconds, CompletionHandler<void()>&& completionHandler)
> {
>     if (!canSendMessage()) {
>@@ -1178,6 +1188,16 @@ void NetworkProcessProxy::createSymLinkForFileUpgrade(const String& indexedDatab
> }
> #endif
> 
>+void NetworkProcessProxy::getLocalStorageDetails(PAL::SessionID sessionID, CompletionHandler<void(Vector<LocalStorageDatabaseTracker::OriginDetails>)>&& completionHandler)
>+{
>+    if (!canSendMessage()) {
>+        completionHandler({ });
>+        return;
>+    }
>+
>+    sendWithAsyncReply(Messages::NetworkProcess::GetLocalStorageOriginDetails(sessionID), WTFMove(completionHandler));
>+}
>+
> } // namespace WebKit
> 
> #undef MESSAGE_CHECK
>diff --git a/Source/WebKit/UIProcess/Network/NetworkProcessProxy.h b/Source/WebKit/UIProcess/Network/NetworkProcessProxy.h
>index ac3dd8325955a8b6fa1480808b30fe3bfc613cd7..7d9cb465e3eac2b3fffaf7d974434e21df1ed202 100644
>--- a/Source/WebKit/UIProcess/Network/NetworkProcessProxy.h
>+++ b/Source/WebKit/UIProcess/Network/NetworkProcessProxy.h
>@@ -96,12 +96,15 @@ public:
>     void deleteWebsiteData(PAL::SessionID, OptionSet<WebsiteDataType>, WallTime modifiedSince, CompletionHandler<void()>&& completionHandler);
>     void deleteWebsiteDataForOrigins(PAL::SessionID, OptionSet<WebKit::WebsiteDataType>, const Vector<WebCore::SecurityOriginData>& origins, const Vector<String>& cookieHostNames, const Vector<String>& HSTSCacheHostNames, CompletionHandler<void()>&&);
> 
>+    void getLocalStorageDetails(PAL::SessionID, CompletionHandler<void(Vector<LocalStorageDatabaseTracker::OriginDetails>)>&&);
>+
> #if ENABLE(RESOURCE_LOAD_STATISTICS)
>     void clearPrevalentResource(PAL::SessionID, const RegistrableDomain&, CompletionHandler<void()>&&);
>     void clearUserInteraction(PAL::SessionID, const RegistrableDomain&, CompletionHandler<void()>&&);
>     void dumpResourceLoadStatistics(PAL::SessionID, CompletionHandler<void(String)>&&);
>     void updatePrevalentDomainsToBlockCookiesFor(PAL::SessionID, const Vector<RegistrableDomain>&, CompletionHandler<void()>&&);
>     void hasHadUserInteraction(PAL::SessionID, const RegistrableDomain&, CompletionHandler<void(bool)>&&);
>+    void hasLocalStorage(PAL::SessionID, const RegistrableDomain&, CompletionHandler<void(bool)>&&);
>     void isGrandfathered(PAL::SessionID, const RegistrableDomain&, CompletionHandler<void(bool)>&&);
>     void isPrevalentResource(PAL::SessionID, const RegistrableDomain&, CompletionHandler<void(bool)>&&);
>     void isRegisteredAsRedirectingTo(PAL::SessionID, const RedirectedFromDomain&, const RedirectedToDomain&, CompletionHandler<void(bool)>&&);
>diff --git a/Source/WebKit/UIProcess/WebPageProxy.cpp b/Source/WebKit/UIProcess/WebPageProxy.cpp
>index 886ded68cc46cef03c8cdda9f578dabcaf56d875..50a1cb8538414c11894a53f17d086635f59db708 100644
>--- a/Source/WebKit/UIProcess/WebPageProxy.cpp
>+++ b/Source/WebKit/UIProcess/WebPageProxy.cpp
>@@ -5037,7 +5037,6 @@ void WebPageProxy::createNewPage(const FrameInfoData& originatingFrameInfoData,
> 
>         reply(newPage->pageID(), newPage->creationParameters(m_process, *newPage->drawingArea()));
> 
>-        WebsiteDataStore::cloneSessionData(*this, *newPage);
>         newPage->m_shouldSuppressAppLinksInNextNavigationPolicyDecision = hostsAreEqual(URL({ }, mainFrameURL), request.url());
> 
> #if HAVE(LOAD_OPTIMIZER)
>diff --git a/Source/WebKit/UIProcess/WebProcessPool.cpp b/Source/WebKit/UIProcess/WebProcessPool.cpp
>index 13ecc485db6f01a05dad3c428059d0ec7aa3dca0..0e139f30d9cef9f63233c613b5e42bcdd598ee68 100644
>--- a/Source/WebKit/UIProcess/WebProcessPool.cpp
>+++ b/Source/WebKit/UIProcess/WebProcessPool.cpp
>@@ -574,6 +574,12 @@ NetworkProcessProxy& WebProcessPool::ensureNetworkProcess(WebsiteDataStore* with
>     parameters.shouldDisableServiceWorkerProcessTerminationDelay = m_shouldDisableServiceWorkerProcessTerminationDelay;
> #endif
> 
>+    auto localStorageDirectory = m_websiteDataStore ? m_websiteDataStore->websiteDataStore().resolvedLocalStorageDirectory() : nullString();
>+    if (!localStorageDirectory)
>+        localStorageDirectory = API::WebsiteDataStore::defaultLocalStorageDirectory();
>+    parameters.defaultDataStoreParameters.networkSessionParameters.localStorageDirectory = localStorageDirectory;
>+    SandboxExtension::createHandleForReadWriteDirectory(localStorageDirectory, parameters.defaultDataStoreParameters.networkSessionParameters.localStorageDirectoryExtensionHandle);
>+
>     if (m_websiteDataStore)
>         parameters.defaultDataStoreParameters.networkSessionParameters.resourceLoadStatisticsDirectory = m_websiteDataStore->websiteDataStore().resolvedResourceLoadStatisticsDirectory();
>     if (parameters.defaultDataStoreParameters.networkSessionParameters.resourceLoadStatisticsDirectory.isEmpty())
>diff --git a/Source/WebKit/UIProcess/WebStorage/LocalStorageDatabase.cpp b/Source/WebKit/UIProcess/WebStorage/LocalStorageDatabase.cpp
>deleted file mode 100644
>index 46fb6c77294f3c631d4fffdfc24a148f708a44ce..0000000000000000000000000000000000000000
>--- a/Source/WebKit/UIProcess/WebStorage/LocalStorageDatabase.cpp
>+++ /dev/null
>@@ -1,366 +0,0 @@
>-/*
>- * Copyright (C) 2008, 2009, 2010, 2013 Apple Inc. All rights reserved.
>- *
>- * Redistribution and use in source and binary forms, with or without
>- * modification, are permitted provided that the following conditions
>- * are met:
>- * 1. Redistributions of source code must retain the above copyright
>- *    notice, this list of conditions and the following disclaimer.
>- * 2. Redistributions in binary form must reproduce the above copyright
>- *    notice, this list of conditions and the following disclaimer in the
>- *    documentation and/or other materials provided with the distribution.
>- *
>- * THIS SOFTWARE IS PROVIDED BY APPLE INC. AND ITS CONTRIBUTORS ``AS IS''
>- * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO,
>- * THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
>- * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL APPLE INC. OR ITS CONTRIBUTORS
>- * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
>- * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
>- * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
>- * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
>- * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
>- * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF
>- * THE POSSIBILITY OF SUCH DAMAGE.
>- */
>-
>-#include "config.h"
>-#include "LocalStorageDatabase.h"
>-
>-#include "LocalStorageDatabaseTracker.h"
>-#include <WebCore/SQLiteStatement.h>
>-#include <WebCore/SQLiteTransaction.h>
>-#include <WebCore/SecurityOrigin.h>
>-#include <WebCore/StorageMap.h>
>-#include <WebCore/SuddenTermination.h>
>-#include <wtf/FileSystem.h>
>-#include <wtf/RefPtr.h>
>-#include <wtf/WorkQueue.h>
>-#include <wtf/text/StringHash.h>
>-#include <wtf/text/WTFString.h>
>-
>-static const auto databaseUpdateInterval = 1_s;
>-
>-static const int maximumItemsToUpdate = 100;
>-
>-namespace WebKit {
>-using namespace WebCore;
>-
>-Ref<LocalStorageDatabase> LocalStorageDatabase::create(Ref<WorkQueue>&& queue, Ref<LocalStorageDatabaseTracker>&& tracker, const SecurityOriginData& securityOrigin)
>-{
>-    return adoptRef(*new LocalStorageDatabase(WTFMove(queue), WTFMove(tracker), securityOrigin));
>-}
>-
>-LocalStorageDatabase::LocalStorageDatabase(Ref<WorkQueue>&& queue, Ref<LocalStorageDatabaseTracker>&& tracker, const SecurityOriginData& securityOrigin)
>-    : m_queue(WTFMove(queue))
>-    , m_tracker(WTFMove(tracker))
>-    , m_securityOrigin(securityOrigin)
>-    , m_databasePath(m_tracker->databasePath(m_securityOrigin))
>-    , m_failedToOpenDatabase(false)
>-    , m_didImportItems(false)
>-    , m_isClosed(false)
>-    , m_didScheduleDatabaseUpdate(false)
>-    , m_shouldClearItems(false)
>-{
>-}
>-
>-LocalStorageDatabase::~LocalStorageDatabase()
>-{
>-    ASSERT(m_isClosed);
>-}
>-
>-void LocalStorageDatabase::openDatabase(DatabaseOpeningStrategy openingStrategy)
>-{
>-    ASSERT(!m_database.isOpen());
>-    ASSERT(!m_failedToOpenDatabase);
>-
>-    if (!tryToOpenDatabase(openingStrategy)) {
>-        m_failedToOpenDatabase = true;
>-        return;
>-    }
>-
>-    if (m_database.isOpen())
>-        m_tracker->didOpenDatabaseWithOrigin(m_securityOrigin);
>-}
>-
>-bool LocalStorageDatabase::tryToOpenDatabase(DatabaseOpeningStrategy openingStrategy)
>-{
>-    if (!FileSystem::fileExists(m_databasePath) && openingStrategy == SkipIfNonExistent)
>-        return true;
>-
>-    if (m_databasePath.isEmpty()) {
>-        LOG_ERROR("Filename for local storage database is empty - cannot open for persistent storage");
>-        return false;
>-    }
>-
>-    if (!m_database.open(m_databasePath)) {
>-        LOG_ERROR("Failed to open database file %s for local storage", m_databasePath.utf8().data());
>-        return false;
>-    }
>-
>-    // Since a WorkQueue isn't bound to a specific thread, we have to disable threading checks
>-    // even though we never access the database from different threads simultaneously.
>-    m_database.disableThreadingChecks();
>-
>-    if (!migrateItemTableIfNeeded()) {
>-        // We failed to migrate the item table. In order to avoid trying to migrate the table over and over,
>-        // just delete it and start from scratch.
>-        if (!m_database.executeCommand("DROP TABLE ItemTable"))
>-            LOG_ERROR("Failed to delete table ItemTable for local storage");
>-    }
>-
>-    if (!m_database.executeCommand("CREATE TABLE IF NOT EXISTS ItemTable (key TEXT UNIQUE ON CONFLICT REPLACE, value BLOB NOT NULL ON CONFLICT FAIL)")) {
>-        LOG_ERROR("Failed to create table ItemTable for local storage");
>-        return false;
>-    }
>-
>-    return true;
>-}
>-
>-bool LocalStorageDatabase::migrateItemTableIfNeeded()
>-{
>-    if (!m_database.tableExists("ItemTable"))
>-        return true;
>-
>-    SQLiteStatement query(m_database, "SELECT value FROM ItemTable LIMIT 1");
>-
>-    // This query isn't ever executed, it's just used to check the column type.
>-    if (query.isColumnDeclaredAsBlob(0))
>-        return true;
>-
>-    // Create a new table with the right type, copy all the data over to it and then replace the new table with the old table.
>-    static const char* commands[] = {
>-        "DROP TABLE IF EXISTS ItemTable2",
>-        "CREATE TABLE ItemTable2 (key TEXT UNIQUE ON CONFLICT REPLACE, value BLOB NOT NULL ON CONFLICT FAIL)",
>-        "INSERT INTO ItemTable2 SELECT * from ItemTable",
>-        "DROP TABLE ItemTable",
>-        "ALTER TABLE ItemTable2 RENAME TO ItemTable",
>-        0,
>-    };
>-
>-    SQLiteTransaction transaction(m_database, false);
>-    transaction.begin();
>-
>-    for (size_t i = 0; commands[i]; ++i) {
>-        if (m_database.executeCommand(commands[i]))
>-            continue;
>-
>-        LOG_ERROR("Failed to migrate table ItemTable for local storage when executing: %s", commands[i]);
>-        transaction.rollback();
>-
>-        return false;
>-    }
>-
>-    transaction.commit();
>-    return true;
>-}
>-
>-void LocalStorageDatabase::importItems(StorageMap& storageMap)
>-{
>-    if (m_didImportItems)
>-        return;
>-
>-    // FIXME: If it can't import, then the default WebKit behavior should be that of private browsing,
>-    // not silently ignoring it. https://bugs.webkit.org/show_bug.cgi?id=25894
>-
>-    // We set this to true even if we don't end up importing any items due to failure because
>-    // there's really no good way to recover other than not importing anything.
>-    m_didImportItems = true;
>-
>-    openDatabase(SkipIfNonExistent);
>-    if (!m_database.isOpen())
>-        return;
>-
>-    SQLiteStatement query(m_database, "SELECT key, value FROM ItemTable");
>-    if (query.prepare() != SQLITE_OK) {
>-        LOG_ERROR("Unable to select items from ItemTable for local storage");
>-        return;
>-    }
>-
>-    HashMap<String, String> items;
>-
>-    int result = query.step();
>-    while (result == SQLITE_ROW) {
>-        String key = query.getColumnText(0);
>-        String value = query.getColumnBlobAsString(1);
>-        if (!key.isNull() && !value.isNull())
>-            items.set(key, value);
>-        result = query.step();
>-    }
>-
>-    if (result != SQLITE_DONE) {
>-        LOG_ERROR("Error reading items from ItemTable for local storage");
>-        return;
>-    }
>-
>-    storageMap.importItems(items);
>-}
>-
>-void LocalStorageDatabase::setItem(const String& key, const String& value)
>-{
>-    itemDidChange(key, value);
>-}
>-
>-void LocalStorageDatabase::removeItem(const String& key)
>-{
>-    itemDidChange(key, String());
>-}
>-
>-void LocalStorageDatabase::clear()
>-{
>-    m_changedItems.clear();
>-    m_shouldClearItems = true;
>-
>-    scheduleDatabaseUpdate();
>-}
>-
>-void LocalStorageDatabase::close()
>-{
>-    ASSERT(!m_isClosed);
>-    m_isClosed = true;
>-
>-    if (m_didScheduleDatabaseUpdate) {
>-        updateDatabaseWithChangedItems(m_changedItems);
>-        m_changedItems.clear();
>-    }
>-
>-    bool isEmpty = databaseIsEmpty();
>-
>-    if (m_database.isOpen())
>-        m_database.close();
>-
>-    if (isEmpty)
>-        m_tracker->deleteDatabaseWithOrigin(m_securityOrigin);
>-}
>-
>-void LocalStorageDatabase::itemDidChange(const String& key, const String& value)
>-{
>-    m_changedItems.set(key, value);
>-    scheduleDatabaseUpdate();
>-}
>-
>-void LocalStorageDatabase::scheduleDatabaseUpdate()
>-{
>-    if (m_didScheduleDatabaseUpdate)
>-        return;
>-
>-    if (!m_disableSuddenTerminationWhileWritingToLocalStorage)
>-        m_disableSuddenTerminationWhileWritingToLocalStorage = std::make_unique<SuddenTerminationDisabler>();
>-
>-    m_didScheduleDatabaseUpdate = true;
>-
>-    m_queue->dispatchAfter(databaseUpdateInterval, [protectedThis = makeRef(*this)] {
>-        protectedThis->updateDatabase();
>-    });
>-}
>-
>-void LocalStorageDatabase::updateDatabase()
>-{
>-    if (m_isClosed)
>-        return;
>-
>-    ASSERT(m_didScheduleDatabaseUpdate);
>-    m_didScheduleDatabaseUpdate = false;
>-
>-    HashMap<String, String> changedItems;
>-    if (m_changedItems.size() <= maximumItemsToUpdate) {
>-        // There are few enough changed items that we can just always write all of them.
>-        m_changedItems.swap(changedItems);
>-        updateDatabaseWithChangedItems(changedItems);
>-        m_disableSuddenTerminationWhileWritingToLocalStorage = nullptr;
>-    } else {
>-        for (int i = 0; i < maximumItemsToUpdate; ++i) {
>-            auto it = m_changedItems.begin();
>-            changedItems.add(it->key, it->value);
>-
>-            m_changedItems.remove(it);
>-        }
>-
>-        ASSERT(changedItems.size() <= maximumItemsToUpdate);
>-
>-        // Reschedule the update for the remaining items.
>-        scheduleDatabaseUpdate();
>-        updateDatabaseWithChangedItems(changedItems);
>-    }
>-}
>-
>-void LocalStorageDatabase::updateDatabaseWithChangedItems(const HashMap<String, String>& changedItems)
>-{
>-    if (!m_database.isOpen())
>-        openDatabase(CreateIfNonExistent);
>-    if (!m_database.isOpen())
>-        return;
>-
>-    if (m_shouldClearItems) {
>-        m_shouldClearItems = false;
>-
>-        SQLiteStatement clearStatement(m_database, "DELETE FROM ItemTable");
>-        if (clearStatement.prepare() != SQLITE_OK) {
>-            LOG_ERROR("Failed to prepare clear statement - cannot write to local storage database");
>-            return;
>-        }
>-
>-        int result = clearStatement.step();
>-        if (result != SQLITE_DONE) {
>-            LOG_ERROR("Failed to clear all items in the local storage database - %i", result);
>-            return;
>-        }
>-    }
>-
>-    SQLiteStatement insertStatement(m_database, "INSERT INTO ItemTable VALUES (?, ?)");
>-    if (insertStatement.prepare() != SQLITE_OK) {
>-        LOG_ERROR("Failed to prepare insert statement - cannot write to local storage database");
>-        return;
>-    }
>-
>-    SQLiteStatement deleteStatement(m_database, "DELETE FROM ItemTable WHERE key=?");
>-    if (deleteStatement.prepare() != SQLITE_OK) {
>-        LOG_ERROR("Failed to prepare delete statement - cannot write to local storage database");
>-        return;
>-    }
>-
>-    SQLiteTransaction transaction(m_database);
>-    transaction.begin();
>-
>-    for (auto it = changedItems.begin(), end = changedItems.end(); it != end; ++it) {
>-        // A null value means that the key/value pair should be deleted.
>-        SQLiteStatement& statement = it->value.isNull() ? deleteStatement : insertStatement;
>-
>-        statement.bindText(1, it->key);
>-
>-        // If we're inserting a key/value pair, bind the value as well.
>-        if (!it->value.isNull())
>-            statement.bindBlob(2, it->value);
>-
>-        int result = statement.step();
>-        if (result != SQLITE_DONE) {
>-            LOG_ERROR("Failed to update item in the local storage database - %i", result);
>-            break;
>-        }
>-
>-        statement.reset();
>-    }
>-
>-    transaction.commit();
>-}
>-
>-bool LocalStorageDatabase::databaseIsEmpty()
>-{
>-    if (!m_database.isOpen())
>-        return false;
>-
>-    SQLiteStatement query(m_database, "SELECT COUNT(*) FROM ItemTable");
>-    if (query.prepare() != SQLITE_OK) {
>-        LOG_ERROR("Unable to count number of rows in ItemTable for local storage");
>-        return false;
>-    }
>-
>-    int result = query.step();
>-    if (result != SQLITE_ROW) {
>-        LOG_ERROR("No results when counting number of rows in ItemTable for local storage");
>-        return false;
>-    }
>-
>-    return !query.getColumnInt(0);
>-}
>-
>-} // namespace WebKit
>diff --git a/Source/WebKit/UIProcess/WebStorage/LocalStorageDatabase.h b/Source/WebKit/UIProcess/WebStorage/LocalStorageDatabase.h
>deleted file mode 100644
>index 9992031f448fb3d91580186d8860a12d84859562..0000000000000000000000000000000000000000
>--- a/Source/WebKit/UIProcess/WebStorage/LocalStorageDatabase.h
>+++ /dev/null
>@@ -1,99 +0,0 @@
>-/*
>- * Copyright (C) 2008, 2009, 2010, 2013 Apple Inc. All rights reserved.
>- *
>- * Redistribution and use in source and binary forms, with or without
>- * modification, are permitted provided that the following conditions
>- * are met:
>- * 1. Redistributions of source code must retain the above copyright
>- *    notice, this list of conditions and the following disclaimer.
>- * 2. Redistributions in binary form must reproduce the above copyright
>- *    notice, this list of conditions and the following disclaimer in the
>- *    documentation and/or other materials provided with the distribution.
>- *
>- * THIS SOFTWARE IS PROVIDED BY APPLE INC. AND ITS CONTRIBUTORS ``AS IS''
>- * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO,
>- * THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
>- * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL APPLE INC. OR ITS CONTRIBUTORS
>- * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
>- * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
>- * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
>- * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
>- * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
>- * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF
>- * THE POSSIBILITY OF SUCH DAMAGE.
>- */
>-
>-#pragma once
>-
>-#include <WebCore/SQLiteDatabase.h>
>-#include <WebCore/SecurityOriginData.h>
>-#include <wtf/Forward.h>
>-#include <wtf/HashMap.h>
>-#include <wtf/RefPtr.h>
>-#include <wtf/ThreadSafeRefCounted.h>
>-#include <wtf/WorkQueue.h>
>-
>-namespace WebCore {
>-class SecurityOrigin;
>-class StorageMap;
>-class SuddenTerminationDisabler;
>-}
>-
>-namespace WebKit {
>-
>-class LocalStorageDatabaseTracker;
>-
>-class LocalStorageDatabase : public ThreadSafeRefCounted<LocalStorageDatabase> {
>-public:
>-    static Ref<LocalStorageDatabase> create(Ref<WorkQueue>&&, Ref<LocalStorageDatabaseTracker>&&, const WebCore::SecurityOriginData&);
>-    ~LocalStorageDatabase();
>-
>-    // Will block until the import is complete.
>-    void importItems(WebCore::StorageMap&);
>-
>-    void setItem(const String& key, const String& value);
>-    void removeItem(const String& key);
>-    void clear();
>-
>-    // Will block until all pending changes have been written to disk.
>-    void close();
>-
>-private:
>-    LocalStorageDatabase(Ref<WorkQueue>&&, Ref<LocalStorageDatabaseTracker>&&, const WebCore::SecurityOriginData&);
>-
>-    enum DatabaseOpeningStrategy {
>-        CreateIfNonExistent,
>-        SkipIfNonExistent
>-    };
>-    bool tryToOpenDatabase(DatabaseOpeningStrategy);
>-    void openDatabase(DatabaseOpeningStrategy);
>-
>-    bool migrateItemTableIfNeeded();
>-
>-    void itemDidChange(const String& key, const String& value);
>-
>-    void scheduleDatabaseUpdate();
>-    void updateDatabase();
>-    void updateDatabaseWithChangedItems(const HashMap<String, String>&);
>-
>-    bool databaseIsEmpty();
>-
>-    Ref<WorkQueue> m_queue;
>-    Ref<LocalStorageDatabaseTracker> m_tracker;
>-    WebCore::SecurityOriginData m_securityOrigin;
>-
>-    String m_databasePath;
>-    WebCore::SQLiteDatabase m_database;
>-    bool m_failedToOpenDatabase;
>-    bool m_didImportItems;
>-    bool m_isClosed;
>-
>-    bool m_didScheduleDatabaseUpdate;
>-    bool m_shouldClearItems;
>-    HashMap<String, String> m_changedItems;
>-
>-    std::unique_ptr<WebCore::SuddenTerminationDisabler> m_disableSuddenTerminationWhileWritingToLocalStorage;
>-};
>-
>-
>-} // namespace WebKit
>diff --git a/Source/WebKit/UIProcess/WebStorage/LocalStorageDatabaseTracker.cpp b/Source/WebKit/UIProcess/WebStorage/LocalStorageDatabaseTracker.cpp
>deleted file mode 100644
>index d084d62877c02269d7addaf5ade3b4fa149741f9..0000000000000000000000000000000000000000
>--- a/Source/WebKit/UIProcess/WebStorage/LocalStorageDatabaseTracker.cpp
>+++ /dev/null
>@@ -1,166 +0,0 @@
>-/*
>- * Copyright (C) 2011, 2013 Apple Inc. All rights reserved.
>- *
>- * Redistribution and use in source and binary forms, with or without
>- * modification, are permitted provided that the following conditions
>- * are met:
>- * 1. Redistributions of source code must retain the above copyright
>- *    notice, this list of conditions and the following disclaimer.
>- * 2. Redistributions in binary form must reproduce the above copyright
>- *    notice, this list of conditions and the following disclaimer in the
>- *    documentation and/or other materials provided with the distribution.
>- *
>- * THIS SOFTWARE IS PROVIDED BY APPLE INC. AND ITS CONTRIBUTORS ``AS IS''
>- * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO,
>- * THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
>- * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL APPLE INC. OR ITS CONTRIBUTORS
>- * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
>- * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
>- * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
>- * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
>- * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
>- * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF
>- * THE POSSIBILITY OF SUCH DAMAGE.
>- */
>-
>-#include "config.h"
>-#include "LocalStorageDatabaseTracker.h"
>-
>-#include "Logging.h"
>-#include <WebCore/SQLiteFileSystem.h>
>-#include <WebCore/SQLiteStatement.h>
>-#include <WebCore/TextEncoding.h>
>-#include <wtf/FileSystem.h>
>-#include <wtf/MainThread.h>
>-#include <wtf/RunLoop.h>
>-#include <wtf/WorkQueue.h>
>-#include <wtf/text/CString.h>
>-
>-namespace WebKit {
>-using namespace WebCore;
>-
>-Ref<LocalStorageDatabaseTracker> LocalStorageDatabaseTracker::create(Ref<WorkQueue>&& queue, const String& localStorageDirectory)
>-{
>-    return adoptRef(*new LocalStorageDatabaseTracker(WTFMove(queue), localStorageDirectory));
>-}
>-
>-LocalStorageDatabaseTracker::LocalStorageDatabaseTracker(Ref<WorkQueue>&& queue, const String& localStorageDirectory)
>-    : m_queue(WTFMove(queue))
>-    , m_localStorageDirectory(localStorageDirectory.isolatedCopy())
>-{
>-    // Make sure the encoding is initialized before we start dispatching things to the queue.
>-    UTF8Encoding();
>-
>-    m_queue->dispatch([protectedThis = makeRef(*this)]() mutable {
>-        // Delete legacy storageTracker database file.
>-        SQLiteFileSystem::deleteDatabaseFile(protectedThis->databasePath("StorageTracker.db"));
>-    });
>-}
>-
>-LocalStorageDatabaseTracker::~LocalStorageDatabaseTracker()
>-{
>-}
>-
>-String LocalStorageDatabaseTracker::databasePath(const SecurityOriginData& securityOrigin) const
>-{
>-    return databasePath(securityOrigin.databaseIdentifier() + ".localstorage");
>-}
>-
>-void LocalStorageDatabaseTracker::didOpenDatabaseWithOrigin(const SecurityOriginData& securityOrigin)
>-{
>-    // FIXME: Tell clients that the origin was added.
>-}
>-
>-void LocalStorageDatabaseTracker::deleteDatabaseWithOrigin(const SecurityOriginData& securityOrigin)
>-{
>-    auto path = databasePath(securityOrigin);
>-    if (!path.isEmpty())
>-        SQLiteFileSystem::deleteDatabaseFile(path);
>-
>-    // FIXME: Tell clients that the origin was removed.
>-}
>-
>-void LocalStorageDatabaseTracker::deleteAllDatabases()
>-{
>-    auto paths = FileSystem::listDirectory(m_localStorageDirectory, "*.localstorage");
>-    for (const auto& path : paths) {
>-        SQLiteFileSystem::deleteDatabaseFile(path);
>-
>-        // FIXME: Call out to the client.
>-    }
>-
>-    SQLiteFileSystem::deleteEmptyDatabaseDirectory(m_localStorageDirectory);
>-}
>-
>-Vector<SecurityOriginData> LocalStorageDatabaseTracker::databasesModifiedSince(WallTime time)
>-{
>-    Vector<SecurityOriginData> databaseOriginsModified;
>-    auto databaseOrigins = origins();
>-    
>-    for (auto origin : databaseOrigins) {
>-        auto path = databasePath(origin);
>-        
>-        auto modificationTime = SQLiteFileSystem::databaseModificationTime(path);
>-        if (!modificationTime)
>-            continue;
>-
>-        if (modificationTime.value() >= time)
>-            databaseOriginsModified.append(origin);
>-    }
>-
>-    return databaseOriginsModified;
>-}
>-
>-Vector<SecurityOriginData> LocalStorageDatabaseTracker::origins() const
>-{
>-    Vector<SecurityOriginData> databaseOrigins;
>-    auto paths = FileSystem::listDirectory(m_localStorageDirectory, "*.localstorage");
>-    
>-    for (const auto& path : paths) {
>-        auto filename = FileSystem::pathGetFileName(path);
>-        auto originIdentifier = filename.substring(0, filename.length() - strlen(".localstorage"));
>-        auto origin = SecurityOriginData::fromDatabaseIdentifier(originIdentifier);
>-        if (origin)
>-            databaseOrigins.append(origin.value());
>-        else
>-            RELEASE_LOG_ERROR(LocalStorageDatabaseTracker, "Unable to extract origin from path %s", path.utf8().data());
>-    }
>-
>-    return databaseOrigins;
>-}
>-
>-Vector<LocalStorageDatabaseTracker::OriginDetails> LocalStorageDatabaseTracker::originDetails()
>-{
>-    Vector<OriginDetails> result;
>-    auto databaseOrigins = origins();
>-    result.reserveInitialCapacity(databaseOrigins.size());
>-
>-    for (const auto& origin : databaseOrigins) {
>-        String path = databasePath(origin);
>-
>-        OriginDetails details;
>-        details.originIdentifier = origin.databaseIdentifier();
>-        details.creationTime = SQLiteFileSystem::databaseCreationTime(path);
>-        details.modificationTime = SQLiteFileSystem::databaseModificationTime(path);
>-        result.uncheckedAppend(details);
>-    }
>-
>-    return result;
>-}
>-
>-String LocalStorageDatabaseTracker::databasePath(const String& filename) const
>-{
>-    if (!SQLiteFileSystem::ensureDatabaseDirectoryExists(m_localStorageDirectory)) {
>-        if (!m_localStorageDirectory.isNull())
>-            LOG_ERROR("Unable to create LocalStorage database path %s", m_localStorageDirectory.utf8().data());
>-        return String();
>-    }
>-
>-#if PLATFORM(IOS_FAMILY)
>-    platformMaybeExcludeFromBackup();
>-#endif
>-
>-    return SQLiteFileSystem::appendDatabaseFileNameToPath(m_localStorageDirectory, filename);
>-}
>-
>-} // namespace WebKit
>diff --git a/Source/WebKit/UIProcess/WebStorage/LocalStorageDatabaseTracker.h b/Source/WebKit/UIProcess/WebStorage/LocalStorageDatabaseTracker.h
>deleted file mode 100644
>index 0991d71272fa094f8baba8423a477b0edd73c522..0000000000000000000000000000000000000000
>--- a/Source/WebKit/UIProcess/WebStorage/LocalStorageDatabaseTracker.h
>+++ /dev/null
>@@ -1,83 +0,0 @@
>-/*
>- * Copyright (C) 2011, 2013 Apple Inc. All rights reserved.
>- *
>- * Redistribution and use in source and binary forms, with or without
>- * modification, are permitted provided that the following conditions
>- * are met:
>- * 1. Redistributions of source code must retain the above copyright
>- *    notice, this list of conditions and the following disclaimer.
>- * 2. Redistributions in binary form must reproduce the above copyright
>- *    notice, this list of conditions and the following disclaimer in the
>- *    documentation and/or other materials provided with the distribution.
>- *
>- * THIS SOFTWARE IS PROVIDED BY APPLE INC. AND ITS CONTRIBUTORS ``AS IS''
>- * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO,
>- * THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
>- * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL APPLE INC. OR ITS CONTRIBUTORS
>- * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
>- * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
>- * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
>- * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
>- * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
>- * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF
>- * THE POSSIBILITY OF SUCH DAMAGE.
>- */
>-
>-#pragma once
>-
>-#include <WebCore/SecurityOriginData.h>
>-#include <wtf/Markable.h>
>-#include <wtf/RefPtr.h>
>-#include <wtf/ThreadSafeRefCounted.h>
>-#include <wtf/WallTime.h>
>-#include <wtf/WorkQueue.h>
>-#include <wtf/text/WTFString.h>
>-
>-namespace WebKit {
>-
>-struct LocalStorageDetails;
>-
>-class LocalStorageDatabaseTracker : public ThreadSafeRefCounted<LocalStorageDatabaseTracker> {
>-public:
>-    static Ref<LocalStorageDatabaseTracker> create(Ref<WorkQueue>&&, const String& localStorageDirectory);
>-    ~LocalStorageDatabaseTracker();
>-
>-    String databasePath(const WebCore::SecurityOriginData&) const;
>-
>-    void didOpenDatabaseWithOrigin(const WebCore::SecurityOriginData&);
>-    void deleteDatabaseWithOrigin(const WebCore::SecurityOriginData&);
>-    void deleteAllDatabases();
>-
>-    // Returns a vector of the origins whose databases should be deleted.
>-    Vector<WebCore::SecurityOriginData> databasesModifiedSince(WallTime);
>-
>-    Vector<WebCore::SecurityOriginData> origins() const;
>-
>-    struct OriginDetails {
>-        String originIdentifier;
>-        Markable<WallTime, WallTime::MarkableTraits> creationTime;
>-        Markable<WallTime, WallTime::MarkableTraits> modificationTime;
>-    };
>-    Vector<OriginDetails> originDetails();
>-
>-private:
>-    LocalStorageDatabaseTracker(Ref<WorkQueue>&&, const String& localStorageDirectory);
>-
>-    String databasePath(const String& filename) const;
>-
>-    enum DatabaseOpeningStrategy {
>-        CreateIfNonExistent,
>-        SkipIfNonExistent
>-    };
>-
>-    RefPtr<WorkQueue> m_queue;
>-    String m_localStorageDirectory;
>-
>-#if PLATFORM(IOS_FAMILY)
>-    void platformMaybeExcludeFromBackup() const;
>-
>-    mutable bool m_hasExcludedFromBackup { false };
>-#endif
>-};
>-
>-} // namespace WebKit
>diff --git a/Source/WebKit/UIProcess/WebStorage/StorageManager.cpp b/Source/WebKit/UIProcess/WebStorage/StorageManager.cpp
>deleted file mode 100644
>index 8cccdc1abd7959e24f499d5bdefe34f8c86f1692..0000000000000000000000000000000000000000
>--- a/Source/WebKit/UIProcess/WebStorage/StorageManager.cpp
>+++ /dev/null
>@@ -1,935 +0,0 @@
>-/*
>- * Copyright (C) 2013-2016 Apple Inc. All rights reserved.
>- *
>- * Redistribution and use in source and binary forms, with or without
>- * modification, are permitted provided that the following conditions
>- * are met:
>- * 1. Redistributions of source code must retain the above copyright
>- *    notice, this list of conditions and the following disclaimer.
>- * 2. Redistributions in binary form must reproduce the above copyright
>- *    notice, this list of conditions and the following disclaimer in the
>- *    documentation and/or other materials provided with the distribution.
>- *
>- * THIS SOFTWARE IS PROVIDED BY APPLE INC. AND ITS CONTRIBUTORS ``AS IS''
>- * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO,
>- * THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
>- * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL APPLE INC. OR ITS CONTRIBUTORS
>- * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
>- * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
>- * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
>- * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
>- * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
>- * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF
>- * THE POSSIBILITY OF SUCH DAMAGE.
>- */
>-
>-#include "config.h"
>-#include "StorageManager.h"
>-
>-#include "LocalStorageDatabase.h"
>-#include "LocalStorageDatabaseTracker.h"
>-#include "StorageAreaMapMessages.h"
>-#include "StorageManagerMessages.h"
>-#include "WebProcessProxy.h"
>-#include <WebCore/SecurityOriginData.h>
>-#include <WebCore/SecurityOriginHash.h>
>-#include <WebCore/StorageMap.h>
>-#include <WebCore/TextEncoding.h>
>-#include <memory>
>-#include <wtf/WorkQueue.h>
>-#include <wtf/threads/BinarySemaphore.h>
>-
>-namespace WebKit {
>-using namespace WebCore;
>-
>-class StorageManager::StorageArea : public ThreadSafeRefCounted<StorageManager::StorageArea> {
>-public:
>-    static Ref<StorageArea> create(LocalStorageNamespace*, const SecurityOriginData&, unsigned quotaInBytes);
>-    ~StorageArea();
>-
>-    const WebCore::SecurityOriginData& securityOrigin() const { return m_securityOrigin; }
>-
>-    void addListener(IPC::Connection::UniqueID, uint64_t storageMapID);
>-    void removeListener(IPC::Connection::UniqueID, uint64_t storageMapID);
>-    bool hasListener(IPC::Connection::UniqueID, uint64_t storageMapID) const;
>-
>-    Ref<StorageArea> clone() const;
>-
>-    void setItem(IPC::Connection::UniqueID sourceConnection, uint64_t sourceStorageAreaID, const String& key, const String& value, const String& urlString, bool& quotaException);
>-    void removeItem(IPC::Connection::UniqueID sourceConnection, uint64_t sourceStorageAreaID, const String& key, const String& urlString);
>-    void clear(IPC::Connection::UniqueID sourceConnection, uint64_t sourceStorageAreaID, const String& urlString);
>-
>-    const HashMap<String, String>& items() const;
>-    void clear();
>-
>-    bool isSessionStorage() const { return !m_localStorageNamespace; }
>-
>-private:
>-    explicit StorageArea(LocalStorageNamespace*, const SecurityOriginData&, unsigned quotaInBytes);
>-
>-    void openDatabaseAndImportItemsIfNeeded() const;
>-
>-    void dispatchEvents(IPC::Connection::UniqueID sourceConnection, uint64_t sourceStorageAreaID, const String& key, const String& oldValue, const String& newValue, const String& urlString) const;
>-
>-    // Will be null if the storage area belongs to a session storage namespace.
>-    LocalStorageNamespace* m_localStorageNamespace;
>-    mutable RefPtr<LocalStorageDatabase> m_localStorageDatabase;
>-    mutable bool m_didImportItemsFromDatabase { false };
>-
>-    SecurityOriginData m_securityOrigin;
>-    unsigned m_quotaInBytes;
>-
>-    RefPtr<StorageMap> m_storageMap;
>-    HashSet<std::pair<IPC::Connection::UniqueID, uint64_t>> m_eventListeners;
>-};
>-
>-class StorageManager::LocalStorageNamespace : public ThreadSafeRefCounted<LocalStorageNamespace> {
>-public:
>-    static Ref<LocalStorageNamespace> create(StorageManager*, uint64_t storageManagerID);
>-    ~LocalStorageNamespace();
>-
>-    StorageManager* storageManager() const { return m_storageManager; }
>-
>-    Ref<StorageArea> getOrCreateStorageArea(SecurityOriginData&&);
>-    void didDestroyStorageArea(StorageArea*);
>-
>-    void clearStorageAreasMatchingOrigin(const SecurityOriginData&);
>-    void clearAllStorageAreas();
>-
>-private:
>-    explicit LocalStorageNamespace(StorageManager*, uint64_t storageManagerID);
>-
>-    StorageManager* m_storageManager;
>-    uint64_t m_storageNamespaceID;
>-    unsigned m_quotaInBytes;
>-
>-    // We don't hold an explicit reference to the StorageAreas; they are kept alive by the m_storageAreasByConnection map in StorageManager.
>-    HashMap<SecurityOriginData, StorageArea*> m_storageAreaMap;
>-};
>-
>-// Suggested by https://www.w3.org/TR/webstorage/#disk-space
>-const unsigned localStorageDatabaseQuotaInBytes = 5 * 1024 * 1024;
>-
>-class StorageManager::TransientLocalStorageNamespace : public ThreadSafeRefCounted<TransientLocalStorageNamespace> {
>-public:
>-    static Ref<TransientLocalStorageNamespace> create()
>-    {
>-        return adoptRef(*new TransientLocalStorageNamespace());
>-    }
>-
>-    ~TransientLocalStorageNamespace()
>-    {
>-    }
>-
>-    Ref<StorageArea> getOrCreateStorageArea(SecurityOriginData&& securityOrigin)
>-    {
>-        return *m_storageAreaMap.ensure(securityOrigin, [this, securityOrigin]() mutable {
>-            return StorageArea::create(nullptr, WTFMove(securityOrigin), m_quotaInBytes);
>-        }).iterator->value.copyRef();
>-    }
>-
>-    Vector<SecurityOriginData> origins() const
>-    {
>-        Vector<SecurityOriginData> origins;
>-
>-        for (const auto& storageArea : m_storageAreaMap.values()) {
>-            if (!storageArea->items().isEmpty())
>-                origins.append(storageArea->securityOrigin());
>-        }
>-
>-        return origins;
>-    }
>-
>-    void clearStorageAreasMatchingOrigin(const SecurityOriginData& securityOrigin)
>-    {
>-        for (auto& storageArea : m_storageAreaMap.values()) {
>-            if (storageArea->securityOrigin() == securityOrigin)
>-                storageArea->clear();
>-        }
>-    }
>-
>-    void clearAllStorageAreas()
>-    {
>-        for (auto& storageArea : m_storageAreaMap.values())
>-            storageArea->clear();
>-    }
>-
>-private:
>-    explicit TransientLocalStorageNamespace()
>-    {
>-    }
>-
>-    const unsigned m_quotaInBytes = localStorageDatabaseQuotaInBytes;
>-
>-    HashMap<SecurityOriginData, RefPtr<StorageArea>> m_storageAreaMap;
>-};
>-
>-auto StorageManager::StorageArea::create(LocalStorageNamespace* localStorageNamespace, const SecurityOriginData& securityOrigin, unsigned quotaInBytes) -> Ref<StorageManager::StorageArea>
>-{
>-    return adoptRef(*new StorageArea(localStorageNamespace, securityOrigin, quotaInBytes));
>-}
>-
>-StorageManager::StorageArea::StorageArea(LocalStorageNamespace* localStorageNamespace, const SecurityOriginData& securityOrigin, unsigned quotaInBytes)
>-    : m_localStorageNamespace(localStorageNamespace)
>-    , m_securityOrigin(securityOrigin)
>-    , m_quotaInBytes(quotaInBytes)
>-    , m_storageMap(StorageMap::create(m_quotaInBytes))
>-{
>-}
>-
>-StorageManager::StorageArea::~StorageArea()
>-{
>-    ASSERT(m_eventListeners.isEmpty());
>-
>-    if (m_localStorageDatabase)
>-        m_localStorageDatabase->close();
>-
>-    if (m_localStorageNamespace)
>-        m_localStorageNamespace->didDestroyStorageArea(this);
>-}
>-
>-void StorageManager::StorageArea::addListener(IPC::Connection::UniqueID connectionID, uint64_t storageMapID)
>-{
>-    ASSERT(!m_eventListeners.contains(std::make_pair(connectionID, storageMapID)));
>-    m_eventListeners.add(std::make_pair(connectionID, storageMapID));
>-}
>-
>-void StorageManager::StorageArea::removeListener(IPC::Connection::UniqueID connectionID, uint64_t storageMapID)
>-{
>-    ASSERT(isSessionStorage() || m_eventListeners.contains(std::make_pair(connectionID, storageMapID)));
>-    m_eventListeners.remove(std::make_pair(connectionID, storageMapID));
>-}
>-
>-bool StorageManager::StorageArea::hasListener(IPC::Connection::UniqueID connectionID, uint64_t storageMapID) const
>-{
>-    return m_eventListeners.contains(std::make_pair(connectionID, storageMapID));
>-}
>-
>-Ref<StorageManager::StorageArea> StorageManager::StorageArea::clone() const
>-{
>-    ASSERT(!m_localStorageNamespace);
>-
>-    auto storageArea = StorageArea::create(nullptr, m_securityOrigin, m_quotaInBytes);
>-    storageArea->m_storageMap = m_storageMap;
>-
>-    return storageArea;
>-}
>-
>-void StorageManager::StorageArea::setItem(IPC::Connection::UniqueID sourceConnection, uint64_t sourceStorageAreaID, const String& key, const String& value, const String& urlString, bool& quotaException)
>-{
>-    openDatabaseAndImportItemsIfNeeded();
>-
>-    String oldValue;
>-
>-    auto newStorageMap = m_storageMap->setItem(key, value, oldValue, quotaException);
>-    if (newStorageMap)
>-        m_storageMap = WTFMove(newStorageMap);
>-
>-    if (quotaException)
>-        return;
>-
>-    if (m_localStorageDatabase)
>-        m_localStorageDatabase->setItem(key, value);
>-
>-    dispatchEvents(sourceConnection, sourceStorageAreaID, key, oldValue, value, urlString);
>-}
>-
>-void StorageManager::StorageArea::removeItem(IPC::Connection::UniqueID sourceConnection, uint64_t sourceStorageAreaID, const String& key, const String& urlString)
>-{
>-    openDatabaseAndImportItemsIfNeeded();
>-
>-    String oldValue;
>-    auto newStorageMap = m_storageMap->removeItem(key, oldValue);
>-    if (newStorageMap)
>-        m_storageMap = WTFMove(newStorageMap);
>-
>-    if (oldValue.isNull())
>-        return;
>-
>-    if (m_localStorageDatabase)
>-        m_localStorageDatabase->removeItem(key);
>-
>-    dispatchEvents(sourceConnection, sourceStorageAreaID, key, oldValue, String(), urlString);
>-}
>-
>-void StorageManager::StorageArea::clear(IPC::Connection::UniqueID sourceConnection, uint64_t sourceStorageAreaID, const String& urlString)
>-{
>-    openDatabaseAndImportItemsIfNeeded();
>-
>-    if (!m_storageMap->length())
>-        return;
>-
>-    m_storageMap = StorageMap::create(m_quotaInBytes);
>-
>-    if (m_localStorageDatabase)
>-        m_localStorageDatabase->clear();
>-
>-    dispatchEvents(sourceConnection, sourceStorageAreaID, String(), String(), String(), urlString);
>-}
>-
>-const HashMap<String, String>& StorageManager::StorageArea::items() const
>-{
>-    openDatabaseAndImportItemsIfNeeded();
>-
>-    return m_storageMap->items();
>-}
>-
>-void StorageManager::StorageArea::clear()
>-{
>-    m_storageMap = StorageMap::create(m_quotaInBytes);
>-
>-    if (m_localStorageDatabase) {
>-        m_localStorageDatabase->close();
>-        m_localStorageDatabase = nullptr;
>-    }
>-
>-    for (auto it = m_eventListeners.begin(), end = m_eventListeners.end(); it != end; ++it) {
>-        RunLoop::main().dispatch([connectionID = it->first, destinationStorageAreaID = it->second] {
>-            if (auto* connection = IPC::Connection::connection(connectionID))
>-                connection->send(Messages::StorageAreaMap::ClearCache(), destinationStorageAreaID);
>-        });
>-    }
>-}
>-
>-void StorageManager::StorageArea::openDatabaseAndImportItemsIfNeeded() const
>-{
>-    if (!m_localStorageNamespace)
>-        return;
>-
>-    // We open the database here even if we've already imported our items to ensure that the database is open if we need to write to it.
>-    if (!m_localStorageDatabase)
>-        m_localStorageDatabase = LocalStorageDatabase::create(m_localStorageNamespace->storageManager()->m_queue.copyRef(), m_localStorageNamespace->storageManager()->m_localStorageDatabaseTracker.copyRef(), m_securityOrigin);
>-
>-    if (m_didImportItemsFromDatabase)
>-        return;
>-
>-    m_localStorageDatabase->importItems(*m_storageMap);
>-    m_didImportItemsFromDatabase = true;
>-}
>-
>-void StorageManager::StorageArea::dispatchEvents(IPC::Connection::UniqueID sourceConnection, uint64_t sourceStorageAreaID, const String& key, const String& oldValue, const String& newValue, const String& urlString) const
>-{
>-    for (auto it = m_eventListeners.begin(), end = m_eventListeners.end(); it != end; ++it) {
>-        sourceStorageAreaID = it->first == sourceConnection ? sourceStorageAreaID : 0;
>-
>-        RunLoop::main().dispatch([connectionID = it->first, sourceStorageAreaID, destinationStorageAreaID = it->second, key = key.isolatedCopy(), oldValue = oldValue.isolatedCopy(), newValue = newValue.isolatedCopy(), urlString = urlString.isolatedCopy()] {
>-            if (auto* connection = IPC::Connection::connection(connectionID))
>-                connection->send(Messages::StorageAreaMap::DispatchStorageEvent(sourceStorageAreaID, key, oldValue, newValue, urlString), destinationStorageAreaID);
>-        });
>-    }
>-}
>-
>-Ref<StorageManager::LocalStorageNamespace> StorageManager::LocalStorageNamespace::create(StorageManager* storageManager, uint64_t storageNamespaceID)
>-{
>-    return adoptRef(*new LocalStorageNamespace(storageManager, storageNamespaceID));
>-}
>-
>-// FIXME: The quota value is copied from GroupSettings.cpp.
>-// We should investigate a way to share it with WebCore.
>-StorageManager::LocalStorageNamespace::LocalStorageNamespace(StorageManager* storageManager, uint64_t storageNamespaceID)
>-    : m_storageManager(storageManager)
>-    , m_storageNamespaceID(storageNamespaceID)
>-    , m_quotaInBytes(localStorageDatabaseQuotaInBytes)
>-{
>-}
>-
>-StorageManager::LocalStorageNamespace::~LocalStorageNamespace()
>-{
>-    ASSERT(m_storageAreaMap.isEmpty());
>-}
>-
>-auto StorageManager::LocalStorageNamespace::getOrCreateStorageArea(SecurityOriginData&& securityOrigin) -> Ref<StorageArea>
>-{
>-    auto& slot = m_storageAreaMap.add(securityOrigin, nullptr).iterator->value;
>-    if (slot)
>-        return *slot;
>-
>-    auto storageArea = StorageArea::create(this, WTFMove(securityOrigin), m_quotaInBytes);
>-    slot = &storageArea.get();
>-
>-    return storageArea;
>-}
>-
>-void StorageManager::LocalStorageNamespace::didDestroyStorageArea(StorageArea* storageArea)
>-{
>-    ASSERT(m_storageAreaMap.contains(storageArea->securityOrigin()));
>-
>-    m_storageAreaMap.remove(storageArea->securityOrigin());
>-    if (!m_storageAreaMap.isEmpty())
>-        return;
>-
>-    ASSERT(m_storageManager->m_localStorageNamespaces.contains(m_storageNamespaceID));
>-    m_storageManager->m_localStorageNamespaces.remove(m_storageNamespaceID);
>-}
>-
>-void StorageManager::LocalStorageNamespace::clearStorageAreasMatchingOrigin(const SecurityOriginData& securityOrigin)
>-{
>-    for (const auto& originAndStorageArea : m_storageAreaMap) {
>-        if (originAndStorageArea.key == securityOrigin)
>-            originAndStorageArea.value->clear();
>-    }
>-}
>-
>-void StorageManager::LocalStorageNamespace::clearAllStorageAreas()
>-{
>-    for (auto* storageArea : m_storageAreaMap.values())
>-        storageArea->clear();
>-}
>-
>-class StorageManager::SessionStorageNamespace : public ThreadSafeRefCounted<SessionStorageNamespace> {
>-public:
>-    static Ref<SessionStorageNamespace> create(unsigned quotaInBytes);
>-    ~SessionStorageNamespace();
>-
>-    bool isEmpty() const { return m_storageAreaMap.isEmpty(); }
>-
>-    Vector<IPC::Connection::UniqueID> allowedConnections() const { return m_allowedConnections; }
>-    void addAllowedConnection(IPC::Connection::UniqueID);
>-    void removeAllowedConnection(IPC::Connection::UniqueID);
>-
>-    Ref<StorageArea> getOrCreateStorageArea(SecurityOriginData&&);
>-
>-    void cloneTo(SessionStorageNamespace& newSessionStorageNamespace);
>-
>-    Vector<SecurityOriginData> origins() const
>-    {
>-        Vector<SecurityOriginData> origins;
>-
>-        for (const auto& storageArea : m_storageAreaMap.values()) {
>-            if (!storageArea->items().isEmpty())
>-                origins.append(storageArea->securityOrigin());
>-        }
>-
>-        return origins;
>-    }
>-
>-    void clearStorageAreasMatchingOrigin(const SecurityOriginData& securityOrigin)
>-    {
>-        for (auto& storageArea : m_storageAreaMap.values()) {
>-            if (storageArea->securityOrigin() == securityOrigin)
>-                storageArea->clear();
>-        }
>-    }
>-
>-    void clearAllStorageAreas()
>-    {
>-        for (auto& storageArea : m_storageAreaMap.values())
>-            storageArea->clear();
>-    }
>-
>-private:
>-    explicit SessionStorageNamespace(unsigned quotaInBytes);
>-
>-    Vector<IPC::Connection::UniqueID> m_allowedConnections;
>-    unsigned m_quotaInBytes;
>-
>-    HashMap<SecurityOriginData, RefPtr<StorageArea>> m_storageAreaMap;
>-};
>-
>-Ref<StorageManager::SessionStorageNamespace> StorageManager::SessionStorageNamespace::create(unsigned quotaInBytes)
>-{
>-    return adoptRef(*new SessionStorageNamespace(quotaInBytes));
>-}
>-
>-StorageManager::SessionStorageNamespace::SessionStorageNamespace(unsigned quotaInBytes)
>-    : m_quotaInBytes(quotaInBytes)
>-{
>-}
>-
>-StorageManager::SessionStorageNamespace::~SessionStorageNamespace()
>-{
>-}
>-
>-void StorageManager::SessionStorageNamespace::addAllowedConnection(IPC::Connection::UniqueID allowedConnection)
>-{
>-    ASSERT(!m_allowedConnections.contains(allowedConnection));
>-    m_allowedConnections.append(allowedConnection);
>-}
>-
>-
>-void StorageManager::SessionStorageNamespace::removeAllowedConnection(IPC::Connection::UniqueID allowedConnection)
>-{
>-    ASSERT(m_allowedConnections.contains(allowedConnection));
>-    m_allowedConnections.removeAll(allowedConnection);
>-}
>-auto StorageManager::SessionStorageNamespace::getOrCreateStorageArea(SecurityOriginData&& securityOrigin) -> Ref<StorageArea>
>-{
>-    return *m_storageAreaMap.ensure(securityOrigin, [this, securityOrigin]() mutable {
>-        return StorageArea::create(nullptr, WTFMove(securityOrigin), m_quotaInBytes);
>-    }).iterator->value.copyRef();
>-}
>-
>-void StorageManager::SessionStorageNamespace::cloneTo(SessionStorageNamespace& newSessionStorageNamespace)
>-{
>-    ASSERT_UNUSED(newSessionStorageNamespace, newSessionStorageNamespace.isEmpty());
>-
>-    for (auto& pair : m_storageAreaMap)
>-        newSessionStorageNamespace.m_storageAreaMap.add(pair.key, pair.value->clone());
>-}
>-
>-Ref<StorageManager> StorageManager::create(const String& localStorageDirectory)
>-{
>-    return adoptRef(*new StorageManager(localStorageDirectory));
>-}
>-
>-StorageManager::StorageManager(const String& localStorageDirectory)
>-    : m_queue(WorkQueue::create("com.apple.WebKit.StorageManager"))
>-    , m_localStorageDatabaseTracker(LocalStorageDatabaseTracker::create(m_queue.copyRef(), localStorageDirectory))
>-    , m_isEphemeral(localStorageDirectory.isNull())
>-{
>-    // Make sure the encoding is initialized before we start dispatching things to the queue.
>-    UTF8Encoding();
>-}
>-
>-StorageManager::~StorageManager()
>-{
>-}
>-
>-void StorageManager::createSessionStorageNamespace(uint64_t storageNamespaceID, unsigned quotaInBytes)
>-{
>-    m_queue->dispatch([this, protectedThis = makeRef(*this), storageNamespaceID, quotaInBytes]() mutable {
>-        ASSERT(!m_sessionStorageNamespaces.contains(storageNamespaceID));
>-
>-        m_sessionStorageNamespaces.set(storageNamespaceID, SessionStorageNamespace::create(quotaInBytes));
>-    });
>-}
>-
>-void StorageManager::destroySessionStorageNamespace(uint64_t storageNamespaceID)
>-{
>-    m_queue->dispatch([this, protectedThis = makeRef(*this), storageNamespaceID] {
>-        ASSERT(m_sessionStorageNamespaces.contains(storageNamespaceID));
>-        m_sessionStorageNamespaces.remove(storageNamespaceID);
>-    });
>-}
>-
>-void StorageManager::addAllowedSessionStorageNamespaceConnection(uint64_t storageNamespaceID, IPC::Connection& allowedConnection)
>-{
>-    auto allowedConnectionID = allowedConnection.uniqueID();
>-    m_queue->dispatch([this, protectedThis = makeRef(*this), allowedConnectionID, storageNamespaceID]() mutable {
>-        ASSERT(m_sessionStorageNamespaces.contains(storageNamespaceID));
>-
>-        m_sessionStorageNamespaces.get(storageNamespaceID)->addAllowedConnection(allowedConnectionID);
>-    });
>-}
>-
>-void StorageManager::removeAllowedSessionStorageNamespaceConnection(uint64_t storageNamespaceID, IPC::Connection& allowedConnection)
>-{
>-    auto allowedConnectionID = allowedConnection.uniqueID();
>-    m_queue->dispatch([this, protectedThis = makeRef(*this), allowedConnectionID, storageNamespaceID]() mutable {
>-        ASSERT(m_sessionStorageNamespaces.contains(storageNamespaceID));
>-
>-        m_sessionStorageNamespaces.get(storageNamespaceID)->removeAllowedConnection(allowedConnectionID);
>-    });
>-}
>-
>-void StorageManager::cloneSessionStorageNamespace(uint64_t storageNamespaceID, uint64_t newStorageNamespaceID)
>-{
>-    m_queue->dispatch([this, protectedThis = makeRef(*this), storageNamespaceID, newStorageNamespaceID] {
>-        SessionStorageNamespace* sessionStorageNamespace = m_sessionStorageNamespaces.get(storageNamespaceID);
>-        if (!sessionStorageNamespace) {
>-            // FIXME: We can get into this situation if someone closes the originating page from within a
>-            // createNewPage callback. We bail for now, but we should really find a way to keep the session storage alive
>-            // so we we'll clone the session storage correctly.
>-            return;
>-        }
>-
>-        SessionStorageNamespace* newSessionStorageNamespace = m_sessionStorageNamespaces.get(newStorageNamespaceID);
>-        ASSERT(newSessionStorageNamespace);
>-
>-        sessionStorageNamespace->cloneTo(*newSessionStorageNamespace);
>-    });
>-}
>-
>-void StorageManager::processWillOpenConnection(WebProcessProxy& process, IPC::Connection& connection)
>-{
>-    connection.addWorkQueueMessageReceiver(Messages::StorageManager::messageReceiverName(), m_queue.get(), this);
>-}
>-
>-void StorageManager::processDidCloseConnection(WebProcessProxy& process, IPC::Connection& connection)
>-{
>-    connection.removeWorkQueueMessageReceiver(Messages::StorageManager::messageReceiverName());
>-
>-    m_queue->dispatch([this, protectedThis = makeRef(*this), connectionID = connection.uniqueID()]() mutable {
>-        Vector<std::pair<IPC::Connection::UniqueID, uint64_t>> connectionAndStorageMapIDPairsToRemove;
>-        for (auto& storageArea : m_storageAreasByConnection) {
>-            if (storageArea.key.first != connectionID)
>-                continue;
>-
>-            storageArea.value->removeListener(storageArea.key.first, storageArea.key.second);
>-            connectionAndStorageMapIDPairsToRemove.append(storageArea.key);
>-        }
>-
>-        for (auto& pair : connectionAndStorageMapIDPairsToRemove)
>-            m_storageAreasByConnection.remove(pair);
>-    });
>-}
>-
>-void StorageManager::getSessionStorageOrigins(Function<void(HashSet<WebCore::SecurityOriginData>&&)>&& completionHandler)
>-{
>-    m_queue->dispatch([this, protectedThis = makeRef(*this), completionHandler = WTFMove(completionHandler)]() mutable {
>-        HashSet<SecurityOriginData> origins;
>-
>-        for (const auto& sessionStorageNamespace : m_sessionStorageNamespaces.values()) {
>-            for (auto& origin : sessionStorageNamespace->origins())
>-                origins.add(origin);
>-        }
>-
>-        RunLoop::main().dispatch([origins = WTFMove(origins), completionHandler = WTFMove(completionHandler)]() mutable {
>-            completionHandler(WTFMove(origins));
>-        });
>-    });
>-}
>-
>-void StorageManager::deleteSessionStorageOrigins(Function<void()>&& completionHandler)
>-{
>-    m_queue->dispatch([this, protectedThis = makeRef(*this), completionHandler = WTFMove(completionHandler)]() mutable {
>-        for (auto& sessionStorageNamespace : m_sessionStorageNamespaces.values())
>-            sessionStorageNamespace->clearAllStorageAreas();
>-
>-        RunLoop::main().dispatch(WTFMove(completionHandler));
>-    });
>-}
>-
>-void StorageManager::deleteSessionStorageEntriesForOrigins(const Vector<WebCore::SecurityOriginData>& origins, Function<void()>&& completionHandler)
>-{
>-    Vector<WebCore::SecurityOriginData> copiedOrigins;
>-    copiedOrigins.reserveInitialCapacity(origins.size());
>-
>-    for (auto& origin : origins)
>-        copiedOrigins.uncheckedAppend(origin.isolatedCopy());
>-
>-    m_queue->dispatch([this, protectedThis = makeRef(*this), copiedOrigins = WTFMove(copiedOrigins), completionHandler = WTFMove(completionHandler)]() mutable {
>-        for (auto& origin : copiedOrigins) {
>-            for (auto& sessionStorageNamespace : m_sessionStorageNamespaces.values())
>-                sessionStorageNamespace->clearStorageAreasMatchingOrigin(origin);
>-        }
>-
>-        RunLoop::main().dispatch(WTFMove(completionHandler));
>-    });
>-}
>-
>-void StorageManager::getLocalStorageOrigins(Function<void(HashSet<WebCore::SecurityOriginData>&&)>&& completionHandler)
>-{
>-    m_queue->dispatch([this, protectedThis = makeRef(*this), completionHandler = WTFMove(completionHandler)]() mutable {
>-        HashSet<SecurityOriginData> origins;
>-
>-        for (auto& origin : m_localStorageDatabaseTracker->origins())
>-            origins.add(origin);
>-
>-        for (auto& transientLocalStorageNamespace : m_transientLocalStorageNamespaces.values()) {
>-            for (auto& origin : transientLocalStorageNamespace->origins())
>-                origins.add(origin);
>-        }
>-
>-        RunLoop::main().dispatch([origins = WTFMove(origins), completionHandler = WTFMove(completionHandler)]() mutable {
>-            completionHandler(WTFMove(origins));
>-        });
>-    });
>-}
>-
>-void StorageManager::getLocalStorageOriginDetails(Function<void (Vector<LocalStorageDatabaseTracker::OriginDetails>)>&& completionHandler)
>-{
>-    m_queue->dispatch([this, protectedThis = makeRef(*this), completionHandler = WTFMove(completionHandler)]() mutable {
>-        auto originDetails = m_localStorageDatabaseTracker->originDetails();
>-
>-        RunLoop::main().dispatch([originDetails = WTFMove(originDetails), completionHandler = WTFMove(completionHandler)]() mutable {
>-            completionHandler(WTFMove(originDetails));
>-        });
>-    });
>-}
>-
>-void StorageManager::deleteLocalStorageEntriesForOrigin(const SecurityOriginData& securityOrigin)
>-{
>-    m_queue->dispatch([this, protectedThis = makeRef(*this), copiedOrigin = securityOrigin.isolatedCopy()]() mutable {
>-        for (auto& localStorageNamespace : m_localStorageNamespaces.values())
>-            localStorageNamespace->clearStorageAreasMatchingOrigin(copiedOrigin);
>-
>-        for (auto& transientLocalStorageNamespace : m_transientLocalStorageNamespaces.values())
>-            transientLocalStorageNamespace->clearStorageAreasMatchingOrigin(copiedOrigin);
>-
>-        m_localStorageDatabaseTracker->deleteDatabaseWithOrigin(copiedOrigin);
>-    });
>-}
>-
>-void StorageManager::deleteLocalStorageOriginsModifiedSince(WallTime time, Function<void()>&& completionHandler)
>-{
>-    m_queue->dispatch([this, protectedThis = makeRef(*this), time, completionHandler = WTFMove(completionHandler)]() mutable {
>-        auto originsToDelete = m_localStorageDatabaseTracker->databasesModifiedSince(time);
>-        
>-        for (auto& transientLocalStorageNamespace : m_transientLocalStorageNamespaces.values())
>-            transientLocalStorageNamespace->clearAllStorageAreas();
>-
>-        for (const auto& origin : originsToDelete) {
>-            for (auto& localStorageNamespace : m_localStorageNamespaces.values())
>-                localStorageNamespace->clearStorageAreasMatchingOrigin(origin);
>-            
>-            m_localStorageDatabaseTracker->deleteDatabaseWithOrigin(origin);
>-        }
>-
>-        RunLoop::main().dispatch(WTFMove(completionHandler));
>-    });
>-}
>-
>-void StorageManager::deleteLocalStorageEntriesForOrigins(const Vector<WebCore::SecurityOriginData>& origins, Function<void()>&& completionHandler)
>-{
>-    Vector<SecurityOriginData> copiedOrigins;
>-    copiedOrigins.reserveInitialCapacity(origins.size());
>-
>-    for (auto& origin : origins)
>-        copiedOrigins.uncheckedAppend(origin.isolatedCopy());
>-
>-    m_queue->dispatch([this, protectedThis = makeRef(*this), copiedOrigins = WTFMove(copiedOrigins), completionHandler = WTFMove(completionHandler)]() mutable {
>-        for (auto& origin : copiedOrigins) {
>-            for (auto& localStorageNamespace : m_localStorageNamespaces.values())
>-                localStorageNamespace->clearStorageAreasMatchingOrigin(origin);
>-
>-            for (auto& transientLocalStorageNamespace : m_transientLocalStorageNamespaces.values())
>-                transientLocalStorageNamespace->clearStorageAreasMatchingOrigin(origin);
>-
>-            m_localStorageDatabaseTracker->deleteDatabaseWithOrigin(origin);
>-        }
>-
>-        RunLoop::main().dispatch(WTFMove(completionHandler));
>-    });
>-}
>-
>-void StorageManager::createLocalStorageMap(IPC::Connection& connection, uint64_t storageMapID, uint64_t storageNamespaceID, SecurityOriginData&& securityOriginData)
>-{
>-    ASSERT(!m_isEphemeral);
>-    std::pair<IPC::Connection::UniqueID, uint64_t> connectionAndStorageMapIDPair(connection.uniqueID(), storageMapID);
>-
>-    // FIXME: This should be a message check.
>-    ASSERT((HashMap<std::pair<IPC::Connection::UniqueID, uint64_t>, RefPtr<StorageArea>>::isValidKey(connectionAndStorageMapIDPair)));
>-
>-    auto result = m_storageAreasByConnection.add(connectionAndStorageMapIDPair, nullptr);
>-
>-    // FIXME: These should be a message checks.
>-    ASSERT(result.isNewEntry);
>-    ASSERT((HashMap<uint64_t, RefPtr<LocalStorageNamespace>>::isValidKey(storageNamespaceID)));
>-
>-    LocalStorageNamespace* localStorageNamespace = getOrCreateLocalStorageNamespace(storageNamespaceID);
>-
>-    // FIXME: This should be a message check.
>-    ASSERT(localStorageNamespace);
>-
>-    auto storageArea = localStorageNamespace->getOrCreateStorageArea(WTFMove(securityOriginData));
>-    storageArea->addListener(connection.uniqueID(), storageMapID);
>-
>-    result.iterator->value = WTFMove(storageArea);
>-}
>-
>-void StorageManager::createTransientLocalStorageMap(IPC::Connection& connection, uint64_t storageMapID, uint64_t storageNamespaceID, SecurityOriginData&& topLevelOriginData, SecurityOriginData&& origin)
>-{
>-    // FIXME: This should be a message check.
>-    ASSERT(m_storageAreasByConnection.isValidKey({ connection.uniqueID(), storageMapID }));
>-
>-    // See if we already have session storage for this connection/origin combo.
>-    // If so, update the map with the new ID, otherwise keep on trucking.
>-    for (auto it = m_storageAreasByConnection.begin(), end = m_storageAreasByConnection.end(); it != end; ++it) {
>-        if (it->key.first != connection.uniqueID())
>-            continue;
>-        Ref<StorageArea> area = *it->value;
>-        if (!area->isSessionStorage())
>-            continue;
>-        if (!origin.securityOrigin()->isSameSchemeHostPort(area->securityOrigin().securityOrigin().get()))
>-            continue;
>-        area->addListener(connection.uniqueID(), storageMapID);
>-        // If the storageMapID used as key in m_storageAreasByConnection is no longer one of the StorageArea's listeners, then this means
>-        // that destroyStorageMap() was already called for that storageMapID but it decided not to remove it from m_storageAreasByConnection
>-        // so that we could reuse it later on for the same connection/origin combo. In this case, it is safe to remove the previous
>-        // storageMapID from m_storageAreasByConnection.
>-        if (!area->hasListener(connection.uniqueID(), it->key.second))
>-            m_storageAreasByConnection.remove(it);
>-        m_storageAreasByConnection.add({ connection.uniqueID(), storageMapID }, WTFMove(area));
>-        return;
>-    }
>-
>-    auto& slot = m_storageAreasByConnection.add({ connection.uniqueID(), storageMapID }, nullptr).iterator->value;
>-
>-    // FIXME: This should be a message check.
>-    ASSERT(!slot);
>-
>-    TransientLocalStorageNamespace* transientLocalStorageNamespace = getOrCreateTransientLocalStorageNamespace(storageNamespaceID, WTFMove(topLevelOriginData));
>-
>-    auto storageArea = transientLocalStorageNamespace->getOrCreateStorageArea(WTFMove(origin));
>-    storageArea->addListener(connection.uniqueID(), storageMapID);
>-
>-    slot = WTFMove(storageArea);
>-}
>-
>-void StorageManager::createSessionStorageMap(IPC::Connection& connection, uint64_t storageMapID, uint64_t storageNamespaceID, SecurityOriginData&& securityOriginData)
>-{
>-    if (m_isEphemeral) {
>-        m_ephemeralStorage.add(securityOriginData, WebCore::StorageMap::create(localStorageDatabaseQuotaInBytes));
>-        return;
>-    }
>-    // FIXME: This should be a message check.
>-    ASSERT(m_sessionStorageNamespaces.isValidKey(storageNamespaceID));
>-
>-    SessionStorageNamespace* sessionStorageNamespace = m_sessionStorageNamespaces.get(storageNamespaceID);
>-    if (!sessionStorageNamespace) {
>-        // We're getting an incoming message from the web process that's for session storage for a web page
>-        // that has already been closed, just ignore it.
>-        return;
>-    }
>-
>-    // FIXME: This should be a message check.
>-    ASSERT(m_storageAreasByConnection.isValidKey({ connection.uniqueID(), storageMapID }));
>-
>-    auto& slot = m_storageAreasByConnection.add({ connection.uniqueID(), storageMapID }, nullptr).iterator->value;
>-
>-    // FIXME: This should be a message check.
>-    ASSERT(!slot);
>-
>-    // FIXME: This should be a message check.
>-    ASSERT(sessionStorageNamespace->allowedConnections().contains(connection.uniqueID()));
>-
>-    auto storageArea = sessionStorageNamespace->getOrCreateStorageArea(WTFMove(securityOriginData));
>-    storageArea->addListener(connection.uniqueID(), storageMapID);
>-
>-    slot = WTFMove(storageArea);
>-}
>-
>-void StorageManager::destroyStorageMap(IPC::Connection& connection, uint64_t storageMapID)
>-{
>-    std::pair<IPC::Connection::UniqueID, uint64_t> connectionAndStorageMapIDPair(connection.uniqueID(), storageMapID);
>-
>-    // FIXME: This should be a message check.
>-    ASSERT(m_storageAreasByConnection.isValidKey(connectionAndStorageMapIDPair));
>-
>-    auto it = m_storageAreasByConnection.find(connectionAndStorageMapIDPair);
>-    if (it == m_storageAreasByConnection.end()) {
>-        // The connection has been removed because the last page was closed.
>-        return;
>-    }
>-
>-    it->value->removeListener(connection.uniqueID(), storageMapID);
>-
>-    // Don't remove session storage maps. The web process may reconnect and expect the data to still be around.
>-    if (it->value->isSessionStorage())
>-        return;
>-
>-    m_storageAreasByConnection.remove(connectionAndStorageMapIDPair);
>-}
>-
>-void StorageManager::getValues(IPC::Connection& connection, WebCore::SecurityOriginData&& securityOriginData, uint64_t storageMapID, uint64_t storageMapSeed, CompletionHandler<void(const HashMap<String, String>&)>&& completionHandler)
>-{
>-    StorageArea* storageArea = findStorageArea(connection, storageMapID);
>-    if (!storageArea) {
>-        if (m_isEphemeral) {
>-            if (auto storageMap = m_ephemeralStorage.get(securityOriginData))
>-                return completionHandler(storageMap->items());
>-        }
>-        // This is a session storage area for a page that has already been closed. Ignore it.
>-        return completionHandler({ });
>-    }
>-
>-    completionHandler(storageArea->items());
>-    connection.send(Messages::StorageAreaMap::DidGetValues(storageMapSeed), storageMapID);
>-}
>-
>-void StorageManager::setItem(IPC::Connection& connection, WebCore::SecurityOriginData&& securityOriginData, uint64_t storageMapID, uint64_t sourceStorageAreaID, uint64_t storageMapSeed, const String& key, const String& value, const String& urlString)
>-{
>-    StorageArea* storageArea = findStorageArea(connection, storageMapID);
>-    if (!storageArea) {
>-        if (m_isEphemeral) {
>-            if (auto storageMap = m_ephemeralStorage.get(securityOriginData)) {
>-                String oldValue;
>-                bool quotaException;
>-                storageMap->setItem(key, value, oldValue, quotaException);
>-            }
>-        }
>-        // This is a session storage area for a page that has already been closed. Ignore it.
>-        return;
>-    }
>-
>-    bool quotaError;
>-    storageArea->setItem(connection.uniqueID(), sourceStorageAreaID, key, value, urlString, quotaError);
>-    connection.send(Messages::StorageAreaMap::DidSetItem(storageMapSeed, key, quotaError), storageMapID);
>-}
>-
>-void StorageManager::removeItem(IPC::Connection& connection, WebCore::SecurityOriginData&& securityOriginData, uint64_t storageMapID, uint64_t sourceStorageAreaID, uint64_t storageMapSeed, const String& key, const String& urlString)
>-{
>-    StorageArea* storageArea = findStorageArea(connection, storageMapID);
>-    if (!storageArea) {
>-        if (m_isEphemeral) {
>-            if (auto storageMap = m_ephemeralStorage.get(securityOriginData)) {
>-                String oldValue;
>-                storageMap->removeItem(key, oldValue);
>-            }
>-        }
>-        // This is a session storage area for a page that has already been closed. Ignore it.
>-        return;
>-    }
>-
>-    storageArea->removeItem(connection.uniqueID(), sourceStorageAreaID, key, urlString);
>-    connection.send(Messages::StorageAreaMap::DidRemoveItem(storageMapSeed, key), storageMapID);
>-}
>-
>-void StorageManager::clear(IPC::Connection& connection, WebCore::SecurityOriginData&& securityOriginData, uint64_t storageMapID, uint64_t sourceStorageAreaID, uint64_t storageMapSeed, const String& urlString)
>-{
>-    StorageArea* storageArea = findStorageArea(connection, storageMapID);
>-    if (!storageArea) {
>-        if (m_isEphemeral)
>-            m_ephemeralStorage.remove(securityOriginData);
>-        // This is a session storage area for a page that has already been closed. Ignore it.
>-        return;
>-    }
>-
>-    storageArea->clear(connection.uniqueID(), sourceStorageAreaID, urlString);
>-    connection.send(Messages::StorageAreaMap::DidClear(storageMapSeed), storageMapID);
>-}
>-
>-void StorageManager::applicationWillTerminate()
>-{
>-    BinarySemaphore semaphore;
>-    m_queue->dispatch([this, &semaphore] {
>-        Vector<std::pair<IPC::Connection::UniqueID, uint64_t>> connectionAndStorageMapIDPairsToRemove;
>-        for (auto& connectionStorageAreaPair : m_storageAreasByConnection) {
>-            connectionStorageAreaPair.value->removeListener(connectionStorageAreaPair.key.first, connectionStorageAreaPair.key.second);
>-            connectionAndStorageMapIDPairsToRemove.append(connectionStorageAreaPair.key);
>-        }
>-
>-        for (auto& connectionStorageAreaPair : connectionAndStorageMapIDPairsToRemove)
>-            m_storageAreasByConnection.remove(connectionStorageAreaPair);
>-
>-        semaphore.signal();
>-    });
>-    semaphore.wait();
>-}
>-
>-StorageManager::StorageArea* StorageManager::findStorageArea(IPC::Connection& connection, uint64_t storageMapID) const
>-{
>-    std::pair<IPC::Connection::UniqueID, uint64_t> connectionAndStorageMapIDPair(connection.uniqueID(), storageMapID);
>-
>-    if (!m_storageAreasByConnection.isValidKey(connectionAndStorageMapIDPair))
>-        return nullptr;
>-
>-    return m_storageAreasByConnection.get(connectionAndStorageMapIDPair);
>-}
>-
>-StorageManager::LocalStorageNamespace* StorageManager::getOrCreateLocalStorageNamespace(uint64_t storageNamespaceID)
>-{
>-    if (!m_localStorageNamespaces.isValidKey(storageNamespaceID))
>-        return nullptr;
>-
>-    auto& slot = m_localStorageNamespaces.add(storageNamespaceID, nullptr).iterator->value;
>-    if (!slot)
>-        slot = LocalStorageNamespace::create(this, storageNamespaceID);
>-
>-    return slot.get();
>-}
>-
>-StorageManager::TransientLocalStorageNamespace* StorageManager::getOrCreateTransientLocalStorageNamespace(uint64_t storageNamespaceID, WebCore::SecurityOriginData&& topLevelOrigin)
>-{
>-    if (!m_transientLocalStorageNamespaces.isValidKey({ storageNamespaceID, topLevelOrigin }))
>-        return nullptr;
>-
>-    auto& slot = m_transientLocalStorageNamespaces.add({ storageNamespaceID, WTFMove(topLevelOrigin) }, nullptr).iterator->value;
>-    if (!slot)
>-        slot = TransientLocalStorageNamespace::create();
>-
>-    return slot.get();
>-}
>-
>-} // namespace WebKit
>diff --git a/Source/WebKit/UIProcess/WebStorage/StorageManager.h b/Source/WebKit/UIProcess/WebStorage/StorageManager.h
>deleted file mode 100644
>index d6f62a0f49e6f062f58ddac7a2e123fb45453f1c..0000000000000000000000000000000000000000
>--- a/Source/WebKit/UIProcess/WebStorage/StorageManager.h
>+++ /dev/null
>@@ -1,117 +0,0 @@
>-/*
>- * Copyright (C) 2013 Apple Inc. All rights reserved.
>- *
>- * Redistribution and use in source and binary forms, with or without
>- * modification, are permitted provided that the following conditions
>- * are met:
>- * 1. Redistributions of source code must retain the above copyright
>- *    notice, this list of conditions and the following disclaimer.
>- * 2. Redistributions in binary form must reproduce the above copyright
>- *    notice, this list of conditions and the following disclaimer in the
>- *    documentation and/or other materials provided with the distribution.
>- *
>- * THIS SOFTWARE IS PROVIDED BY APPLE INC. AND ITS CONTRIBUTORS ``AS IS''
>- * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO,
>- * THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
>- * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL APPLE INC. OR ITS CONTRIBUTORS
>- * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
>- * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
>- * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
>- * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
>- * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
>- * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF
>- * THE POSSIBILITY OF SUCH DAMAGE.
>- */
>-
>-#pragma once
>-
>-#include "Connection.h"
>-#include "LocalStorageDatabaseTracker.h"
>-#include <WebCore/SecurityOriginData.h>
>-#include <WebCore/StorageMap.h>
>-#include <wtf/Forward.h>
>-#include <wtf/Function.h>
>-#include <wtf/HashSet.h>
>-#include <wtf/ThreadSafeRefCounted.h>
>-#include <wtf/text/StringHash.h>
>-
>-namespace WebCore {
>-class SecurityOrigin;
>-}
>-
>-namespace WebKit {
>-
>-class LocalStorageDatabaseTracker;
>-class WebProcessProxy;
>-
>-class StorageManager : public IPC::Connection::WorkQueueMessageReceiver {
>-public:
>-    static Ref<StorageManager> create(const String& localStorageDirectory);
>-    ~StorageManager();
>-
>-    void createSessionStorageNamespace(uint64_t storageNamespaceID, unsigned quotaInBytes);
>-    void destroySessionStorageNamespace(uint64_t storageNamespaceID);
>-    void addAllowedSessionStorageNamespaceConnection(uint64_t storageNamespaceID, IPC::Connection&);
>-    void removeAllowedSessionStorageNamespaceConnection(uint64_t storageNamespaceID, IPC::Connection&);
>-    void cloneSessionStorageNamespace(uint64_t storageNamespaceID, uint64_t newStorageNamespaceID);
>-
>-    void processWillOpenConnection(WebProcessProxy&, IPC::Connection&);
>-    void processDidCloseConnection(WebProcessProxy&, IPC::Connection&);
>-    void applicationWillTerminate();
>-
>-    void getSessionStorageOrigins(Function<void(HashSet<WebCore::SecurityOriginData>&&)>&& completionHandler);
>-    void deleteSessionStorageOrigins(Function<void()>&& completionHandler);
>-    void deleteSessionStorageEntriesForOrigins(const Vector<WebCore::SecurityOriginData>&, Function<void()>&& completionHandler);
>-
>-    void getLocalStorageOrigins(Function<void(HashSet<WebCore::SecurityOriginData>&&)>&& completionHandler);
>-    void deleteLocalStorageEntriesForOrigin(const WebCore::SecurityOriginData&);
>-
>-    void deleteLocalStorageOriginsModifiedSince(WallTime, Function<void()>&& completionHandler);
>-    void deleteLocalStorageEntriesForOrigins(const Vector<WebCore::SecurityOriginData>&, Function<void()>&& completionHandler);
>-
>-    void getLocalStorageOriginDetails(Function<void(Vector<LocalStorageDatabaseTracker::OriginDetails>)>&& completionHandler);
>-
>-private:
>-    explicit StorageManager(const String& localStorageDirectory);
>-
>-    // IPC::Connection::WorkQueueMessageReceiver.
>-    void didReceiveMessage(IPC::Connection&, IPC::Decoder&) override;
>-    void didReceiveSyncMessage(IPC::Connection&, IPC::Decoder&, std::unique_ptr<IPC::Encoder>& replyEncoder) override;
>-
>-    // Message handlers.
>-    void createLocalStorageMap(IPC::Connection&, uint64_t storageMapID, uint64_t storageNamespaceID, WebCore::SecurityOriginData&&);
>-    void createTransientLocalStorageMap(IPC::Connection&, uint64_t storageMapID, uint64_t storageNamespaceID, WebCore::SecurityOriginData&& topLevelOriginData, WebCore::SecurityOriginData&&);
>-    void createSessionStorageMap(IPC::Connection&, uint64_t storageMapID, uint64_t storageNamespaceID, WebCore::SecurityOriginData&&);
>-    void destroyStorageMap(IPC::Connection&, uint64_t storageMapID);
>-
>-    void getValues(IPC::Connection&, WebCore::SecurityOriginData&&, uint64_t storageMapID, uint64_t storageMapSeed, CompletionHandler<void(const HashMap<String, String>&)>&&);
>-    void setItem(IPC::Connection&, WebCore::SecurityOriginData&&, uint64_t storageAreaID, uint64_t sourceStorageAreaID, uint64_t storageMapSeed, const String& key, const String& value, const String& urlString);
>-    void removeItem(IPC::Connection&, WebCore::SecurityOriginData&&, uint64_t storageMapID, uint64_t sourceStorageAreaID, uint64_t storageMapSeed, const String& key, const String& urlString);
>-    void clear(IPC::Connection&, WebCore::SecurityOriginData&&, uint64_t storageMapID, uint64_t sourceStorageAreaID, uint64_t storageMapSeed, const String& urlString);
>-
>-    class StorageArea;
>-    StorageArea* findStorageArea(IPC::Connection&, uint64_t) const;
>-
>-    class LocalStorageNamespace;
>-    LocalStorageNamespace* getOrCreateLocalStorageNamespace(uint64_t storageNamespaceID);
>-
>-    class TransientLocalStorageNamespace;
>-    TransientLocalStorageNamespace* getOrCreateTransientLocalStorageNamespace(uint64_t storageNamespaceID, WebCore::SecurityOriginData&& topLevelOrigin);
>-
>-    Ref<WorkQueue> m_queue;
>-
>-    Ref<LocalStorageDatabaseTracker> m_localStorageDatabaseTracker;
>-    HashMap<uint64_t, RefPtr<LocalStorageNamespace>> m_localStorageNamespaces;
>-
>-    HashMap<std::pair<uint64_t, WebCore::SecurityOriginData>, RefPtr<TransientLocalStorageNamespace>> m_transientLocalStorageNamespaces;
>-
>-    class SessionStorageNamespace;
>-    HashMap<uint64_t, RefPtr<SessionStorageNamespace>> m_sessionStorageNamespaces;
>-
>-    HashMap<std::pair<IPC::Connection::UniqueID, uint64_t>, RefPtr<StorageArea>> m_storageAreasByConnection;
>-
>-    HashMap<WebCore::SecurityOriginData, Ref<WebCore::StorageMap>> m_ephemeralStorage;
>-    bool m_isEphemeral { false };
>-};
>-
>-} // namespace WebKit
>diff --git a/Source/WebKit/UIProcess/WebStorage/StorageManager.messages.in b/Source/WebKit/UIProcess/WebStorage/StorageManager.messages.in
>deleted file mode 100644
>index b3b6dbf279803514e535b1e0374db7dbe9969cba..0000000000000000000000000000000000000000
>--- a/Source/WebKit/UIProcess/WebStorage/StorageManager.messages.in
>+++ /dev/null
>@@ -1,34 +0,0 @@
>-# Copyright (C) 2013 Apple Inc. All rights reserved.
>-#
>-# Redistribution and use in source and binary forms, with or without
>-# modification, are permitted provided that the following conditions
>-# are met:
>-# 1.  Redistributions of source code must retain the above copyright
>-#     notice, this list of conditions and the following disclaimer.
>-# 2.  Redistributions in binary form must reproduce the above copyright
>-#     notice, this list of conditions and the following disclaimer in the
>-#     documentation and/or other materials provided with the distribution.
>-#
>-# THIS SOFTWARE IS PROVIDED BY APPLE INC. AND ITS CONTRIBUTORS ``AS IS'' AND
>-# ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
>-# WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
>-# DISCLAIMED. IN NO EVENT SHALL APPLE INC. OR ITS CONTRIBUTORS BE LIABLE FOR
>-# ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
>-# DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
>-# SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
>-# CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
>-# OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
>-# OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
>-
>-messages -> StorageManager {
>-    CreateLocalStorageMap(uint64_t storageMapID, uint64_t storageNamespaceID, struct WebCore::SecurityOriginData securityOriginData) WantsConnection
>-    CreateTransientLocalStorageMap(uint64_t storageMapID, uint64_t storageNamespaceID, struct WebCore::SecurityOriginData topLevelSecurityOriginData, struct WebCore::SecurityOriginData securityOriginData) WantsConnection
>-    CreateSessionStorageMap(uint64_t storageMapID, uint64_t storageNamespaceID, struct WebCore::SecurityOriginData securityOriginData) WantsConnection
>-    DestroyStorageMap(uint64_t storageMapID) WantsConnection
>-
>-    GetValues(struct WebCore::SecurityOriginData securityOriginData, uint64_t storageMapID, uint64_t storageMapSeed) -> (HashMap<String, String> values) Synchronous WantsConnection
>-
>-    SetItem(struct WebCore::SecurityOriginData securityOriginData, uint64_t storageMapID, uint64_t sourceStorageAreaID, uint64_t storageMapSeed, String key, String value, String urlString) WantsConnection
>-    RemoveItem(struct WebCore::SecurityOriginData securityOriginData, uint64_t storageMapID, uint64_t sourceStorageAreaID, uint64_t storageMapSeed, String key, String urlString) WantsConnection
>-    Clear(struct WebCore::SecurityOriginData securityOriginData, uint64_t storageMapID, uint64_t sourceStorageAreaID, uint64_t storageMapSeed, String urlString) WantsConnection
>-}
>diff --git a/Source/WebKit/UIProcess/WebStorage/ios/LocalStorageDatabaseTrackerIOS.mm b/Source/WebKit/UIProcess/WebStorage/ios/LocalStorageDatabaseTrackerIOS.mm
>deleted file mode 100644
>index 9b01e896360f42c9f5097ff280b7ff615e65414f..0000000000000000000000000000000000000000
>--- a/Source/WebKit/UIProcess/WebStorage/ios/LocalStorageDatabaseTrackerIOS.mm
>+++ /dev/null
>@@ -1,48 +0,0 @@
>-/*
>- * Copyright (C) 2017 Apple Inc. All rights reserved.
>- *
>- * Redistribution and use in source and binary forms, with or without
>- * modification, are permitted provided that the following conditions
>- * are met:
>- * 1. Redistributions of source code must retain the above copyright
>- *    notice, this list of conditions and the following disclaimer.
>- * 2. Redistributions in binary form must reproduce the above copyright
>- *    notice, this list of conditions and the following disclaimer in the
>- *    documentation and/or other materials provided with the distribution.
>- *
>- * THIS SOFTWARE IS PROVIDED BY APPLE INC. AND ITS CONTRIBUTORS ``AS IS''
>- * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO,
>- * THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
>- * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL APPLE INC. OR ITS CONTRIBUTORS
>- * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
>- * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
>- * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
>- * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
>- * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
>- * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF
>- * THE POSSIBILITY OF SUCH DAMAGE.
>- */
>-
>-#include "config.h"
>-#include "LocalStorageDatabaseTracker.h"
>-
>-#if PLATFORM(IOS_FAMILY)
>-
>-#include "VersionChecks.h"
>-
>-namespace WebKit {
>-
>-void LocalStorageDatabaseTracker::platformMaybeExcludeFromBackup() const
>-{
>-    if (m_hasExcludedFromBackup)
>-        return;
>-
>-    m_hasExcludedFromBackup = true;
>-
>-    if (linkedOnOrAfter(SDKVersion::FirstToExcludeLocalStorageFromBackup))
>-        [[NSURL fileURLWithPath:(NSString *)m_localStorageDirectory isDirectory:YES] setResourceValue:@YES forKey:NSURLIsExcludedFromBackupKey error:nil];
>-}
>-
>-} // namespace WebKit
>-
>-#endif
>diff --git a/Source/WebKit/UIProcess/WebsiteData/Cocoa/WebsiteDataStoreCocoa.mm b/Source/WebKit/UIProcess/WebsiteData/Cocoa/WebsiteDataStoreCocoa.mm
>index 716a231883352a08defd667f05375bcb6e947208..3374b261614ebd50670185e8bd37c29d27679be1 100644
>--- a/Source/WebKit/UIProcess/WebsiteData/Cocoa/WebsiteDataStoreCocoa.mm
>+++ b/Source/WebKit/UIProcess/WebsiteData/Cocoa/WebsiteDataStoreCocoa.mm
>@@ -107,6 +107,11 @@ WebsiteDataStoreParameters WebsiteDataStore::parameters()
>     if (!resourceLoadStatisticsDirectory.isEmpty())
>         SandboxExtension::createHandleForReadWriteDirectory(resourceLoadStatisticsDirectory, resourceLoadStatisticsDirectoryHandle);
> 
>+    auto localStorageDirectory = resolvedLocalStorageDirectory();
>+    SandboxExtension::Handle localStorageDirectoryExtensionHandle;
>+    if (!localStorageDirectory.isEmpty())
>+        SandboxExtension::createHandleForReadWriteDirectory(localStorageDirectory, localStorageDirectoryExtensionHandle);
>+
>     bool shouldIncludeLocalhostInResourceLoadStatistics = isSafari;
>     WebsiteDataStoreParameters parameters;
>     parameters.networkSessionParameters = {
>@@ -126,7 +131,9 @@ WebsiteDataStoreParameters WebsiteDataStore::parameters()
>         false,
>         shouldIncludeLocalhostInResourceLoadStatistics,
>         enableResourceLoadStatisticsDebugMode,
>-        WTFMove(resourceLoadStatisticsManualPrevalentResource)
>+        WTFMove(resourceLoadStatisticsManualPrevalentResource),
>+        WTFMove(localStorageDirectory),
>+        WTFMove(localStorageDirectoryExtensionHandle)
>     };
>     networkingHasBegun();
> 
>@@ -168,9 +175,6 @@ WebsiteDataStoreParameters WebsiteDataStore::parameters()
> 
> void WebsiteDataStore::platformInitialize()
> {
>-    if (!m_storageManager)
>-        return;
>-
>     if (!terminationObserver) {
>         ASSERT(dataStoresWithStorageManagers().isEmpty());
> 
>@@ -181,7 +185,6 @@ void WebsiteDataStore::platformInitialize()
> #endif
>         terminationObserver = [[NSNotificationCenter defaultCenter] addObserverForName:notificationName object:nil queue:nil usingBlock:^(NSNotification *note) {
>             for (auto& dataStore : dataStoresWithStorageManagers()) {
>-                dataStore->m_storageManager->applicationWillTerminate();
> #if ENABLE(RESOURCE_LOAD_STATISTICS)
>                 if (dataStore->m_resourceLoadStatistics)
>                     dataStore->m_resourceLoadStatistics->applicationWillTerminate();
>@@ -201,12 +204,6 @@ void WebsiteDataStore::platformDestroy()
>         m_resourceLoadStatistics->applicationWillTerminate();
> #endif
> 
>-    if (!m_storageManager)
>-        return;
>-
>-    // FIXME: Rename applicationWillTerminate to something that better indicates what StorageManager does (waits for pending writes to finish).
>-    m_storageManager->applicationWillTerminate();
>-
>     ASSERT(dataStoresWithStorageManagers().contains(this));
>     dataStoresWithStorageManagers().removeFirst(this);
> 
>diff --git a/Source/WebKit/UIProcess/WebsiteData/WebsiteDataStore.cpp b/Source/WebKit/UIProcess/WebsiteData/WebsiteDataStore.cpp
>index 56e18aaa45abac7c4903b6c8947c7e8f07e9bb2f..7c85485d5ffbebf0833c114d75d68be4770986e2 100644
>--- a/Source/WebKit/UIProcess/WebsiteData/WebsiteDataStore.cpp
>+++ b/Source/WebKit/UIProcess/WebsiteData/WebsiteDataStore.cpp
>@@ -35,7 +35,6 @@
> #include "NetworkProcessMessages.h"
> #include "ShouldGrandfatherStatistics.h"
> #include "StorageAccessStatus.h"
>-#include "StorageManager.h"
> #include "WebProcessCache.h"
> #include "WebProcessMessages.h"
> #include "WebProcessPool.h"
>@@ -96,7 +95,6 @@ WebsiteDataStore::WebsiteDataStore(Ref<WebsiteDataStoreConfiguration>&& configur
>     : m_sessionID(sessionID)
>     , m_resolvedConfiguration(WTFMove(configuration))
>     , m_configuration(m_resolvedConfiguration->copy())
>-    , m_storageManager(StorageManager::create(m_configuration->localStorageDirectory()))
>     , m_deviceIdHashSaltStorage(DeviceIdHashSaltStorage::create(isPersistent() ? m_configuration->deviceIdHashSaltsStorageDirectory() : String()))
>     , m_queue(WorkQueue::create("com.apple.WebKit.WebsiteDataStore"))
>     , m_sourceApplicationBundleIdentifier(m_configuration->sourceApplicationBundleIdentifier())
>@@ -120,7 +118,6 @@ WebsiteDataStore::WebsiteDataStore(PAL::SessionID sessionID)
>     : m_sessionID(sessionID)
>     , m_resolvedConfiguration(WebsiteDataStoreConfiguration::create())
>     , m_configuration(m_resolvedConfiguration->copy())
>-    , m_storageManager(StorageManager::create({ }))
>     , m_deviceIdHashSaltStorage(DeviceIdHashSaltStorage::create(isPersistent() ? m_configuration->deviceIdHashSaltsStorageDirectory() : String()))
>     , m_queue(WorkQueue::create("com.apple.WebKit.WebsiteDataStore"))
> #if ENABLE(WEB_AUTHN)
>@@ -207,21 +204,6 @@ void WebsiteDataStore::resolveDirectoriesIfNecessary()
>     }
> }
> 
>-void WebsiteDataStore::cloneSessionData(WebPageProxy& sourcePage, WebPageProxy& newPage)
>-{
>-    auto& sourceDataStore = sourcePage.websiteDataStore();
>-    auto& newDataStore = newPage.websiteDataStore();
>-
>-    // FIXME: Handle this.
>-    if (&sourceDataStore != &newDataStore)
>-        return;
>-
>-    if (!sourceDataStore.m_storageManager)
>-        return;
>-
>-    sourceDataStore.m_storageManager->cloneSessionStorageNamespace(sourcePage.pageID(), newPage.pageID());
>-}
>-
> enum class ProcessAccessType {
>     None,
>     OnlyIfLaunched,
>@@ -247,7 +229,17 @@ static ProcessAccessType computeNetworkProcessAccessTypeForDataFetch(OptionSet<W
> 
>     if (dataTypes.contains(WebsiteDataType::DOMCache))
>         processAccessType = std::max(processAccessType, ProcessAccessType::Launch);
>-    
>+
>+    if (dataTypes.contains(WebsiteDataType::SessionStorage))
>+        processAccessType = std::max(processAccessType, ProcessAccessType::OnlyIfLaunched);
>+
>+    if (dataTypes.contains(WebsiteDataType::LocalStorage)) {
>+        if (isNonPersistentStore)
>+            processAccessType = std::max(processAccessType, ProcessAccessType::OnlyIfLaunched);
>+        else
>+            processAccessType = std::max(processAccessType, ProcessAccessType::Launch);
>+    }
>+
>     if (dataTypes.contains(WebsiteDataType::IndexedDBDatabases) && !isNonPersistentStore)
>         processAccessType = std::max(processAccessType, ProcessAccessType::Launch);
> 
>@@ -483,32 +475,6 @@ void WebsiteDataStore::fetchDataAndApply(OptionSet<WebsiteDataType> dataTypes, O
>         }
>     }
> 
>-    if (dataTypes.contains(WebsiteDataType::SessionStorage) && m_storageManager) {
>-        callbackAggregator->addPendingCallback();
>-
>-        m_storageManager->getSessionStorageOrigins([callbackAggregator](HashSet<WebCore::SecurityOriginData>&& origins) {
>-            WebsiteData websiteData;
>-
>-            while (!origins.isEmpty())
>-                websiteData.entries.append(WebsiteData::Entry { origins.takeAny(), WebsiteDataType::SessionStorage, 0 });
>-
>-            callbackAggregator->removePendingCallback(WTFMove(websiteData));
>-        });
>-    }
>-
>-    if (dataTypes.contains(WebsiteDataType::LocalStorage) && m_storageManager) {
>-        callbackAggregator->addPendingCallback();
>-
>-        m_storageManager->getLocalStorageOrigins([callbackAggregator](HashSet<WebCore::SecurityOriginData>&& origins) {
>-            WebsiteData websiteData;
>-
>-            while (!origins.isEmpty())
>-                websiteData.entries.append(WebsiteData::Entry { origins.takeAny(), WebsiteDataType::LocalStorage, 0 });
>-
>-            callbackAggregator->removePendingCallback(WTFMove(websiteData));
>-        });
>-    }
>-
>     if (dataTypes.contains(WebsiteDataType::DeviceIdHashSalt)) {
>         callbackAggregator->addPendingCallback();
> 
>@@ -821,22 +787,6 @@ void WebsiteDataStore::removeData(OptionSet<WebsiteDataType> dataTypes, WallTime
>         }
>     }
> 
>-    if (dataTypes.contains(WebsiteDataType::SessionStorage) && m_storageManager) {
>-        callbackAggregator->addPendingCallback();
>-
>-        m_storageManager->deleteSessionStorageOrigins([callbackAggregator] {
>-            callbackAggregator->removePendingCallback();
>-        });
>-    }
>-
>-    if (dataTypes.contains(WebsiteDataType::LocalStorage) && m_storageManager) {
>-        callbackAggregator->addPendingCallback();
>-
>-        m_storageManager->deleteLocalStorageOriginsModifiedSince(modifiedSince, [callbackAggregator] {
>-            callbackAggregator->removePendingCallback();
>-        });
>-    }
>-
>     if (dataTypes.contains(WebsiteDataType::DeviceIdHashSalt) || (dataTypes.contains(WebsiteDataType::Cookies))) {
>         callbackAggregator->addPendingCallback();
> 
>@@ -1101,22 +1051,6 @@ void WebsiteDataStore::removeData(OptionSet<WebsiteDataType> dataTypes, const Ve
>         }
>     }
> 
>-    if (dataTypes.contains(WebsiteDataType::SessionStorage) && m_storageManager) {
>-        callbackAggregator->addPendingCallback();
>-
>-        m_storageManager->deleteSessionStorageEntriesForOrigins(origins, [callbackAggregator] {
>-            callbackAggregator->removePendingCallback();
>-        });
>-    }
>-
>-    if (dataTypes.contains(WebsiteDataType::LocalStorage) && m_storageManager) {
>-        callbackAggregator->addPendingCallback();
>-
>-        m_storageManager->deleteLocalStorageEntriesForOrigins(origins, [callbackAggregator] {
>-            callbackAggregator->removePendingCallback();
>-        });
>-    }
>-
>     if (dataTypes.contains(WebsiteDataType::DeviceIdHashSalt) || (dataTypes.contains(WebsiteDataType::Cookies))) {
>         callbackAggregator->addPendingCallback();
> 
>@@ -1795,21 +1729,13 @@ void WebsiteDataStore::deleteCookiesForTesting(const URL& url, bool includeHttpO
> 
> void WebsiteDataStore::hasLocalStorageForTesting(const URL& url, CompletionHandler<void(bool)>&& completionHandler) const
> {
>-    if (!m_storageManager) {
>-        completionHandler(false);
>-        return;
>-    }
>-
>-    m_storageManager->getLocalStorageOrigins([url, completionHandler = WTFMove(completionHandler)](HashSet<WebCore::SecurityOriginData>&& origins) mutable {
>-        for (auto& origin : origins) {
>-            if (origin.host == url.host()) {
>-                completionHandler(true);
>-                return;
>-            }
>+    for (auto& processPool : processPools()) {
>+        if (auto* networkProcess = processPool->networkProcess()) {
>+            networkProcess->hasLocalStorage(m_sessionID, WebCore::RegistrableDomain { url }, WTFMove(completionHandler));
>+            ASSERT(processPools().size() == 1);
>+            break;
>         }
>-
>-        completionHandler(false);
>-    });
>+    }
> }
> #endif // ENABLE(RESOURCE_LOAD_STATISTICS)
> 
>@@ -1840,42 +1766,6 @@ void WebsiteDataStore::resetCacheMaxAgeCapForPrevalentResources(CompletionHandle
> #endif
> }
> 
>-void WebsiteDataStore::webPageWasAdded(WebPageProxy& webPageProxy)
>-{
>-    if (m_storageManager)
>-        m_storageManager->createSessionStorageNamespace(webPageProxy.pageID(), std::numeric_limits<unsigned>::max());
>-}
>-
>-void WebsiteDataStore::webPageWasInvalidated(WebPageProxy& webPageProxy)
>-{
>-    if (m_storageManager)
>-        m_storageManager->destroySessionStorageNamespace(webPageProxy.pageID());
>-}
>-
>-void WebsiteDataStore::webProcessWillOpenConnection(WebProcessProxy& webProcessProxy, IPC::Connection& connection)
>-{
>-    if (m_storageManager)
>-        m_storageManager->processWillOpenConnection(webProcessProxy, connection);
>-}
>-
>-void WebsiteDataStore::webPageWillOpenConnection(WebPageProxy& webPageProxy, IPC::Connection& connection)
>-{
>-    if (m_storageManager)
>-        m_storageManager->addAllowedSessionStorageNamespaceConnection(webPageProxy.pageID(), connection);
>-}
>-
>-void WebsiteDataStore::webPageDidCloseConnection(WebPageProxy& webPageProxy, IPC::Connection& connection)
>-{
>-    if (m_storageManager)
>-        m_storageManager->removeAllowedSessionStorageNamespaceConnection(webPageProxy.pageID(), connection);
>-}
>-
>-void WebsiteDataStore::webProcessDidCloseConnection(WebProcessProxy& webProcessProxy, IPC::Connection& connection)
>-{
>-    if (m_storageManager)
>-        m_storageManager->processDidCloseConnection(webProcessProxy, connection);
>-}
>-
> bool WebsiteDataStore::isAssociatedProcessPool(WebProcessPool& processPool) const
> {
>     if (auto* processPoolDataStore = processPool.websiteDataStore())
>@@ -2107,6 +1997,12 @@ WebsiteDataStoreParameters WebsiteDataStore::parameters()
> 
>     resolveDirectoriesIfNecessary();
> 
>+    auto localStorageDirectory = resolvedLocalStorageDirectory();
>+    if (!localStorageDirectory.isEmpty()) {
>+        parameters.networkSessionParameters.localStorageDirectory = localStorageDirectory;
>+        SandboxExtension::createHandleForReadWriteDirectory(localStorageDirectory, parameters.networkSessionParameters.localStorageDirectoryExtensionHandle);
>+    }
>+
> #if ENABLE(INDEXED_DATABASE)
>     parameters.indexedDatabaseDirectory = resolvedIndexedDatabaseDirectory();
>     if (!parameters.indexedDatabaseDirectory.isEmpty())
>@@ -2182,4 +2078,19 @@ bool WebsiteDataStore::setSourceApplicationBundleIdentifier(String&& identifier)
>     return true;
> }
> 
>+void WebsiteDataStore::getLocalStorageDetails(Function<void(Vector<LocalStorageDatabaseTracker::OriginDetails>)>&& completionHandler)
>+{
>+    if (!isPersistent()) {
>+        completionHandler({ });
>+        return;
>+    }
>+
>+    for (auto& processPool : processPools()) {
>+        processPool->ensureNetworkProcess(this);
>+        processPool->networkProcess()->getLocalStorageDetails(m_sessionID, [completionHandler = WTFMove(completionHandler)](auto details) {
>+            completionHandler(details);
>+        });
>+    }
>+}
>+
> }
>diff --git a/Source/WebKit/UIProcess/WebsiteData/WebsiteDataStore.h b/Source/WebKit/UIProcess/WebsiteData/WebsiteDataStore.h
>index 77f048a454f34e5e0916fa190ad11293069afc6f..df9531c0e75d58640af4d73f70330ede6c7f7009 100644
>--- a/Source/WebKit/UIProcess/WebsiteData/WebsiteDataStore.h
>+++ b/Source/WebKit/UIProcess/WebsiteData/WebsiteDataStore.h
>@@ -25,6 +25,7 @@
> 
> #pragma once
> 
>+#include "LocalStorageDatabaseTracker.h"
> #include "NetworkSessionCreationParameters.h"
> #include "WebDeviceOrientationAndMotionAccessController.h"
> #include "WebProcessLifetimeObserver.h"
>@@ -71,7 +72,6 @@ namespace WebKit {
> 
> class AuthenticatorManager;
> class SecKeyProxyStore;
>-class StorageManager;
> class DeviceIdHashSaltStorage;
> class WebPageProxy;
> class WebProcessPool;
>@@ -122,12 +122,12 @@ public:
>     void clearResourceLoadStatisticsInWebProcesses(CompletionHandler<void()>&&);
> #endif
> 
>-    static void cloneSessionData(WebPageProxy& sourcePage, WebPageProxy& newPage);
>-
>     void fetchData(OptionSet<WebsiteDataType>, OptionSet<WebsiteDataFetchOption>, Function<void(Vector<WebsiteDataRecord>)>&& completionHandler);
>     void removeData(OptionSet<WebsiteDataType>, WallTime modifiedSince, Function<void()>&& completionHandler);
>     void removeData(OptionSet<WebsiteDataType>, const Vector<WebsiteDataRecord>&, Function<void()>&& completionHandler);
> 
>+    void getLocalStorageDetails(Function<void(Vector<LocalStorageDatabaseTracker::OriginDetails>)>&&);
>+
> #if ENABLE(RESOURCE_LOAD_STATISTICS)
>     void fetchDataForRegistrableDomains(OptionSet<WebsiteDataType>, OptionSet<WebsiteDataFetchOption>, const Vector<WebCore::RegistrableDomain>&, CompletionHandler<void(Vector<WebsiteDataRecord>&&, HashSet<WebCore::RegistrableDomain>&&)>&&);
>     void clearPrevalentResource(const URL&, CompletionHandler<void()>&&);
>@@ -179,6 +179,7 @@ public:
>     void resetCacheMaxAgeCapForPrevalentResources(CompletionHandler<void()>&&);
>     void resolveDirectoriesIfNecessary();
>     const String& resolvedApplicationCacheDirectory() const { return m_resolvedConfiguration->applicationCacheDirectory(); }
>+    const String& resolvedLocalStorageDirectory() const { return m_resolvedConfiguration->localStorageDirectory(); }
>     const String& resolvedMediaCacheDirectory() const { return m_resolvedConfiguration->mediaCacheDirectory(); }
>     const String& resolvedMediaKeysDirectory() const { return m_resolvedConfiguration->mediaKeysStorageDirectory(); }
>     const String& resolvedDatabaseDirectory() const { return m_resolvedConfiguration->webSQLDatabaseDirectory(); }
>@@ -188,8 +189,6 @@ public:
>     const String& resolvedServiceWorkerRegistrationDirectory() const { return m_resolvedConfiguration->serviceWorkerRegistrationDirectory(); }
>     const String& resolvedResourceLoadStatisticsDirectory() const { return m_resolvedConfiguration->resourceLoadStatisticsDirectory(); }
> 
>-    StorageManager* storageManager() { return m_storageManager.get(); }
>-
>     DeviceIdHashSaltStorage& deviceIdHashSaltStorage() { return m_deviceIdHashSaltStorage.get(); }
> 
>     WebProcessPool* processPoolForCookieStorageOperations();
>@@ -265,14 +264,6 @@ private:
> 
>     void fetchDataAndApply(OptionSet<WebsiteDataType>, OptionSet<WebsiteDataFetchOption>, RefPtr<WorkQueue>&&, Function<void(Vector<WebsiteDataRecord>)>&& apply);
> 
>-    // WebProcessLifetimeObserver.
>-    void webPageWasAdded(WebPageProxy&) override;
>-    void webPageWasInvalidated(WebPageProxy&) override;
>-    void webProcessWillOpenConnection(WebProcessProxy&, IPC::Connection&) override;
>-    void webPageWillOpenConnection(WebPageProxy&, IPC::Connection&) override;
>-    void webPageDidCloseConnection(WebPageProxy&, IPC::Connection&) override;
>-    void webProcessDidCloseConnection(WebProcessProxy&, IPC::Connection&) override;
>-
>     void platformInitialize();
>     void platformDestroy();
>     static void platformRemoveRecentSearches(WallTime);
>@@ -299,7 +290,6 @@ private:
>     Ref<const WebsiteDataStoreConfiguration> m_configuration;
>     bool m_hasResolvedDirectories { false };
> 
>-    const RefPtr<StorageManager> m_storageManager;
>     const Ref<DeviceIdHashSaltStorage> m_deviceIdHashSaltStorage;
> 
> #if ENABLE(RESOURCE_LOAD_STATISTICS)
>diff --git a/Source/WebKit/WebKit.xcodeproj/project.pbxproj b/Source/WebKit/WebKit.xcodeproj/project.pbxproj
>index 26c05c7469e68f7fb24c47086cab523fb42536e0..a0c873b669a7b42d2e0b8c3af49fd2531fa1069a 100644
>--- a/Source/WebKit/WebKit.xcodeproj/project.pbxproj
>+++ b/Source/WebKit/WebKit.xcodeproj/project.pbxproj
>@@ -152,7 +152,6 @@
> 		1A179780137EE82C00F97D45 /* PluginCreationParameters.h in Headers */ = {isa = PBXBuildFile; fileRef = 1A17977E137EE82C00F97D45 /* PluginCreationParameters.h */; };
> 		1A1B0EB618A424950038481A /* WKNavigationResponse.h in Headers */ = {isa = PBXBuildFile; fileRef = 1A1B0EB418A424950038481A /* WKNavigationResponse.h */; settings = {ATTRIBUTES = (Public, ); }; };
> 		1A1B0EB818A424CD0038481A /* WKNavigationResponseInternal.h in Headers */ = {isa = PBXBuildFile; fileRef = 1A1B0EB718A424CD0038481A /* WKNavigationResponseInternal.h */; };
>-		1A1D8BA21731A36300141DA4 /* LocalStorageDatabase.h in Headers */ = {isa = PBXBuildFile; fileRef = 1A1D8BA01731A36300141DA4 /* LocalStorageDatabase.h */; };
> 		1A1DC340196346D700FF7059 /* LegacySessionStateCoding.h in Headers */ = {isa = PBXBuildFile; fileRef = 31607F3819627002009B87DA /* LegacySessionStateCoding.h */; };
> 		1A1E093418861D3800D2DC49 /* WebProgressTrackerClient.h in Headers */ = {isa = PBXBuildFile; fileRef = 1A1E093218861D3800D2DC49 /* WebProgressTrackerClient.h */; };
> 		1A1EC69E1872092100B951F0 /* ImportanceAssertion.h in Headers */ = {isa = PBXBuildFile; fileRef = 1A1EC69D1872092100B951F0 /* ImportanceAssertion.h */; };
>@@ -195,7 +194,6 @@
> 		1A445BA1184D5FC1004B3414 /* WKContextHistoryClient.h in Headers */ = {isa = PBXBuildFile; fileRef = 1A445BA0184D5FC1004B3414 /* WKContextHistoryClient.h */; settings = {ATTRIBUTES = (Private, ); }; };
> 		1A445BA3184D5FCF004B3414 /* WKContextDownloadClient.h in Headers */ = {isa = PBXBuildFile; fileRef = 1A445BA2184D5FCF004B3414 /* WKContextDownloadClient.h */; settings = {ATTRIBUTES = (Private, ); }; };
> 		1A445BA5184D5FDA004B3414 /* WKContextConnectionClient.h in Headers */ = {isa = PBXBuildFile; fileRef = 1A445BA4184D5FDA004B3414 /* WKContextConnectionClient.h */; settings = {ATTRIBUTES = (Private, ); }; };
>-		1A44B95C16B73F9F00B7BBD8 /* StorageManager.h in Headers */ = {isa = PBXBuildFile; fileRef = 1A44B95A16B73F9F00B7BBD8 /* StorageManager.h */; };
> 		1A4832CC1A9BC465008B4DFE /* WKWebsiteDataRecord.h in Headers */ = {isa = PBXBuildFile; fileRef = 1A4832CA1A9BC465008B4DFE /* WKWebsiteDataRecord.h */; settings = {ATTRIBUTES = (Public, ); }; };
> 		1A4832CE1A9BC484008B4DFE /* WKWebsiteDataRecordInternal.h in Headers */ = {isa = PBXBuildFile; fileRef = 1A4832CD1A9BC484008B4DFE /* WKWebsiteDataRecordInternal.h */; };
> 		1A4832D11A9BDC2F008B4DFE /* WebsiteDataRecord.h in Headers */ = {isa = PBXBuildFile; fileRef = 1A4832CF1A9BD821008B4DFE /* WebsiteDataRecord.h */; };
>@@ -245,7 +243,6 @@
> 		1A85E4721E303F3700914599 /* WebKit.apinotes in Headers */ = {isa = PBXBuildFile; fileRef = 1A85E4701E303F2400914599 /* WebKit.apinotes */; settings = {ATTRIBUTES = (Public, ); }; };
> 		1A8B66B01BC43C860082DF77 /* PageLoadStateObserver.h in Headers */ = {isa = PBXBuildFile; fileRef = 1A8B66AE1BC43C860082DF77 /* PageLoadStateObserver.h */; };
> 		1A8B66B41BC45B010082DF77 /* WKBundleMac.h in Headers */ = {isa = PBXBuildFile; fileRef = 1A8B66B21BC45B010082DF77 /* WKBundleMac.h */; settings = {ATTRIBUTES = (Private, ); }; };
>-		1A8C728D1738477C000A6554 /* LocalStorageDatabaseTracker.h in Headers */ = {isa = PBXBuildFile; fileRef = 1A8C728B1738477C000A6554 /* LocalStorageDatabaseTracker.h */; };
> 		1A8E7D3C18C15149005A702A /* VisitedLinkTableControllerMessageReceiver.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 1A8E7D3A18C15149005A702A /* VisitedLinkTableControllerMessageReceiver.cpp */; };
> 		1A8E7D3D18C15149005A702A /* VisitedLinkTableControllerMessages.h in Headers */ = {isa = PBXBuildFile; fileRef = 1A8E7D3B18C15149005A702A /* VisitedLinkTableControllerMessages.h */; };
> 		1A8EF4CB1252403700F7067F /* PluginControllerProxy.h in Headers */ = {isa = PBXBuildFile; fileRef = 1A8EF4C91252403700F7067F /* PluginControllerProxy.h */; };
>@@ -1257,6 +1254,9 @@
> 		93A88B331BC6E9CD00ABA5C2 /* WebHitTestResultData.h in Headers */ = {isa = PBXBuildFile; fileRef = 93A88B311BC6E9C000ABA5C2 /* WebHitTestResultData.h */; };
> 		93A88B3B1BC710D900ABA5C2 /* _WKHitTestResultInternal.h in Headers */ = {isa = PBXBuildFile; fileRef = 93A88B3A1BC710D900ABA5C2 /* _WKHitTestResultInternal.h */; };
> 		93A88B461BC8829300ABA5C2 /* APIHitTestResult.h in Headers */ = {isa = PBXBuildFile; fileRef = 93A88B431BC8828C00ABA5C2 /* APIHitTestResult.h */; };
>+		93B2614D227D149E00B97A76 /* StorageManager.h in Headers */ = {isa = PBXBuildFile; fileRef = 93B26149227D147200B97A76 /* StorageManager.h */; };
>+		93B2614E227D14B100B97A76 /* LocalStorageDatabase.h in Headers */ = {isa = PBXBuildFile; fileRef = 93B26145227D147000B97A76 /* LocalStorageDatabase.h */; };
>+		93B2614F227D14B100B97A76 /* LocalStorageDatabaseTracker.h in Headers */ = {isa = PBXBuildFile; fileRef = 93B26146227D147100B97A76 /* LocalStorageDatabaseTracker.h */; };
> 		93BDEB01171DD7AF00BFEE1B /* WKPageLoadTypesPrivate.h in Headers */ = {isa = PBXBuildFile; fileRef = 93BDEB00171DD7AF00BFEE1B /* WKPageLoadTypesPrivate.h */; settings = {ATTRIBUTES = (Private, ); }; };
> 		93E6A4EE1BC5DD3900F8A0E7 /* _WKHitTestResult.h in Headers */ = {isa = PBXBuildFile; fileRef = 93E6A4ED1BC5DD3900F8A0E7 /* _WKHitTestResult.h */; settings = {ATTRIBUTES = (Private, ); }; };
> 		93F549B41E3174B7000E7239 /* WKSnapshotConfiguration.h in Headers */ = {isa = PBXBuildFile; fileRef = 93F549B31E3174B7000E7239 /* WKSnapshotConfiguration.h */; settings = {ATTRIBUTES = (Public, ); }; };
>@@ -2016,8 +2016,6 @@
> 		1A1B0EB718A424CD0038481A /* WKNavigationResponseInternal.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = WKNavigationResponseInternal.h; sourceTree = "<group>"; };
> 		1A1D2116191D995C0001619F /* postprocess-framework-headers.sh */ = {isa = PBXFileReference; lastKnownFileType = text.script.sh; name = "postprocess-framework-headers.sh"; path = "mac/postprocess-framework-headers.sh"; sourceTree = "<group>"; };
> 		1A1D2117191D996C0001619F /* MigrateHeadersFromWebKitLegacy.make */ = {isa = PBXFileReference; lastKnownFileType = text; name = MigrateHeadersFromWebKitLegacy.make; path = mac/MigrateHeadersFromWebKitLegacy.make; sourceTree = "<group>"; };
>-		1A1D8B9F1731A36300141DA4 /* LocalStorageDatabase.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = LocalStorageDatabase.cpp; sourceTree = "<group>"; };
>-		1A1D8BA01731A36300141DA4 /* LocalStorageDatabase.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = LocalStorageDatabase.h; sourceTree = "<group>"; };
> 		1A1E093118861D3800D2DC49 /* WebProgressTrackerClient.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = WebProgressTrackerClient.cpp; sourceTree = "<group>"; };
> 		1A1E093218861D3800D2DC49 /* WebProgressTrackerClient.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = WebProgressTrackerClient.h; sourceTree = "<group>"; };
> 		1A1EC69D1872092100B951F0 /* ImportanceAssertion.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = ImportanceAssertion.h; sourceTree = "<group>"; };
>@@ -2094,8 +2092,6 @@
> 		1A445BA0184D5FC1004B3414 /* WKContextHistoryClient.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = WKContextHistoryClient.h; sourceTree = "<group>"; };
> 		1A445BA2184D5FCF004B3414 /* WKContextDownloadClient.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = WKContextDownloadClient.h; sourceTree = "<group>"; };
> 		1A445BA4184D5FDA004B3414 /* WKContextConnectionClient.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = WKContextConnectionClient.h; sourceTree = "<group>"; };
>-		1A44B95916B73F9F00B7BBD8 /* StorageManager.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = StorageManager.cpp; sourceTree = "<group>"; };
>-		1A44B95A16B73F9F00B7BBD8 /* StorageManager.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = StorageManager.h; sourceTree = "<group>"; };
> 		1A4832C11A965A3C008B4DFE /* WebsiteDataStoreCocoa.mm */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.objcpp; path = WebsiteDataStoreCocoa.mm; sourceTree = "<group>"; };
> 		1A4832C91A9BC465008B4DFE /* WKWebsiteDataRecord.mm */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.objcpp; path = WKWebsiteDataRecord.mm; sourceTree = "<group>"; };
> 		1A4832CA1A9BC465008B4DFE /* WKWebsiteDataRecord.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = WKWebsiteDataRecord.h; sourceTree = "<group>"; };
>@@ -2182,8 +2178,6 @@
> 		1A8B66AE1BC43C860082DF77 /* PageLoadStateObserver.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = PageLoadStateObserver.h; sourceTree = "<group>"; };
> 		1A8B66B11BC45B010082DF77 /* WKBundleMac.mm */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.objcpp; path = WKBundleMac.mm; sourceTree = "<group>"; };
> 		1A8B66B21BC45B010082DF77 /* WKBundleMac.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = WKBundleMac.h; sourceTree = "<group>"; };
>-		1A8C728A1738477C000A6554 /* LocalStorageDatabaseTracker.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = LocalStorageDatabaseTracker.cpp; sourceTree = "<group>"; };
>-		1A8C728B1738477C000A6554 /* LocalStorageDatabaseTracker.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = LocalStorageDatabaseTracker.h; sourceTree = "<group>"; };
> 		1A8E7D3818C150BF005A702A /* VisitedLinkTableController.messages.in */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text; path = VisitedLinkTableController.messages.in; sourceTree = "<group>"; };
> 		1A8E7D3A18C15149005A702A /* VisitedLinkTableControllerMessageReceiver.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = VisitedLinkTableControllerMessageReceiver.cpp; path = DerivedSources/WebKit2/VisitedLinkTableControllerMessageReceiver.cpp; sourceTree = BUILT_PRODUCTS_DIR; };
> 		1A8E7D3B18C15149005A702A /* VisitedLinkTableControllerMessages.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; name = VisitedLinkTableControllerMessages.h; path = DerivedSources/WebKit2/VisitedLinkTableControllerMessages.h; sourceTree = BUILT_PRODUCTS_DIR; };
>@@ -2279,7 +2273,6 @@
> 		1AB1F7931D1B3613007C9BD1 /* WebPaymentCoordinatorMessages.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; name = WebPaymentCoordinatorMessages.h; path = DerivedSources/WebKit2/WebPaymentCoordinatorMessages.h; sourceTree = BUILT_PRODUCTS_DIR; };
> 		1AB1F7941D1B3613007C9BD1 /* WebPaymentCoordinatorProxyMessageReceiver.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = WebPaymentCoordinatorProxyMessageReceiver.cpp; path = DerivedSources/WebKit2/WebPaymentCoordinatorProxyMessageReceiver.cpp; sourceTree = BUILT_PRODUCTS_DIR; };
> 		1AB1F7951D1B3613007C9BD1 /* WebPaymentCoordinatorProxyMessages.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; name = WebPaymentCoordinatorProxyMessages.h; path = DerivedSources/WebKit2/WebPaymentCoordinatorProxyMessages.h; sourceTree = BUILT_PRODUCTS_DIR; };
>-		1AB31A9316BC65AB00F6DBC9 /* StorageManager.messages.in */ = {isa = PBXFileReference; lastKnownFileType = text; path = StorageManager.messages.in; sourceTree = "<group>"; };
> 		1AB31A9416BC688100F6DBC9 /* StorageManagerMessageReceiver.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = StorageManagerMessageReceiver.cpp; path = DerivedSources/WebKit2/StorageManagerMessageReceiver.cpp; sourceTree = BUILT_PRODUCTS_DIR; };
> 		1AB31A9516BC688100F6DBC9 /* StorageManagerMessages.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; name = StorageManagerMessages.h; path = DerivedSources/WebKit2/StorageManagerMessages.h; sourceTree = BUILT_PRODUCTS_DIR; };
> 		1AB40EE31BF677E300BA81BE /* WKMenuItemIdentifiers.mm */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.objcpp; path = WKMenuItemIdentifiers.mm; sourceTree = "<group>"; };
>@@ -3206,7 +3199,6 @@
> 		511F7D401EB1BCEE00E47B83 /* WebsiteDataStoreParameters.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = WebsiteDataStoreParameters.h; sourceTree = "<group>"; };
> 		511F8A77138B460900A95F44 /* SecItemShimLibrary.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; name = SecItemShimLibrary.h; path = ../../WebProcess/mac/SecItemShimLibrary.h; sourceTree = "<group>"; };
> 		511F8A78138B460900A95F44 /* SecItemShimLibrary.mm */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.objcpp; name = SecItemShimLibrary.mm; path = ../../WebProcess/mac/SecItemShimLibrary.mm; sourceTree = "<group>"; };
>-		5120C8301E54E2650025B250 /* LocalStorageDatabaseTrackerIOS.mm */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.objcpp; path = LocalStorageDatabaseTrackerIOS.mm; sourceTree = "<group>"; };
> 		5120C8331E5B71570025B250 /* _WKWebsiteDataStoreConfiguration.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = _WKWebsiteDataStoreConfiguration.h; sourceTree = "<group>"; };
> 		5120C8341E5B71570025B250 /* _WKWebsiteDataStoreConfiguration.mm */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.objcpp; path = _WKWebsiteDataStoreConfiguration.mm; sourceTree = "<group>"; };
> 		512127C11908239A00DAF35C /* WebPasteboardOverrides.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = WebPasteboardOverrides.cpp; sourceTree = "<group>"; };
>@@ -3846,6 +3838,14 @@
> 		93A88B3A1BC710D900ABA5C2 /* _WKHitTestResultInternal.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = _WKHitTestResultInternal.h; sourceTree = "<group>"; };
> 		93A88B421BC8828C00ABA5C2 /* APIHitTestResult.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = APIHitTestResult.cpp; sourceTree = "<group>"; };
> 		93A88B431BC8828C00ABA5C2 /* APIHitTestResult.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = APIHitTestResult.h; sourceTree = "<group>"; };
>+		93B26145227D147000B97A76 /* LocalStorageDatabase.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = LocalStorageDatabase.h; sourceTree = "<group>"; };
>+		93B26146227D147100B97A76 /* LocalStorageDatabaseTracker.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = LocalStorageDatabaseTracker.h; sourceTree = "<group>"; };
>+		93B26147227D147100B97A76 /* LocalStorageDatabaseTracker.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = LocalStorageDatabaseTracker.cpp; sourceTree = "<group>"; };
>+		93B26148227D147100B97A76 /* ios */ = {isa = PBXFileReference; lastKnownFileType = folder; path = ios; sourceTree = "<group>"; };
>+		93B26149227D147200B97A76 /* StorageManager.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = StorageManager.h; sourceTree = "<group>"; };
>+		93B2614A227D147200B97A76 /* StorageManager.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = StorageManager.cpp; sourceTree = "<group>"; };
>+		93B2614B227D147200B97A76 /* StorageManager.messages.in */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text; path = StorageManager.messages.in; sourceTree = "<group>"; };
>+		93B2614C227D147200B97A76 /* LocalStorageDatabase.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = LocalStorageDatabase.cpp; sourceTree = "<group>"; };
> 		93BA04DA2151ADF3007F455F /* WebSWServerConnection.messages.in */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text; path = WebSWServerConnection.messages.in; sourceTree = "<group>"; };
> 		93BA04DB2151ADF3007F455F /* WebSWServerToContextConnection.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = WebSWServerToContextConnection.h; sourceTree = "<group>"; };
> 		93BA04DC2151ADF3007F455F /* WebSWServerToContextConnection.messages.in */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text; path = WebSWServerToContextConnection.messages.in; sourceTree = "<group>"; };
>@@ -4892,21 +4892,6 @@
> 			name = Deprecated;
> 			sourceTree = "<group>";
> 		};
>-		1A44B95816B73F8C00B7BBD8 /* WebStorage */ = {
>-			isa = PBXGroup;
>-			children = (
>-				5120C82D1E54E2040025B250 /* ios */,
>-				1A1D8B9F1731A36300141DA4 /* LocalStorageDatabase.cpp */,
>-				1A1D8BA01731A36300141DA4 /* LocalStorageDatabase.h */,
>-				1A8C728A1738477C000A6554 /* LocalStorageDatabaseTracker.cpp */,
>-				1A8C728B1738477C000A6554 /* LocalStorageDatabaseTracker.h */,
>-				1A44B95916B73F9F00B7BBD8 /* StorageManager.cpp */,
>-				1A44B95A16B73F9F00B7BBD8 /* StorageManager.h */,
>-				1AB31A9316BC65AB00F6DBC9 /* StorageManager.messages.in */,
>-			);
>-			path = WebStorage;
>-			sourceTree = "<group>";
>-		};
> 		1A4832C01A965A33008B4DFE /* Cocoa */ = {
> 			isa = PBXGroup;
> 			children = (
>@@ -6586,6 +6571,7 @@
> 				510CC7DC16138E2900D03ED3 /* mac */,
> 				93BA04D92151ADCD007F455F /* ServiceWorker */,
> 				413075971DE84ED70039EC69 /* webrtc */,
>+				93B26143227D143100B97A76 /* WebStorage */,
> 				6BD05864220CE8C2000BED5C /* AdClickAttributionManager.cpp */,
> 				6BD05863220CE8C2000BED5C /* AdClickAttributionManager.h */,
> 				53F3CAA5206C443E0086490E /* NetworkActivityTracker.cpp */,
>@@ -6696,14 +6682,6 @@
> 			path = IndexedDB;
> 			sourceTree = "<group>";
> 		};
>-		5120C82D1E54E2040025B250 /* ios */ = {
>-			isa = PBXGroup;
>-			children = (
>-				5120C8301E54E2650025B250 /* LocalStorageDatabaseTrackerIOS.mm */,
>-			);
>-			path = ios;
>-			sourceTree = "<group>";
>-		};
> 		5123CF18133D25E60056F800 /* cg */ = {
> 			isa = PBXGroup;
> 			children = (
>@@ -7178,6 +7156,21 @@
> 			path = mac;
> 			sourceTree = "<group>";
> 		};
>+		93B26143227D143100B97A76 /* WebStorage */ = {
>+			isa = PBXGroup;
>+			children = (
>+				93B26148227D147100B97A76 /* ios */,
>+				93B2614C227D147200B97A76 /* LocalStorageDatabase.cpp */,
>+				93B26145227D147000B97A76 /* LocalStorageDatabase.h */,
>+				93B26147227D147100B97A76 /* LocalStorageDatabaseTracker.cpp */,
>+				93B26146227D147100B97A76 /* LocalStorageDatabaseTracker.h */,
>+				93B2614A227D147200B97A76 /* StorageManager.cpp */,
>+				93B26149227D147200B97A76 /* StorageManager.h */,
>+				93B2614B227D147200B97A76 /* StorageManager.messages.in */,
>+			);
>+			path = WebStorage;
>+			sourceTree = "<group>";
>+		};
> 		93BA04D92151ADCD007F455F /* ServiceWorker */ = {
> 			isa = PBXGroup;
> 			children = (
>@@ -7512,7 +7505,6 @@
> 				1AAF089E192681AC00B6390C /* UserContent */,
> 				57608294202BD84900116678 /* WebAuthentication */,
> 				1A53C2A31A325691004E8C70 /* WebsiteData */,
>-				1A44B95816B73F8C00B7BBD8 /* WebStorage */,
> 				7CD102D91866770600ED429D /* AutoCorrectionCallback.h */,
> 				E1513C64166EABB200149FCB /* AuxiliaryProcessProxy.cpp */,
> 				E1513C65166EABB200149FCB /* AuxiliaryProcessProxy.h */,
>@@ -9310,8 +9302,8 @@
> 				57DCEDAC214C60270016B847 /* LocalAuthenticator.h in Headers */,
> 				57DCEDAD214C602C0016B847 /* LocalConnection.h in Headers */,
> 				57DCEDAE214C60330016B847 /* LocalService.h in Headers */,
>-				1A1D8BA21731A36300141DA4 /* LocalStorageDatabase.h in Headers */,
>-				1A8C728D1738477C000A6554 /* LocalStorageDatabaseTracker.h in Headers */,
>+				93B2614E227D14B100B97A76 /* LocalStorageDatabase.h in Headers */,
>+				93B2614F227D14B100B97A76 /* LocalStorageDatabaseTracker.h in Headers */,
> 				51A7F2F3125BF820008AEB1D /* Logging.h in Headers */,
> 				0FDCD7F71D47E92A009F08BC /* LogInitialization.h in Headers */,
> 				1A6D86C21DF75265007745E8 /* MachMessage.h in Headers */,
>@@ -9527,7 +9519,7 @@
> 				1AD3306F16B1D991004F60E7 /* StorageAreaImpl.h in Headers */,
> 				1ACECD2517162DB1001FC9EF /* StorageAreaMap.h in Headers */,
> 				1A334DEE16DE8F88006A8E38 /* StorageAreaMapMessages.h in Headers */,
>-				1A44B95C16B73F9F00B7BBD8 /* StorageManager.h in Headers */,
>+				93B2614D227D149E00B97A76 /* StorageManager.h in Headers */,
> 				1AB31A9716BC688100F6DBC9 /* StorageManagerMessages.h in Headers */,
> 				1AE00D6C18327C1200087DD7 /* StringReference.h in Headers */,
> 				296BD85D15019BC30071F424 /* StringUtilities.h in Headers */,
>diff --git a/Source/WebKit/WebProcess/InjectedBundle/InjectedBundle.cpp b/Source/WebKit/WebProcess/InjectedBundle/InjectedBundle.cpp
>index 4de6674bc61e4c9db0dcbf68744e1306efa5044f..c541f92b8fa86f11da074415cfb8fd51e660ac03 100644
>--- a/Source/WebKit/WebProcess/InjectedBundle/InjectedBundle.cpp
>+++ b/Source/WebKit/WebProcess/InjectedBundle/InjectedBundle.cpp
>@@ -348,8 +348,8 @@ void InjectedBundle::setJavaScriptCanAccessClipboard(WebPageGroupProxy* pageGrou
> void InjectedBundle::setPrivateBrowsingEnabled(WebPageGroupProxy* pageGroup, bool enabled)
> {
>     ASSERT(!hasProcessPrivilege(ProcessPrivilege::CanAccessRawCookies));
>-    if (enabled)
>-        WebProcess::singleton().ensureLegacyPrivateBrowsingSessionInNetworkProcess();
>+
>+    WebProcess::singleton().setPrivateBrowsingEnabled(enabled);
> 
>     const HashSet<Page*>& pages = PageGroup::pageGroup(pageGroup->identifier())->pages();
>     for (HashSet<Page*>::iterator iter = pages.begin(); iter != pages.end(); ++iter)
>diff --git a/Source/WebKit/WebProcess/Network/NetworkProcessConnection.cpp b/Source/WebKit/WebProcess/Network/NetworkProcessConnection.cpp
>index 5ea3cd27a426c3d4c1e4abdfe53bed4ac2e2eabd..57edd9275bd60596044874f40101e4e840fa1883 100644
>--- a/Source/WebKit/WebProcess/Network/NetworkProcessConnection.cpp
>+++ b/Source/WebKit/WebProcess/Network/NetworkProcessConnection.cpp
>@@ -30,6 +30,8 @@
> #include "LibWebRTCNetwork.h"
> #include "NetworkConnectionToWebProcessMessages.h"
> #include "ServiceWorkerClientFetchMessages.h"
>+#include "StorageAreaMap.h"
>+#include "StorageAreaMapMessages.h"
> #include "WebCacheStorageConnection.h"
> #include "WebCacheStorageConnectionMessages.h"
> #include "WebCacheStorageProvider.h"
>@@ -93,6 +95,11 @@ void NetworkProcessConnection::didReceiveMessage(IPC::Connection& connection, IP
>             webPage->didReceiveWebPageMessage(connection, decoder);
>         return;
>     }
>+    if (decoder.messageReceiverName() == Messages::StorageAreaMap::messageReceiverName()) {
>+        if (auto* stoargeAreaMap = WebProcess::singleton().storageAreaMap(decoder.destinationID()))
>+            stoargeAreaMap->didReceiveMessage(connection, decoder);
>+        return;
>+    }
> 
> #if USE(LIBWEBRTC)
>     if (decoder.messageReceiverName() == Messages::WebRTCSocket::messageReceiverName()) {
>diff --git a/Source/WebKit/WebProcess/WebCoreSupport/WebChromeClient.cpp b/Source/WebKit/WebProcess/WebCoreSupport/WebChromeClient.cpp
>index 66e53a2d4e07c8b4e0683ec28a2f89189908a7db..6def9c995dc3d9c6f95392d13feeb9a35fa98c80 100644
>--- a/Source/WebKit/WebProcess/WebCoreSupport/WebChromeClient.cpp
>+++ b/Source/WebKit/WebProcess/WebCoreSupport/WebChromeClient.cpp
>@@ -296,6 +296,8 @@ Page* WebChromeClient::createWindow(Frame& frame, const FrameLoadRequest& reques
>     if (!newPageID)
>         return nullptr;
>     ASSERT(parameters);
>+    if (parameters->sessionID == m_page.sessionID())
>+        parameters->oldPageID = m_page.pageID();
> 
>     webProcess.createWebPage(newPageID, WTFMove(*parameters));
>     return webProcess.webPage(newPageID)->corePage();
>diff --git a/Source/WebKit/WebProcess/WebPage/WebPage.cpp b/Source/WebKit/WebProcess/WebPage/WebPage.cpp
>index 0ed89d0f305fb4fdf3a5dce8823f2547126e7004..b316781fddd8b7101f1178d97c5faaf4dcd47971 100644
>--- a/Source/WebKit/WebProcess/WebPage/WebPage.cpp
>+++ b/Source/WebKit/WebProcess/WebPage/WebPage.cpp
>@@ -1403,6 +1403,7 @@ void WebPage::close()
>     m_mainFrame->coreFrame()->loader().detachFromParent();
>     m_drawingArea = nullptr;
> 
>+    PAL::SessionID session(sessionID());
>     DeferredPageDestructor::createDeferredPageDestructor(WTFMove(m_page), this);
> 
>     bool isRunningModal = m_isRunningModal;
>@@ -1430,7 +1431,7 @@ void WebPage::close()
> #endif
> 
>     // The WebPage can be destroyed by this call.
>-    WebProcess::singleton().removeWebPage(m_pageID);
>+    WebProcess::singleton().removeWebPage(session, m_pageID);
> 
>     WebProcess::singleton().updateActivePages();
> 
>diff --git a/Source/WebKit/WebProcess/WebProcess.cpp b/Source/WebKit/WebProcess/WebProcess.cpp
>index 97b8305880eebf442ead494cb5c3e5017a2f0e04..89a95b624eba781e9add3dab3964cbde9c0565e3 100644
>--- a/Source/WebKit/WebProcess/WebProcess.cpp
>+++ b/Source/WebKit/WebProcess/WebProcess.cpp
>@@ -42,6 +42,7 @@
> #include "NetworkSessionCreationParameters.h"
> #include "PluginProcessConnectionManager.h"
> #include "StatisticsData.h"
>+#include "StorageAreaMap.h"
> #include "UserData.h"
> #include "WebAutomationSessionProxy.h"
> #include "WebCacheStorageProvider.h"
>@@ -56,6 +57,7 @@
> #include "WebMemorySampler.h"
> #include "WebMessagePortChannelProvider.h"
> #include "WebPage.h"
>+#include "WebPageCreationParameters.h"
> #include "WebPageGroupProxy.h"
> #include "WebPaymentCoordinator.h"
> #include "WebPlatformStrategies.h"
>@@ -675,6 +677,7 @@ void WebProcess::createWebPage(uint64_t pageID, WebPageCreationParameters&& para
>     // It is necessary to check for page existence here since during a window.open() (or targeted
>     // link) the WebPage gets created both in the synchronous handler and through the normal way. 
>     HashMap<uint64_t, RefPtr<WebPage>>::AddResult result = m_pageMap.add(pageID, nullptr);
>+    auto oldPageID = parameters.oldPageID ? parameters.oldPageID.value() : pageID;
>     if (result.isNewEntry) {
>         ASSERT(!result.iterator->value);
>         result.iterator->value = WebPage::create(pageID, WTFMove(parameters));
>@@ -685,13 +688,16 @@ void WebProcess::createWebPage(uint64_t pageID, WebPageCreationParameters&& para
>     } else
>         result.iterator->value->reinitializeWebPage(WTFMove(parameters));
> 
>+    ensureNetworkProcessConnection().connection().send(Messages::NetworkConnectionToWebProcess::WebPageWasAdded(m_privateBrowsingEnabled ? PAL::SessionID::legacyPrivateSessionID() : result.iterator->value->sessionID(), pageID, oldPageID), 0);
>+
>     ASSERT(result.iterator->value);
> }
> 
>-void WebProcess::removeWebPage(uint64_t pageID)
>+void WebProcess::removeWebPage(PAL::SessionID sessionID, uint64_t pageID)
> {
>     ASSERT(m_pageMap.contains(pageID));
> 
>+    ensureNetworkProcessConnection().connection().send(Messages::NetworkConnectionToWebProcess::WebPageWasRemoved(m_privateBrowsingEnabled ? PAL::SessionID::legacyPrivateSessionID() : sessionID, pageID), 0);
>     pageWillLeaveWindow(pageID);
>     m_pageMap.remove(pageID);
> 
>@@ -1243,6 +1249,14 @@ NetworkProcessConnection& WebProcess::ensureNetworkProcessConnection()
> 
>         m_networkProcessConnection = NetworkProcessConnection::create(connectionIdentifier);
>         m_networkProcessConnection->connection().send(Messages::NetworkConnectionToWebProcess::SetWebProcessIdentifier(Process::identifier()), 0);
>+
>+        // To recover web storage.
>+        for (auto& page : m_pageMap) {
>+            if (!page.value)
>+                continue;
>+
>+            m_networkProcessConnection->connection().send(Messages::NetworkConnectionToWebProcess::WebPageWasAdded(m_privateBrowsingEnabled ? PAL::SessionID::legacyPrivateSessionID() : page.value->sessionID(), page.key, page.key), 0);
>+        }
>     }
>     
>     return *m_networkProcessConnection;
>@@ -1273,6 +1287,9 @@ void WebProcess::networkProcessConnectionClosed(NetworkProcessConnection* connec
>     ASSERT(m_networkProcessConnection);
>     ASSERT_UNUSED(connection, m_networkProcessConnection == connection);
> 
>+    for (auto* storageAreaMap : m_storageAreaMaps.values())
>+        storageAreaMap->disconnect();
>+
> #if ENABLE(INDEXED_DATABASE)
>     for (auto& page : m_pageMap.values()) {
>         auto idbConnection = page->corePage()->optionalIDBConnection();
>@@ -1640,6 +1657,39 @@ void WebProcess::nonVisibleProcessCleanupTimerFired()
> #endif
> }
> 
>+void WebProcess::registerStorageAreaMap(StorageAreaMap& storageAreaMap)
>+{
>+    ASSERT(!m_storageAreaMaps.contains(storageAreaMap.identifier()));
>+    m_storageAreaMaps.set(storageAreaMap.identifier(), &storageAreaMap);
>+}
>+
>+void WebProcess::unregisterStorageAreaMap(StorageAreaMap& storageAreaMap)
>+{
>+    ASSERT(m_storageAreaMaps.contains(storageAreaMap.identifier()));
>+    ASSERT(m_storageAreaMaps.get(storageAreaMap.identifier()) == &storageAreaMap);
>+    m_storageAreaMaps.remove(storageAreaMap.identifier());
>+}
>+
>+StorageAreaMap* WebProcess::storageAreaMap(uint64_t identifier) const
>+{
>+    ASSERT(m_storageAreaMaps.contains(identifier));
>+    return m_storageAreaMaps.get(identifier);
>+}
>+
>+void WebProcess::setPrivateBrowsingEnabled(bool enabled)
>+{
>+    if (m_privateBrowsingEnabled == enabled)
>+        return;
>+
>+    if (enabled)
>+        ensureLegacyPrivateBrowsingSessionInNetworkProcess();
>+
>+    if (!m_pageMap.isEmpty())
>+        ensureNetworkProcessConnection().connection().send(Messages::NetworkConnectionToWebProcess::WebProcessSessionChanged(enabled ? PAL::SessionID::legacyPrivateSessionID() : PAL::SessionID::defaultSessionID(), copyToVector(m_pageMap.keys())), 0);
>+    
>+    m_privateBrowsingEnabled = enabled;
>+}
>+
> void WebProcess::setResourceLoadStatisticsEnabled(bool enabled)
> {
>     WebCore::DeprecatedGlobalSettings::setResourceLoadStatisticsEnabled(enabled);
>diff --git a/Source/WebKit/WebProcess/WebProcess.h b/Source/WebKit/WebProcess/WebProcess.h
>index 4b6ddc693476833dfb3da1025b25afb0911d341f..a863fb1fd6f7c0fae4075c527707e0401ed79a07 100644
>--- a/Source/WebKit/WebProcess/WebProcess.h
>+++ b/Source/WebKit/WebProcess/WebProcess.h
>@@ -97,6 +97,7 @@ class InjectedBundle;
> class LibWebRTCNetwork;
> class NetworkProcessConnection;
> class ObjCObjectGraph;
>+class StorageAreaMap;
> class UserData;
> class WaylandCompositorDisplay;
> class WebAutomationSessionProxy;
>@@ -146,7 +147,7 @@ public:
> 
>     WebPage* webPage(uint64_t pageID) const;
>     void createWebPage(uint64_t pageID, WebPageCreationParameters&&);
>-    void removeWebPage(uint64_t pageID);
>+    void removeWebPage(PAL::SessionID, uint64_t pageID);
>     WebPage* focusedWebPage() const;
> 
>     InjectedBundle* injectedBundle() const { return m_injectedBundle.get(); }
>@@ -203,6 +204,12 @@ public:
> 
>     void nonVisibleProcessCleanupTimerFired();
> 
>+    void registerStorageAreaMap(StorageAreaMap&);
>+    void unregisterStorageAreaMap(StorageAreaMap&);
>+    StorageAreaMap* storageAreaMap(uint64_t identifier) const;
>+
>+    void setPrivateBrowsingEnabled(bool);
>+
> #if PLATFORM(COCOA)
>     RetainPtr<CFDataRef> sourceApplicationAuditData() const;
>     void destroyRenderingResources();
>@@ -555,6 +562,9 @@ private:
> #if PLATFORM(IOS)
>     float m_backlightLevel { 0 };
> #endif
>+
>+    HashMap<uint64_t, StorageAreaMap*> m_storageAreaMaps;
>+    bool m_privateBrowsingEnabled { false };
> };
> 
> } // namespace WebKit
>diff --git a/Source/WebKit/WebProcess/WebStorage/StorageAreaMap.cpp b/Source/WebKit/WebProcess/WebStorage/StorageAreaMap.cpp
>index c3176c7acb59cf81ead021d53032da6f3b542746..26d3e2669c15ca99c83e7da7986fad654606a3a1 100644
>--- a/Source/WebKit/WebProcess/WebStorage/StorageAreaMap.cpp
>+++ b/Source/WebKit/WebProcess/WebStorage/StorageAreaMap.cpp
>@@ -26,6 +26,7 @@
> #include "config.h"
> #include "StorageAreaMap.h"
> 
>+#include "NetworkProcessConnection.h"
> #include "StorageAreaImpl.h"
> #include "StorageAreaMapMessages.h"
> #include "StorageManagerMessages.h"
>@@ -69,36 +70,18 @@ StorageAreaMap::StorageAreaMap(StorageNamespaceImpl* storageNamespace, Ref<WebCo
>     , m_hasPendingClear(false)
>     , m_hasPendingGetValues(false)
> {
>-    switch (m_storageType) {
>-    case StorageType::Local:
>-    case StorageType::TransientLocal:
>-        if (SecurityOrigin* topLevelOrigin = storageNamespace->topLevelOrigin())
>-            WebProcess::singleton().parentProcessConnection()->send(Messages::StorageManager::CreateTransientLocalStorageMap(m_storageMapID, storageNamespace->storageNamespaceID(), topLevelOrigin->data(), m_securityOrigin->data()), 0);
>-        else
>-            WebProcess::singleton().parentProcessConnection()->send(Messages::StorageManager::CreateLocalStorageMap(m_storageMapID, storageNamespace->storageNamespaceID(), m_securityOrigin->data()), 0);
>-
>-        break;
>-
>-    case StorageType::Session:
>-        WebProcess::singleton().parentProcessConnection()->send(Messages::StorageManager::CreateSessionStorageMap(m_storageMapID, storageNamespace->storageNamespaceID(), m_securityOrigin->data()), 0);
>-        break;
>-
>-    case StorageType::EphemeralLocal:
>-        ASSERT_NOT_REACHED();
>-        return;
>-    }
>-
>-    WebProcess::singleton().addMessageReceiver(Messages::StorageAreaMap::messageReceiverName(), m_storageMapID, *this);
>+    WebProcess::singleton().registerStorageAreaMap(*this);
>+    connect();
> }
> 
> StorageAreaMap::~StorageAreaMap()
> {
>-    if (m_storageType != StorageType::EphemeralLocal) {
>-        WebProcess::singleton().parentProcessConnection()->send(Messages::StorageManager::DestroyStorageMap(m_storageMapID), 0);
>-        WebProcess::singleton().removeMessageReceiver(Messages::StorageAreaMap::messageReceiverName(), m_storageMapID);
>-    }
>+    if (m_storageType != StorageType::EphemeralLocal)
>+        WebProcess::singleton().ensureNetworkProcessConnection().connection().send(Messages::StorageManager::DestroyStorageMap(m_storageMapID), 0);
> 
>     m_storageNamespace->didDestroyStorageAreaMap(*this);
>+
>+    WebProcess::singleton().unregisterStorageAreaMap(*this);
> }
> 
> unsigned StorageAreaMap::length()
>@@ -139,7 +122,7 @@ void StorageAreaMap::setItem(Frame* sourceFrame, StorageAreaImpl* sourceArea, co
> 
>     m_pendingValueChanges.add(key);
> 
>-    WebProcess::singleton().parentProcessConnection()->send(Messages::StorageManager::SetItem(m_securityOrigin->data(), m_storageMapID, sourceArea->storageAreaID(), m_currentSeed, key, value, sourceFrame->document()->url()), 0);
>+    WebProcess::singleton().ensureNetworkProcessConnection().connection().send(Messages::StorageManager::SetItem(m_securityOrigin->data(), m_storageMapID, sourceArea->storageAreaID(), m_currentSeed, key, value, sourceFrame->document()->url()), 0);
> }
> 
> void StorageAreaMap::removeItem(WebCore::Frame* sourceFrame, StorageAreaImpl* sourceArea, const String& key)
>@@ -155,7 +138,7 @@ void StorageAreaMap::removeItem(WebCore::Frame* sourceFrame, StorageAreaImpl* so
> 
>     m_pendingValueChanges.add(key);
> 
>-    WebProcess::singleton().parentProcessConnection()->send(Messages::StorageManager::RemoveItem(m_securityOrigin->data(), m_storageMapID, sourceArea->storageAreaID(), m_currentSeed, key, sourceFrame->document()->url()), 0);
>+    WebProcess::singleton().ensureNetworkProcessConnection().connection().send(Messages::StorageManager::RemoveItem(m_securityOrigin->data(), m_storageMapID, sourceArea->storageAreaID(), m_currentSeed, key, sourceFrame->document()->url()), 0);
> }
> 
> void StorageAreaMap::clear(WebCore::Frame* sourceFrame, StorageAreaImpl* sourceArea)
>@@ -164,7 +147,7 @@ void StorageAreaMap::clear(WebCore::Frame* sourceFrame, StorageAreaImpl* sourceA
> 
>     m_hasPendingClear = true;
>     m_storageMap = StorageMap::create(m_quotaInBytes);
>-    WebProcess::singleton().parentProcessConnection()->send(Messages::StorageManager::Clear(m_securityOrigin->data(), m_storageMapID, sourceArea->storageAreaID(), m_currentSeed, sourceFrame->document()->url()), 0);
>+    WebProcess::singleton().ensureNetworkProcessConnection().connection().send(Messages::StorageManager::Clear(m_securityOrigin->data(), m_storageMapID, sourceArea->storageAreaID(), m_currentSeed, sourceFrame->document()->url()), 0);
> }
> 
> bool StorageAreaMap::contains(const String& key)
>@@ -189,11 +172,13 @@ void StorageAreaMap::loadValuesIfNeeded()
>     if (m_storageMap)
>         return;
> 
>+    connect();
>+
>     HashMap<String, String> values;
>     // FIXME: This should use a special sendSync flag to indicate that we don't want to process incoming messages while waiting for a reply.
>     // (This flag does not yet exist). Since loadValuesIfNeeded() ends up being called from within JavaScript code, processing incoming synchronous messages
>     // could lead to weird reentrency bugs otherwise.
>-    WebProcess::singleton().parentProcessConnection()->sendSync(Messages::StorageManager::GetValues(m_securityOrigin->data(), m_storageMapID, m_currentSeed), Messages::StorageManager::GetValues::Reply(values), 0);
>+    WebProcess::singleton().ensureNetworkProcessConnection().connection().sendSync(Messages::StorageManager::GetValues(m_securityOrigin->data(), m_storageMapID, m_currentSeed), Messages::StorageManager::GetValues::Reply(values), 0);
> 
>     m_storageMap = StorageMap::create(m_quotaInBytes);
>     m_storageMap->importItems(values);
>@@ -385,4 +370,36 @@ void StorageAreaMap::dispatchLocalStorageEvent(uint64_t sourceStorageAreaID, con
>     StorageEventDispatcher::dispatchLocalStorageEventsToFrames(pageGroup, frames, key, oldValue, newValue, urlString, m_securityOrigin->data());
> }
> 
>+void StorageAreaMap::connect()
>+{
>+    if (!m_isDisconnected)
>+        return;
>+    
>+    switch (m_storageType) {
>+    case StorageType::Local:
>+    case StorageType::TransientLocal:
>+        if (SecurityOrigin* topLevelOrigin = m_storageNamespace->topLevelOrigin())
>+            WebProcess::singleton().ensureNetworkProcessConnection().connection().send(Messages::StorageManager::CreateTransientLocalStorageMap(m_storageMapID, m_storageNamespace->storageNamespaceID(), topLevelOrigin->data(), m_securityOrigin->data()), 0);
>+        else
>+            WebProcess::singleton().ensureNetworkProcessConnection().connection().send(Messages::StorageManager::CreateLocalStorageMap(m_storageMapID, m_storageNamespace->storageNamespaceID(), m_securityOrigin->data()), 0);
>+        
>+        break;
>+        
>+    case StorageType::Session:
>+        WebProcess::singleton().ensureNetworkProcessConnection().connection().send(Messages::StorageManager::CreateSessionStorageMap(m_storageMapID, m_storageNamespace->storageNamespaceID(), m_securityOrigin->data()), 0);
>+        break;
>+        
>+    case StorageType::EphemeralLocal:
>+        ASSERT_NOT_REACHED();
>+        return;
>+    }
>+    m_isDisconnected = false;
>+}
>+
>+void StorageAreaMap::disconnect()
>+{
>+    m_isDisconnected = true;
>+    resetValues();
>+}
>+
> } // namespace WebKit
>diff --git a/Source/WebKit/WebProcess/WebStorage/StorageAreaMap.h b/Source/WebKit/WebProcess/WebStorage/StorageAreaMap.h
>index 637093fbf4764b50178eeac3fe09fcda57b75987..29ba7d8a8a37e5b3fc3659ebb6c92d4b33e91ae4 100644
>--- a/Source/WebKit/WebProcess/WebStorage/StorageAreaMap.h
>+++ b/Source/WebKit/WebProcess/WebStorage/StorageAreaMap.h
>@@ -58,14 +58,18 @@ public:
>     void clear(WebCore::Frame* sourceFrame, StorageAreaImpl* sourceArea);
>     bool contains(const String& key);
> 
>+    // IPC::MessageReceiver
>+    void didReceiveMessage(IPC::Connection&, IPC::Decoder&) override;
>+
>     const WebCore::SecurityOrigin& securityOrigin() const { return m_securityOrigin.get(); }
> 
>+    void connect();
>+    void disconnect();
>+    uint64_t identifier() const { return m_storageMapID; }
>+
> private:
>     StorageAreaMap(StorageNamespaceImpl*, Ref<WebCore::SecurityOrigin>&&);
> 
>-    // IPC::MessageReceiver
>-    void didReceiveMessage(IPC::Connection&, IPC::Decoder&) override;
>-
>     void didGetValues(uint64_t storageMapSeed);
>     void didSetItem(uint64_t storageMapSeed, const String& key, bool quotaError);
>     void didRemoveItem(uint64_t storageMapSeed, const String& key);
>@@ -98,6 +102,8 @@ private:
>     bool m_hasPendingClear;
>     bool m_hasPendingGetValues;
>     HashCountedSet<String> m_pendingValueChanges;
>+
>+    bool m_isDisconnected { true };
> };
> 
> } // namespace WebKit
>diff --git a/Tools/ChangeLog b/Tools/ChangeLog
>index 79e91b55629d13d62d32ec74496f54de6dd16826..6cb207549023bc0deaa575c887e1cf2d2ea93bb8 100644
>--- a/Tools/ChangeLog
>+++ b/Tools/ChangeLog
>@@ -1,3 +1,16 @@
>+2019-05-15  Sihui Liu  <sihui_liu@apple.com>
>+
>+        Move Web Storage to Network Process
>+        https://bugs.webkit.org/show_bug.cgi?id=197636
>+
>+        Reviewed by NOBODY (OOPS!).
>+
>+        * TestWebKitAPI/Tests/WebKitCocoa/LocalStorageDatabaseTracker.mm:
>+        (TEST):
>+        * TestWebKitAPI/Tests/WebKitCocoa/LocalStoragePersistence.mm: Add a test for network process crash recovery.
>+        (TEST):
>+        * TestWebKitAPI/Tests/WebKitCocoa/ProcessSwapOnNavigation.mm: Fix a typo and add a test case to cover it.
>+
> 2019-05-14  Youenn Fablet  <youenn@apple.com>
> 
>         A service worker process should app nap when all its clients app nap
>diff --git a/Tools/TestWebKitAPI/Tests/WebKitCocoa/LocalStorageDatabaseTracker.mm b/Tools/TestWebKitAPI/Tests/WebKitCocoa/LocalStorageDatabaseTracker.mm
>index cf912a3387ff049269eb94e4b5acdde83e5d0c5e..a216f8ccd0531162af5a56052a71a196e738cadc 100644
>--- a/Tools/TestWebKitAPI/Tests/WebKitCocoa/LocalStorageDatabaseTracker.mm
>+++ b/Tools/TestWebKitAPI/Tests/WebKitCocoa/LocalStorageDatabaseTracker.mm
>@@ -61,7 +61,8 @@ TEST(WKWebView, LocalStorageFetchDataRecords)
>     TestWebKitAPI::Util::run(&readyToContinue);
> 
>     // Local storage database update interval is 1 second.
>-    TestWebKitAPI::Util::sleep(1);
>+    // FetchData will get from local storage database files, so we need to wait a while to make sure write to database file finishes.
>+    TestWebKitAPI::Util::sleep(1.5);
> 
>     readyToContinue = false;
>     [[WKWebsiteDataStore defaultDataStore] fetchDataRecordsOfTypes:[WKWebsiteDataStore allWebsiteDataTypes] completionHandler:^(NSArray<WKWebsiteDataRecord *> *dataRecords) {
>diff --git a/Tools/TestWebKitAPI/Tests/WebKitCocoa/LocalStoragePersistence.mm b/Tools/TestWebKitAPI/Tests/WebKitCocoa/LocalStoragePersistence.mm
>index 0d94122dec5db91d91d236304a6c47e074175c0a..90e372991fc39e181203f4ca2a8fa0677a56808d 100644
>--- a/Tools/TestWebKitAPI/Tests/WebKitCocoa/LocalStoragePersistence.mm
>+++ b/Tools/TestWebKitAPI/Tests/WebKitCocoa/LocalStoragePersistence.mm
>@@ -53,6 +53,73 @@ - (void)userContentController:(WKUserContentController *)userContentController d
> 
> @end
> 
>+TEST(WKWebView, LocalStorageProcessCrashes)
>+{
>+    readyToContinue = false;
>+    [[WKWebsiteDataStore defaultDataStore] removeDataOfTypes:[WKWebsiteDataStore allWebsiteDataTypes] modifiedSince:[NSDate distantPast] completionHandler:^() {
>+        readyToContinue = true;
>+    }];
>+    TestWebKitAPI::Util::run(&readyToContinue);
>+
>+    RetainPtr<LocalStorageMessageHandler> handler = adoptNS([[LocalStorageMessageHandler alloc] init]);
>+    RetainPtr<WKWebViewConfiguration> configuration = adoptNS([[WKWebViewConfiguration alloc] init]);
>+    [[configuration userContentController] addScriptMessageHandler:handler.get() name:@"testHandler"];
>+    [configuration _setAllowUniversalAccessFromFileURLs:YES];
>+    RetainPtr<WKWebView> webView = adoptNS([[WKWebView alloc] initWithFrame:NSMakeRect(0, 0, 800, 600) configuration:configuration.get()]);
>+    NSURLRequest *request = [NSURLRequest requestWithURL:[[NSBundle mainBundle] URLForResource:@"LocalStorageClear" withExtension:@"html" subdirectory:@"TestWebKitAPI.resources"]];
>+    receivedScriptMessage = false;
>+    [webView loadRequest:request];
>+    TestWebKitAPI::Util::run(&receivedScriptMessage);
>+    
>+    readyToContinue = false;
>+    [webView evaluateJavaScript:@"window.localStorage.setItem('local','storage')" completionHandler:^(id, NSError *) {
>+        readyToContinue = true;
>+    }];
>+    TestWebKitAPI::Util::run(&readyToContinue);
>+    
>+    readyToContinue = false;
>+    [webView evaluateJavaScript:@"window.sessionStorage.setItem('session','storage')" completionHandler:^(id, NSError *) {
>+        readyToContinue = true;
>+    }];
>+    TestWebKitAPI::Util::run(&readyToContinue);
>+
>+    readyToContinue = false;
>+    [webView evaluateJavaScript:@"window.localStorage.getItem('local')" completionHandler:^(id result, NSError *) {
>+        EXPECT_TRUE([@"storage" isEqualToString:result]);
>+        readyToContinue = true;
>+    }];
>+    TestWebKitAPI::Util::run(&readyToContinue);
>+    
>+    readyToContinue = false;
>+    [webView evaluateJavaScript:@"window.sessionStorage.getItem('session')" completionHandler:^(id result, NSError *) {
>+        EXPECT_TRUE([@"storage" isEqualToString:result]);
>+        readyToContinue = true;
>+    }];
>+    TestWebKitAPI::Util::run(&readyToContinue);
>+    
>+    // Wait for changes to be written to database file.
>+    TestWebKitAPI::Util::sleep(1);
>+
>+    [configuration.get().processPool _terminateNetworkProcess];
>+    
>+    // Wait for network process connection to be closed so we can check the result after process is crashed.
>+    TestWebKitAPI::Util::sleep(1);
>+
>+    readyToContinue = false;
>+    [webView evaluateJavaScript:@"window.localStorage.getItem('local')" completionHandler:^(id result, NSError *) {
>+        EXPECT_TRUE([@"storage" isEqualToString:result]);
>+        readyToContinue = true;
>+    }];
>+    TestWebKitAPI::Util::run(&readyToContinue);
>+    
>+    readyToContinue = false;
>+    [webView evaluateJavaScript:@"window.sessionStorage.getItem('session')" completionHandler:^(id result, NSError *) {
>+        EXPECT_TRUE([result isEqual:[NSNull null]]);
>+        readyToContinue = true;
>+    }];
>+    TestWebKitAPI::Util::run(&readyToContinue);
>+    
>+}
> 
> TEST(WKWebView, LocalStorageEmptyString)
> {
>diff --git a/Tools/TestWebKitAPI/Tests/WebKitCocoa/ProcessSwapOnNavigation.mm b/Tools/TestWebKitAPI/Tests/WebKitCocoa/ProcessSwapOnNavigation.mm
>index 2e8e8e297eafba8fffb9e0344474ff736828c431..210724d7c85f9fd27d20008a490d705c363c3ca2 100644
>--- a/Tools/TestWebKitAPI/Tests/WebKitCocoa/ProcessSwapOnNavigation.mm
>+++ b/Tools/TestWebKitAPI/Tests/WebKitCocoa/ProcessSwapOnNavigation.mm
>@@ -4999,7 +4999,7 @@ TEST(ProcessSwap, EphemeralWebStorage)
>     TestWebKitAPI::Util::run(&done);
> 
>     done = false;
>-    [webView evaluateJavaScript:@"window.sessionStorage.setItem('b,'a')" completionHandler:^(id, NSError *) {
>+    [webView evaluateJavaScript:@"window.sessionStorage.setItem('b','a')" completionHandler:^(id, NSError *) {
>         done = true;
>     }];
>     TestWebKitAPI::Util::run(&done);
>@@ -5018,6 +5018,13 @@ TEST(ProcessSwap, EphemeralWebStorage)
>         done = true;
>     }];
>     TestWebKitAPI::Util::run(&done);
>+
>+    done = false;
>+    [webView evaluateJavaScript:@"window.sessionStorage.getItem('b')" completionHandler:^(id result, NSError *) {
>+        EXPECT_TRUE([@"a" isEqualToString:result]);
>+        done = true;
>+    }];
>+    TestWebKitAPI::Util::run(&done);
>     
>     done = false;
>     [webView loadHTMLString:@"<html><iframe src='pson://www.webkit.org/iframe.html'></iframe></html>" baseURL:[NSURL URLWithString:@"http://www.example.com/"]];

Actions: View | Formatted Diff | Diff

Attachments on bug 197636: 369206 | 369210 | 369215 | 369220 | 369223 | 369252 | 369404 | 369737 | 369739 | 369978 | 369982 | 369986 | 369990 | 370015 | 370047 | 370166 | 370172 | 370187 | 370280