Attachment 359708 Details for Bug 193556 – Patch for landing

[patch] Patch for landing

bug-193556-20190121135104.patch (text/plain), 323.85 KB, created by Brent Fulgham on 2019-01-21 13:51:05 PST

(hide)

Description:

Filename:

MIME Type:

Creator: Brent Fulgham

Created: 2019-01-21 13:51:05 PST

Size: 323.85 KB

patch

obsolete

>Subversion Revision: 240239
>diff --git a/Source/WebCore/ChangeLog b/Source/WebCore/ChangeLog
>index 5508ebd3cc2aaae0d04a39c900d202178fd2be45..5738adea1ca350b207d23b44f1491700153ccb54 100644
>--- a/Source/WebCore/ChangeLog
>+++ b/Source/WebCore/ChangeLog
>@@ -1,3 +1,24 @@
>+2019-01-17  Brent Fulgham  <bfulgham@apple.com>
>+
>+        Implement message handlers for NetworkProcess-based ResourceLoadStatistics
>+        https://bugs.webkit.org/show_bug.cgi?id=193556
>+        <rdar://problem/47368501>
>+
>+        Reviewed by Alex Christensen.
>+
>+        This patch adds a new observer callback used to message the NetworkProcess when
>+        user interaction events are received. This is needed when the ResourceLoadStatistics
>+        data is not being managed by the UIProcess.
>+
>+        Tested by existing ResourceLoadStatistics and storageAccess tests.
>+
>+        * loader/ResourceLoadObserver.cpp:
>+        (WebCore::ResourceLoadObserver::setLogUserInteractionNotificationCallback):
>+        (WebCore::ResourceLoadObserver::logUserInteractionWithReducedTimeResolution):
>+        * loader/ResourceLoadObserver.h:
>+        * platform/network/cocoa/NetworkStorageSessionCocoa.mm:
>+        (WebCore::NetworkStorageSession::setCookiesFromDOM):
>+
> 2019-01-21  David Kilzer  <ddkilzer@apple.com>
> 
>         REGRESSION (r240237): Revert changes to WebCore Xcode project
>diff --git a/Source/WebKit/ChangeLog b/Source/WebKit/ChangeLog
>index b74267bd4d44f9814be47fbb592655d35ecc5e8f..5f07d5d1634ffd73791cfc83f2c8c1d6296b212c 100644
>--- a/Source/WebKit/ChangeLog
>+++ b/Source/WebKit/ChangeLog
>@@ -1,3 +1,316 @@
>+2019-01-17  Brent Fulgham  <bfulgham@apple.com>
>+
>+        Implement message handlers for NetworkProcess-based ResourceLoadStatistics
>+        https://bugs.webkit.org/show_bug.cgi?id=193556
>+        <rdar://problem/47368501>
>+
>+        Reviewed by Alex Christensen.
>+
>+        This patch adds a number of sibling methods for tracking ResourceLoadStatistics when the
>+        observations are being handled in the NetworkProcess, rather than the UIProcess. The
>+        original versions of these methods will be removed as part of Bug 193303.
>+
>+        * NetworkProcess/Classifier/ResourceLoadStatisticsMemoryStore.cpp:
>+        (WebKit::ResourceLoadStatisticsMemoryStore::removeDataRecords):
>+        (WebKit::ResourceLoadStatisticsMemoryStore::processStatisticsAndDataRecords):
>+        (WebKit::ResourceLoadStatisticsMemoryStore::grandfatherExistingWebsiteData):
>+        * NetworkProcess/Classifier/ResourceLoadStatisticsMemoryStore.h:
>+        (WebKit::ResourceLoadStatisticsMemoryStore::store const):
>+        * NetworkProcess/Classifier/WebResourceLoadStatisticsStore.cpp:
>+        (WebKit::WebResourceLoadStatisticsStore::setNotifyPagesWhenDataRecordsWereScanned):
>+        (WebKit::WebResourceLoadStatisticsStore::setNotifyPagesWhenTelemetryWasCaptured):
>+        (WebKit::WebResourceLoadStatisticsStore::WebResourceLoadStatisticsStore):
>+        (WebKit::WebResourceLoadStatisticsStore::setPrevalentResourceForDebugMode):
>+        (WebKit::WebResourceLoadStatisticsStore::scheduleStatisticsAndDataRecordsProcessing):
>+        (WebKit::WebResourceLoadStatisticsStore::hasStorageAccess):
>+        (WebKit::WebResourceLoadStatisticsStore::callHasStorageAccessForFrameHandler):
>+        (WebKit::WebResourceLoadStatisticsStore::requestStorageAccess):
>+        (WebKit::WebResourceLoadStatisticsStore::logUserInteraction):
>+        (WebKit::WebResourceLoadStatisticsStore::clearUserInteraction):
>+        (WebKit::WebResourceLoadStatisticsStore::hasHadUserInteraction):
>+        (WebKit::WebResourceLoadStatisticsStore::setLastSeen):
>+        (WebKit::WebResourceLoadStatisticsStore::setPrevalentResource):
>+        (WebKit::WebResourceLoadStatisticsStore::setVeryPrevalentResource):
>+        (WebKit::WebResourceLoadStatisticsStore::isPrevalentResource):
>+        (WebKit::WebResourceLoadStatisticsStore::isVeryPrevalentResource):
>+        (WebKit::WebResourceLoadStatisticsStore::isRegisteredAsSubresourceUnder):
>+        (WebKit::WebResourceLoadStatisticsStore::isRegisteredAsSubFrameUnder):
>+        (WebKit::WebResourceLoadStatisticsStore::isRegisteredAsRedirectingTo):
>+        (WebKit::WebResourceLoadStatisticsStore::clearPrevalentResource):
>+        (WebKit::WebResourceLoadStatisticsStore::setGrandfathered):
>+        (WebKit::WebResourceLoadStatisticsStore::isGrandfathered):
>+        (WebKit::WebResourceLoadStatisticsStore::setSubframeUnderTopFrameOrigin):
>+        (WebKit::WebResourceLoadStatisticsStore::setSubresourceUnderTopFrameOrigin):
>+        (WebKit::WebResourceLoadStatisticsStore::setSubresourceUniqueRedirectTo):
>+        (WebKit::WebResourceLoadStatisticsStore::setSubresourceUniqueRedirectFrom):
>+        (WebKit::WebResourceLoadStatisticsStore::setTopFrameUniqueRedirectTo):
>+        (WebKit::WebResourceLoadStatisticsStore::setTopFrameUniqueRedirectFrom):
>+        (WebKit::WebResourceLoadStatisticsStore::setTimeToLiveUserInteraction):
>+        (WebKit::WebResourceLoadStatisticsStore::logTestingEvent):
>+        (WebKit::WebResourceLoadStatisticsStore::notifyResourceLoadStatisticsProcessed):
>+        (WebKit::WebResourceLoadStatisticsStore::deleteWebsiteDataForTopPrivatelyControlledDomainsInAllPersistentDataStores):
>+        (WebKit::WebResourceLoadStatisticsStore::topPrivatelyControlledDomainsWithWebsiteData):
>+        (WebKit::WebResourceLoadStatisticsStore::sendDiagnosticMessageWithValue const):
>+        (WebKit::WebResourceLoadStatisticsStore::notifyPageStatisticsTelemetryFinished const):
>+        * NetworkProcess/Classifier/WebResourceLoadStatisticsStore.h:
>+        * NetworkProcess/Classifier/WebResourceLoadStatisticsTelemetry.cpp:
>+        (WebKit::submitTopList):
>+        (WebKit::submitTopLists):
>+        (WebKit::notifyPages):
>+        (WebKit::WebResourceLoadStatisticsTelemetry::calculateAndSubmit):
>+        (WebKit::nonEphemeralWebPageProxy): Deleted.
>+        * NetworkProcess/NetworkConnectionToWebProcess.cpp:
>+        (WebKit::NetworkConnectionToWebProcess::logUserInteraction):
>+        * NetworkProcess/NetworkConnectionToWebProcess.h:
>+        * NetworkProcess/NetworkConnectionToWebProcess.messages.in:
>+        * NetworkProcess/NetworkProcess.cpp:
>+        (WebKit::NetworkProcess::dumpResourceLoadStatistics):
>+        (WebKit::NetworkProcess::isGrandfathered):
>+        (WebKit::NetworkProcess::isPrevalentResource):
>+        (WebKit::NetworkProcess::isVeryPrevalentResource):
>+        (WebKit::NetworkProcess::setGrandfathered):
>+        (WebKit::NetworkProcess::setPrevalentResource):
>+        (WebKit::NetworkProcess::setPrevalentResourceForDebugMode):
>+        (WebKit::NetworkProcess::setVeryPrevalentResource):
>+        (WebKit::NetworkProcess::clearPrevalentResource):
>+        (WebKit::NetworkProcess::submitTelemetry):
>+        (WebKit::NetworkProcess::scheduleCookieBlockingUpdate):
>+        (WebKit::NetworkProcess::scheduleClearInMemoryAndPersistent):
>+        (WebKit::NetworkProcess::resetParametersToDefaultValues):
>+        (WebKit::NetworkProcess::scheduleStatisticsAndDataRecordsProcessing):
>+        (WebKit::NetworkProcess::setNotifyPagesWhenDataRecordsWereScanned):
>+        (WebKit::NetworkProcess::setNotifyPagesWhenTelemetryWasCaptured):
>+        (WebKit::NetworkProcess::setSubframeUnderTopFrameOrigin):
>+        (WebKit::NetworkProcess::isRegisteredAsRedirectingTo):
>+        (WebKit::NetworkProcess::isRegisteredAsSubFrameUnder):
>+        (WebKit::NetworkProcess::setSubresourceUnderTopFrameOrigin):
>+        (WebKit::NetworkProcess::setSubresourceUniqueRedirectTo):
>+        (WebKit::NetworkProcess::setSubresourceUniqueRedirectFrom):
>+        (WebKit::NetworkProcess::isRegisteredAsSubresourceUnder):
>+        (WebKit::NetworkProcess::setTopFrameUniqueRedirectTo):
>+        (WebKit::NetworkProcess::setTopFrameUniqueRedirectFrom):
>+        (WebKit::NetworkProcess::setLastSeen):
>+        (WebKit::NetworkProcess::hasStorageAccess):
>+        (WebKit::NetworkProcess::requestStorageAccess):
>+        (WebKit::NetworkProcess::grantStorageAccess):
>+        (WebKit::NetworkProcess::logUserInteraction):
>+        (WebKit::NetworkProcess::hadUserInteraction):
>+        (WebKit::NetworkProcess::clearUserInteraction):
>+        (WebKit::NetworkProcess::setGrandfatheringTime):
>+        (WebKit::NetworkProcess::setMaxStatisticsEntries):
>+        (WebKit::NetworkProcess::setMinimumTimeBetweenDataRecordsRemoval):
>+        (WebKit::NetworkProcess::setPruneEntriesDownTo):
>+        (WebKit::NetworkProcess::setTimeToLiveUserInteraction):
>+        (WebKit::NetworkProcess::setShouldClassifyResourcesBeforeDataRecordsRemoval):
>+        (WebKit::NetworkProcess::setResourceLoadStatisticsEnabled):
>+        (WebKit::NetworkProcess::setResourceLoadStatisticsDebugMode):
>+        (WebKit::NetworkProcess::resetCacheMaxAgeCapForPrevalentResources):
>+        (WebKit::NetworkProcess::deleteWebsiteData):
>+        (WebKit::filterForTopLevelDomains):
>+        (WebKit::NetworkProcess::deleteWebsiteDataForTopPrivatelyControlledDomainsInAllPersistentDataStores):
>+        (WebKit::NetworkProcess::topPrivatelyControlledDomainsWithWebsiteData):
>+        * NetworkProcess/NetworkProcess.h:
>+        * NetworkProcess/NetworkProcess.messages.in:
>+        * NetworkProcess/NetworkSession.cpp:
>+        (WebKit::NetworkSession::setResourceLoadStatisticsEnabled):
>+        (WebKit::NetworkSession::notifyResourceLoadStatisticsProcessed):
>+        (WebKit::NetworkSession::logDiagnosticMessageWithValue):
>+        (WebKit::NetworkSession::notifyPageStatisticsTelemetryFinished):
>+        (WebKit::NetworkSession::deleteWebsiteDataForTopPrivatelyControlledDomainsInAllPersistentDataStores):
>+        (WebKit::NetworkSession::topPrivatelyControlledDomainsWithWebsiteData):
>+        (WebKit::NetworkSession::enableResourceLoadStatistics): Deleted.
>+        * NetworkProcess/NetworkSession.h:
>+        * NetworkProcess/cocoa/NetworkSessionCocoa.mm:
>+        (WebKit::NetworkSessionCocoa::NetworkSessionCocoa):
>+        * UIProcess/API/C/WKWebsiteDataStoreRef.cpp:
>+        (WKWebsiteDataStoreSetResourceLoadStatisticsDebugModeWithCompletionHandler):
>+        (WKWebsiteDataStoreSetResourceLoadStatisticsPrevalentResourceForDebugMode):
>+        (WKWebsiteDataStoreSetStatisticsLastSeen):
>+        (WKWebsiteDataStoreSetStatisticsPrevalentResource):
>+        (WKWebsiteDataStoreSetStatisticsVeryPrevalentResource):
>+        (WKWebsiteDataStoreDumpResourceLoadStatistics):
>+        (WKWebsiteDataStoreIsStatisticsPrevalentResource):
>+        (WKWebsiteDataStoreIsStatisticsVeryPrevalentResource):
>+        (WKWebsiteDataStoreIsStatisticsRegisteredAsSubresourceUnder):
>+        (WKWebsiteDataStoreIsStatisticsRegisteredAsSubFrameUnder):
>+        (WKWebsiteDataStoreIsStatisticsRegisteredAsRedirectingTo):
>+        (WKWebsiteDataStoreSetStatisticsHasHadUserInteraction):
>+        (WKWebsiteDataStoreIsStatisticsHasHadUserInteraction):
>+        (WKWebsiteDataStoreSetStatisticsGrandfathered):
>+        (WKWebsiteDataStoreIsStatisticsGrandfathered):
>+        (WKWebsiteDataStoreSetStatisticsSubframeUnderTopFrameOrigin):
>+        (WKWebsiteDataStoreSetStatisticsSubresourceUnderTopFrameOrigin):
>+        (WKWebsiteDataStoreSetStatisticsSubresourceUniqueRedirectTo):
>+        (WKWebsiteDataStoreSetStatisticsSubresourceUniqueRedirectFrom):
>+        (WKWebsiteDataStoreSetStatisticsTopFrameUniqueRedirectTo):
>+        (WKWebsiteDataStoreSetStatisticsTopFrameUniqueRedirectFrom):
>+        (WKWebsiteDataStoreSetStatisticsTimeToLiveUserInteraction):
>+        (WKWebsiteDataStoreStatisticsProcessStatisticsAndDataRecords):
>+        (WKWebsiteDataStoreStatisticsUpdateCookieBlocking):
>+        (WKWebsiteDataStoreStatisticsSubmitTelemetry):
>+        (WKWebsiteDataStoreSetStatisticsNotifyPagesWhenDataRecordsWereScanned):
>+        (WKWebsiteDataStoreSetStatisticsShouldClassifyResourcesBeforeDataRecordsRemoval):
>+        (WKWebsiteDataStoreSetStatisticsNotifyPagesWhenTelemetryWasCaptured):
>+        (WKWebsiteDataStoreSetStatisticsMinimumTimeBetweenDataRecordsRemoval):
>+        (WKWebsiteDataStoreSetStatisticsGrandfatheringTime):
>+        (WKWebsiteDataStoreSetStatisticsMaxStatisticsEntries):
>+        (WKWebsiteDataStoreSetStatisticsPruneEntriesDownTo):
>+        (WKWebsiteDataStoreStatisticsClearInMemoryAndPersistentStore):
>+        (WKWebsiteDataStoreStatisticsClearInMemoryAndPersistentStoreModifiedSinceHours):
>+        (WKWebsiteDataStoreStatisticsResetToConsistentState):
>+        * UIProcess/API/Cocoa/WKWebsiteDataStore.mm:
>+        (-[WKWebsiteDataStore _setResourceLoadStatisticsTestingCallback:]):
>+        * UIProcess/Network/NetworkProcessProxy.cpp:
>+        (WebKit::NetworkProcessProxy::clearCallbackStates):
>+        (WebKit::NetworkProcessProxy::didClose):
>+        (WebKit::nonEphemeralWebPageProxy):
>+        (WebKit::NetworkProcessProxy::logGlobalDiagnosticMessageWithValue):
>+        (WebKit::NetworkProcessProxy::dumpResourceLoadStatistics):
>+        (WebKit::NetworkProcessProxy::didDumpResourceLoadStatistics):
>+        (WebKit::NetworkProcessProxy::updatePrevalentDomainsToBlockCookiesFor):
>+        (WebKit::NetworkProcessProxy::didUpdateBlockCookies):
>+        (WebKit::NetworkProcessProxy::isPrevalentResource):
>+        (WebKit::NetworkProcessProxy::isPrevalentResourceResult):
>+        (WebKit::NetworkProcessProxy::isVeryPrevalentResource):
>+        (WebKit::NetworkProcessProxy::setPrevalentResource):
>+        (WebKit::NetworkProcessProxy::setPrevalentResourceForDebugMode):
>+        (WebKit::NetworkProcessProxy::setVeryPrevalentResource):
>+        (WebKit::NetworkProcessProxy::didSetResourceLoadStatisticData):
>+        (WebKit::NetworkProcessProxy::setLastSeen):
>+        (WebKit::NetworkProcessProxy::clearPrevalentResource):
>+        (WebKit::NetworkProcessProxy::scheduleCookieBlockingUpdate):
>+        (WebKit::NetworkProcessProxy::didScheduleCookieBlockingUpdate):
>+        (WebKit::NetworkProcessProxy::scheduleClearInMemoryAndPersistent):
>+        (WebKit::NetworkProcessProxy::didScheduleStatisticsProcessing):
>+        (WebKit::NetworkProcessProxy::scheduleStatisticsAndDataRecordsProcessing):
>+        (WebKit::NetworkProcessProxy::logUserInteraction):
>+        (WebKit::NetworkProcessProxy::hasHadUserInteraction):
>+        (WebKit::NetworkProcessProxy::didHaveUserInteraction):
>+        (WebKit::NetworkProcessProxy::clearUserInteraction):
>+        (WebKit::NetworkProcessProxy::setAgeCapForClientSideCookies):
>+        (WebKit::NetworkProcessProxy::didSetAgeCapForClientSideCookies):
>+        (WebKit::NetworkProcessProxy::setTimeToLiveUserInteraction):
>+        (WebKit::NetworkProcessProxy::didUpdateRuntimeSettings):
>+        (WebKit::NetworkProcessProxy::setNotifyPagesWhenTelemetryWasCaptured):
>+        (WebKit::NetworkProcessProxy::setNotifyPagesWhenDataRecordsWereScanned):
>+        (WebKit::NetworkProcessProxy::setSubframeUnderTopFrameOrigin):
>+        (WebKit::NetworkProcessProxy::isRegisteredAsRedirectingTo):
>+        (WebKit::NetworkProcessProxy::didIsRegisteredAsRedirectingTo):
>+        (WebKit::NetworkProcessProxy::isRegisteredAsSubFrameUnder):
>+        (WebKit::NetworkProcessProxy::didIsRegisteredAsSubFrameUnder):
>+        (WebKit::NetworkProcessProxy::setSubresourceUnderTopFrameOrigin):
>+        (WebKit::NetworkProcessProxy::isRegisteredAsSubresourceUnder):
>+        (WebKit::NetworkProcessProxy::didIsRegisteredAsSubresourceUnder):
>+        (WebKit::NetworkProcessProxy::setSubresourceUniqueRedirectTo):
>+        (WebKit::NetworkProcessProxy::setSubresourceUniqueRedirectFrom):
>+        (WebKit::NetworkProcessProxy::setTopFrameUniqueRedirectTo):
>+        (WebKit::NetworkProcessProxy::setTopFrameUniqueRedirectFrom):
>+        (WebKit::NetworkProcessProxy::isGrandfathered):
>+        (WebKit::NetworkProcessProxy::didIsGrandfathered):
>+        (WebKit::NetworkProcessProxy::setGrandfathered):
>+        (WebKit::NetworkProcessProxy::hasStorageAccess):
>+        (WebKit::NetworkProcessProxy::requestStorageAccess):
>+        (WebKit::NetworkProcessProxy::grantStorageAccess):
>+        (WebKit::NetworkProcessProxy::storageAccessRequestResult):
>+        (WebKit::NetworkProcessProxy::storageAccessOperationResult):
>+        (WebKit::NetworkProcessProxy::didRemoveAllStorageAccess):
>+        (WebKit::NetworkProcessProxy::didSetCacheMaxAgeCapForPrevalentResources):
>+        (WebKit::NetworkProcessProxy::setCacheMaxAgeCap):
>+        (WebKit::NetworkProcessProxy::setGrandfatheringTime):
>+        (WebKit::NetworkProcessProxy::setMaxStatisticsEntries):
>+        (WebKit::NetworkProcessProxy::setMinimumTimeBetweenDataRecordsRemoval):
>+        (WebKit::NetworkProcessProxy::setPruneEntriesDownTo):
>+        (WebKit::NetworkProcessProxy::setShouldClassifyResourcesBeforeDataRecordsRemoval):
>+        (WebKit::NetworkProcessProxy::setResourceLoadStatisticsDebugMode):
>+        (WebKit::NetworkProcessProxy::resetParametersToDefaultValues):
>+        (WebKit::NetworkProcessProxy::submitTelemetry):
>+        (WebKit::NetworkProcessProxy::notifyResourceLoadStatisticsProcessed):
>+        (WebKit::NetworkProcessProxy::notifyWebsiteDataDeletionForTopPrivatelyOwnedDomainsFinished):
>+        (WebKit::NetworkProcessProxy::notifyWebsiteDataScanForTopPrivatelyControlledDomainsFinished):
>+        (WebKit::NetworkProcessProxy::notifyResourceLoadStatisticsTelemetryFinished):
>+        (WebKit::NetworkProcessProxy::didLogUserInteraction): Deleted.
>+        (WebKit::NetworkProcessProxy::didResetCacheMaxAgeCapForPrevalentResources): Deleted.
>+        * UIProcess/Network/NetworkProcessProxy.h:
>+        * UIProcess/Network/NetworkProcessProxy.messages.in:
>+        * UIProcess/WebPageProxy.cpp:
>+        (WebKit::WebPageProxy::nonEphemeralWebPageProxy):
>+        * UIProcess/WebPageProxy.h:
>+        * UIProcess/WebProcessPool.cpp:
>+        (WebKit::WebProcessPool::ensureNetworkProcess):
>+        * UIProcess/WebProcessProxy.cpp:
>+        (WebKit::WebProcessProxy::notifyWebsiteDataScanForTopPrivatelyControlledDomainsFinished):
>+        (WebKit::WebProcessProxy::notifyWebsiteDataDeletionForTopPrivatelyOwnedDomainsFinished):
>+        * UIProcess/WebProcessProxy.h:
>+        * UIProcess/WebsiteData/Cocoa/WebsiteDataStoreCocoa.mm:
>+        (WebKit::WebsiteDataStore::parameters):
>+        * UIProcess/WebsiteData/WebsiteDataStore.cpp:
>+        (WebKit::WebsiteDataStore::removeData):
>+        (WebKit::WebsiteDataStore::setMaxStatisticsEntries):
>+        (WebKit::WebsiteDataStore::setPruneEntriesDownTo):
>+        (WebKit::WebsiteDataStore::setGrandfatheringTime):
>+        (WebKit::WebsiteDataStore::setCacheMaxAgeCap):
>+        (WebKit::WebsiteDataStore::setMinimumTimeBetweenDataRecordsRemoval):
>+        (WebKit::WebsiteDataStore::dumpResourceLoadStatistics):
>+        (WebKit::WebsiteDataStore::isPrevalentResource):
>+        (WebKit::WebsiteDataStore::setPrevalentResource):
>+        (WebKit::WebsiteDataStore::setPrevalentResourceForDebugMode):
>+        (WebKit::WebsiteDataStore::isVeryPrevalentResource):
>+        (WebKit::WebsiteDataStore::setVeryPrevalentResource):
>+        (WebKit::WebsiteDataStore::setShouldClassifyResourcesBeforeDataRecordsRemoval):
>+        (WebKit::WebsiteDataStore::setSubframeUnderTopFrameOrigin):
>+        (WebKit::WebsiteDataStore::isRegisteredAsSubFrameUnder):
>+        (WebKit::WebsiteDataStore::setSubresourceUnderTopFrameOrigin):
>+        (WebKit::WebsiteDataStore::isRegisteredAsSubresourceUnder):
>+        (WebKit::WebsiteDataStore::setSubresourceUniqueRedirectTo):
>+        (WebKit::WebsiteDataStore::setSubresourceUniqueRedirectFrom):
>+        (WebKit::WebsiteDataStore::setTopFrameUniqueRedirectTo):
>+        (WebKit::WebsiteDataStore::setTopFrameUniqueRedirectFrom):
>+        (WebKit::WebsiteDataStore::isRegisteredAsRedirectingTo):
>+        (WebKit::WebsiteDataStore::clearPrevalentResource):
>+        (WebKit::WebsiteDataStore::resetParametersToDefaultValues):
>+        (WebKit::WebsiteDataStore::submitTelemetry):
>+        (WebKit::WebsiteDataStore::scheduleClearInMemoryAndPersistent):
>+        (WebKit::WebsiteDataStore::scheduleCookieBlockingUpdate):
>+        (WebKit::WebsiteDataStore::scheduleStatisticsAndDataRecordsProcessing):
>+        (WebKit::WebsiteDataStore::updatePrevalentDomainsToBlockCookiesFor):
>+        (WebKit::WebsiteDataStore::setAgeCapForClientSideCookies):
>+        (WebKit::WebsiteDataStore::setLastSeen):
>+        (WebKit::WebsiteDataStore::setNotifyPagesWhenDataRecordsWereScanned):
>+        (WebKit::WebsiteDataStore::setNotifyPagesWhenTelemetryWasCaptured):
>+        (WebKit::WebsiteDataStore::hasStorageAccessForFrameHandler):
>+        (WebKit::WebsiteDataStore::getAllStorageAccessEntries):
>+        (WebKit::WebsiteDataStore::grantStorageAccessHandler):
>+        (WebKit::WebsiteDataStore::removeAllStorageAccessHandler):
>+        (WebKit::WebsiteDataStore::removePrevalentDomains):
>+        (WebKit::WebsiteDataStore::hasStorageAccess):
>+        (WebKit::WebsiteDataStore::requestStorageAccess):
>+        (WebKit::WebsiteDataStore::grantStorageAccess):
>+        (WebKit::WebsiteDataStore::setTimeToLiveUserInteraction):
>+        (WebKit::WebsiteDataStore::logUserInteraction):
>+        (WebKit::WebsiteDataStore::hasHadUserInteraction):
>+        (WebKit::WebsiteDataStore::clearUserInteraction):
>+        (WebKit::WebsiteDataStore::isGrandfathered):
>+        (WebKit::WebsiteDataStore::setGrandfathered):
>+        (WebKit::WebsiteDataStore::setCacheMaxAgeCapForPrevalentResources):
>+        (WebKit::WebsiteDataStore::resetCacheMaxAgeCapForPrevalentResources):
>+        (WebKit::WebsiteDataStore::webPageWasAdded):
>+        (WebKit::WebsiteDataStore::webPageWasInvalidated):
>+        (WebKit::WebsiteDataStore::webProcessWillOpenConnection):
>+        (WebKit::WebsiteDataStore::webPageWillOpenConnection):
>+        (WebKit::WebsiteDataStore::webPageDidCloseConnection):
>+        (WebKit::WebsiteDataStore::webProcessDidCloseConnection):
>+        (WebKit::WebsiteDataStore::isAssociatedProcessPool const):
>+        (WebKit::WebsiteDataStore::processPools const):
>+        (WebKit::WebsiteDataStore::resourceLoadStatisticsEnabled const):
>+        (WebKit::WebsiteDataStore::setResourceLoadStatisticsEnabled):
>+        (WebKit::WebsiteDataStore::setResourceLoadStatisticsDebugMode):
>+        (WebKit::WebsiteDataStore::enableResourceLoadStatisticsAndSetTestingCallback):
>+        (WebKit::WebsiteDataStore::logTestingEvent):
>+        * UIProcess/WebsiteData/WebsiteDataStore.h:
>+        (WebKit::WebsiteDataStore::setStatisticsTestingCallback):
>+        * WebProcess/WebProcess.cpp:
>+        (WebKit::WebProcess::initializeWebProcess):
>+
> 2019-01-15  Darin Adler  <darin@apple.com>
> 
>         Use references rather than pointers for register/unregister functions, and more
>diff --git a/Source/WebCore/loader/ResourceLoadObserver.cpp b/Source/WebCore/loader/ResourceLoadObserver.cpp
>index 82fb35ee0cef7d2c13fbd40fa2ba6b0cac23d267..c3ad1b0d667917b89f4e62a4bf437b9913ab399a 100644
>--- a/Source/WebCore/loader/ResourceLoadObserver.cpp
>+++ b/Source/WebCore/loader/ResourceLoadObserver.cpp
>@@ -69,6 +69,12 @@ void ResourceLoadObserver::setRequestStorageAccessUnderOpenerCallback(WTF::Funct
>     m_requestStorageAccessUnderOpenerCallback = WTFMove(callback);
> }
> 
>+void ResourceLoadObserver::setLogUserInteractionNotificationCallback(Function<void(PAL::SessionID, const String&)>&& callback)
>+{
>+    ASSERT(!m_logUserInteractionNotificationCallback);
>+    m_logUserInteractionNotificationCallback = WTFMove(callback);
>+}
>+
> ResourceLoadObserver::ResourceLoadObserver()
>     : m_notificationTimer(*this, &ResourceLoadObserver::notifyObserver)
> {
>@@ -190,6 +196,9 @@ void ResourceLoadObserver::logUserInteractionWithReducedTimeResolution(const Doc
>             }
>         }
>     }
>+
>+    // FIXME(193297): Uncomment this line when ResourceLoadStatistics are no longer gathered in the UI Process.
>+    // m_logUserInteractionNotificationCallback(document.sessionID(), domain);
> #endif
> 
>     m_notificationTimer.stop();
>diff --git a/Source/WebCore/loader/ResourceLoadObserver.h b/Source/WebCore/loader/ResourceLoadObserver.h
>index 2abfc50334c17d89e2b6ffbdc38a382a1f106e9d..a44f28c4f9fd7973b5b0fe204879b2a17931926b 100644
>--- a/Source/WebCore/loader/ResourceLoadObserver.h
>+++ b/Source/WebCore/loader/ResourceLoadObserver.h
>@@ -39,6 +39,10 @@ class WorkQueue;
> class WallTime;
> }
> 
>+namespace PAL {
>+class SessionID;
>+}
>+
> namespace WebCore {
> 
> class Document;
>@@ -69,6 +73,7 @@ public:
> 
>     WEBCORE_EXPORT void setNotificationCallback(WTF::Function<void (Vector<ResourceLoadStatistics>&&)>&&);
>     WEBCORE_EXPORT void setRequestStorageAccessUnderOpenerCallback(WTF::Function<void(const String&, uint64_t, const String&)>&&);
>+    WEBCORE_EXPORT void setLogUserInteractionNotificationCallback(WTF::Function<void(PAL::SessionID, const String&)>&&);
> 
>     WEBCORE_EXPORT void notifyObserver();
>     WEBCORE_EXPORT void clearState();
>@@ -95,6 +100,7 @@ private:
>     HashMap<String, WTF::WallTime> m_lastReportedUserInteractionMap;
>     WTF::Function<void (Vector<ResourceLoadStatistics>&&)> m_notificationCallback;
>     WTF::Function<void(const String&, uint64_t, const String&)> m_requestStorageAccessUnderOpenerCallback;
>+    WTF::Function<void(PAL::SessionID, const String&)> m_logUserInteractionNotificationCallback;
>     Timer m_notificationTimer;
> #if ENABLE(RESOURCE_LOAD_STATISTICS) && !RELEASE_LOG_DISABLED
>     uint64_t m_loggingCounter { 0 };
>diff --git a/Source/WebCore/platform/network/cocoa/NetworkStorageSessionCocoa.mm b/Source/WebCore/platform/network/cocoa/NetworkStorageSessionCocoa.mm
>index 4db7bae18f369232a787e516779509c8b440efc7..e05940e462c5d773b0aad3edab00425595473a7a 100644
>--- a/Source/WebCore/platform/network/cocoa/NetworkStorageSessionCocoa.mm
>+++ b/Source/WebCore/platform/network/cocoa/NetworkStorageSessionCocoa.mm
>@@ -405,7 +405,7 @@ void NetworkStorageSession::setCookiesFromDOM(const URL& firstParty, const SameS
> #if ENABLE(RESOURCE_LOAD_STATISTICS)
>     RetainPtr<NSArray> filteredCookies = filterCookies(unfilteredCookies, m_ageCapForClientSideCookies);
> #else
>-    RetainPtr<NSArray> filteredCookies = filterCookies(unfilteredCookies, false);
>+    RetainPtr<NSArray> filteredCookies = filterCookies(unfilteredCookies, WTF::nullopt);
> #endif
>     ASSERT([filteredCookies.get() count] <= 1);
> 
>diff --git a/Source/WebKit/NetworkProcess/Classifier/ResourceLoadStatisticsMemoryStore.cpp b/Source/WebKit/NetworkProcess/Classifier/ResourceLoadStatisticsMemoryStore.cpp
>index 5db459629d196258b9bc07c5946469149b444564..7685b6e33c62f1b8e94d3865719bf15cbba7f0d6 100644
>--- a/Source/WebKit/NetworkProcess/Classifier/ResourceLoadStatisticsMemoryStore.cpp
>+++ b/Source/WebKit/NetworkProcess/Classifier/ResourceLoadStatisticsMemoryStore.cpp
>@@ -26,6 +26,8 @@
> #include "config.h"
> #include "ResourceLoadStatisticsMemoryStore.h"
> 
>+#if ENABLE(RESOURCE_LOAD_STATISTICS)
>+
> #include "Logging.h"
> #include "NetworkSession.h"
> #include "PluginProcessManager.h"
>@@ -244,7 +246,12 @@ void ResourceLoadStatisticsMemoryStore::removeDataRecords(CompletionHandler<void
>     setDataRecordsBeingRemoved(true);
> 
>     RunLoop::main().dispatch([prevalentResourceDomains = crossThreadCopy(prevalentResourceDomains), callback = WTFMove(callback), weakThis = makeWeakPtr(*this), shouldNotifyPagesWhenDataRecordsWereScanned = m_parameters.shouldNotifyPagesWhenDataRecordsWereScanned, workQueue = m_workQueue.copyRef()] () mutable {
>-        WebProcessProxy::deleteWebsiteDataForTopPrivatelyControlledDomainsInAllPersistentDataStores(WebResourceLoadStatisticsStore::monitoredDataTypes(), WTFMove(prevalentResourceDomains), shouldNotifyPagesWhenDataRecordsWereScanned, [callback = WTFMove(callback), weakThis = WTFMove(weakThis), workQueue = workQueue.copyRef()](const HashSet<String>& domainsWithDeletedWebsiteData) mutable {
>+        if (!weakThis) {
>+            callback();
>+            return;
>+        }
>+
>+        weakThis->m_store.deleteWebsiteDataForTopPrivatelyControlledDomainsInAllPersistentDataStores(WebResourceLoadStatisticsStore::monitoredDataTypes(), WTFMove(prevalentResourceDomains), shouldNotifyPagesWhenDataRecordsWereScanned, [callback = WTFMove(callback), weakThis = WTFMove(weakThis), workQueue = workQueue.copyRef()](const HashSet<String>& domainsWithDeletedWebsiteData) mutable {
>             workQueue->dispatch([topDomains = crossThreadCopy(domainsWithDeletedWebsiteData), callback = WTFMove(callback), weakThis = WTFMove(weakThis)] () mutable {
>                 if (!weakThis) {
>                     callback();
>@@ -358,13 +365,17 @@ void ResourceLoadStatisticsMemoryStore::processStatisticsAndDataRecords()
>         if (!m_parameters.shouldNotifyPagesWhenDataRecordsWereScanned)
>             return;
> 
>-        RunLoop::main().dispatch([] {
>-            WebProcessProxy::notifyPageStatisticsAndDataRecordsProcessed();
>+        RunLoop::main().dispatch([this, weakThis = makeWeakPtr(*this)] {
>+            ASSERT(RunLoop::isMain());
>+            if (!weakThis)
>+                return;
>+
>+            m_store.notifyResourceLoadStatisticsProcessed();
>         });
>     });
> }
> 
>-void ResourceLoadStatisticsMemoryStore::hasStorageAccess(const String& subFramePrimaryDomain, const String& topFramePrimaryDomain, uint64_t frameID, uint64_t pageID, CompletionHandler<void(bool)>&& completionHandler)
>+void ResourceLoadStatisticsMemoryStore::hasStorageAccess(const String& subFramePrimaryDomain, const String& topFramePrimaryDomain, Optional<uint64_t> frameID, uint64_t pageID, CompletionHandler<void(bool)>&& completionHandler)
> {
>     ASSERT(!RunLoop::isMain());
> 
>@@ -380,7 +391,7 @@ void ResourceLoadStatisticsMemoryStore::hasStorageAccess(const String& subFrameP
>     }
> 
>     RunLoop::main().dispatch([store = makeRef(m_store), subFramePrimaryDomain = subFramePrimaryDomain.isolatedCopy(), topFramePrimaryDomain = topFramePrimaryDomain.isolatedCopy(), frameID, pageID, completionHandler = WTFMove(completionHandler)]() mutable {
>-        store->callHasStorageAccessForFrameHandler(subFramePrimaryDomain, topFramePrimaryDomain, frameID, pageID, [store = store.copyRef(), completionHandler = WTFMove(completionHandler)](bool result) mutable {
>+        store->callHasStorageAccessForFrameHandler(subFramePrimaryDomain, topFramePrimaryDomain, frameID.value(), pageID, [store = store.copyRef(), completionHandler = WTFMove(completionHandler)](bool result) mutable {
>             store->statisticsQueue().dispatch([completionHandler = WTFMove(completionHandler), result] () mutable {
>                 completionHandler(result);
>             });
>@@ -494,11 +505,9 @@ void ResourceLoadStatisticsMemoryStore::grandfatherExistingWebsiteData(Completio
> {
>     ASSERT(!RunLoop::isMain());
> 
>-    RunLoop::main().dispatch([weakThis = makeWeakPtr(*this), callback = WTFMove(callback), shouldNotifyPagesWhenDataRecordsWereScanned = m_parameters.shouldNotifyPagesWhenDataRecordsWereScanned, workQueue = m_workQueue.copyRef()] () mutable {
>-        // FIXME: This method being a static call on WebProcessProxy is wrong.
>-        // It should be on the data store that this object belongs to.
>-        WebProcessProxy::topPrivatelyControlledDomainsWithWebsiteData(WebResourceLoadStatisticsStore::monitoredDataTypes(), shouldNotifyPagesWhenDataRecordsWereScanned, [weakThis = WTFMove(weakThis), callback = WTFMove(callback), workQueue = workQueue.copyRef()] (HashSet<String>&& topPrivatelyControlledDomainsWithWebsiteData) mutable {
>-            workQueue->dispatch([weakThis = WTFMove(weakThis), topDomains = crossThreadCopy(topPrivatelyControlledDomainsWithWebsiteData), callback = WTFMove(callback)] () mutable {
>+    RunLoop::main().dispatch([weakThis = makeWeakPtr(*this), callback = WTFMove(callback), shouldNotifyPagesWhenDataRecordsWereScanned = m_parameters.shouldNotifyPagesWhenDataRecordsWereScanned, workQueue = m_workQueue.copyRef(), store = makeRef(m_store)] () mutable {
>+        store->topPrivatelyControlledDomainsWithWebsiteData(WebResourceLoadStatisticsStore::monitoredDataTypes(), shouldNotifyPagesWhenDataRecordsWereScanned, [weakThis = WTFMove(weakThis), callback = WTFMove(callback), workQueue = workQueue.copyRef()] (HashSet<String>&& topDomainsWithWebsiteData) mutable {
>+            workQueue->dispatch([weakThis = WTFMove(weakThis), topDomains = crossThreadCopy(topDomainsWithWebsiteData), callback = WTFMove(callback)] () mutable {
>                 if (!weakThis) {
>                     callback();
>                     return;
>@@ -1298,3 +1307,5 @@ void ResourceLoadStatisticsMemoryStore::didCreateNetworkProcess()
> }
> 
> } // namespace WebKit
>+
>+#endif
>diff --git a/Source/WebKit/NetworkProcess/Classifier/ResourceLoadStatisticsMemoryStore.h b/Source/WebKit/NetworkProcess/Classifier/ResourceLoadStatisticsMemoryStore.h
>index f3a9a7b96a00d85d0c1ea7b1caa61c72bd1db0c4..2cf7a153561482d8b49b2a37f08d93eacc2084fa 100644
>--- a/Source/WebKit/NetworkProcess/Classifier/ResourceLoadStatisticsMemoryStore.h
>+++ b/Source/WebKit/NetworkProcess/Classifier/ResourceLoadStatisticsMemoryStore.h
>@@ -25,6 +25,8 @@
> 
> #pragma once
> 
>+#if ENABLE(RESOURCE_LOAD_STATISTICS)
>+
> #include "ResourceLoadStatisticsClassifier.h"
> #include "WebResourceLoadStatisticsStore.h"
> #include <wtf/CompletionHandler.h>
>@@ -116,7 +118,7 @@ public:
>     bool isDebugModeEnabled() const { return m_debugModeEnabled; };
>     void setPrevalentResourceForDebugMode(const String& domain);
> 
>-    void hasStorageAccess(const String& subFramePrimaryDomain, const String& topFramePrimaryDomain, uint64_t frameID, uint64_t pageID, CompletionHandler<void(bool)>&&);
>+    void hasStorageAccess(const String& subFramePrimaryDomain, const String& topFramePrimaryDomain, Optional<uint64_t> frameID, uint64_t pageID, CompletionHandler<void(bool)>&&);
>     void requestStorageAccess(String&& subFramePrimaryDomain, String&& topFramePrimaryDomain, uint64_t frameID, uint64_t pageID, bool promptEnabled, CompletionHandler<void(StorageAccessStatus)>&&);
>     void grantStorageAccess(String&& subFrameHost, String&& topFrameHost, uint64_t frameID, uint64_t pageID, bool userWasPromptedNow, CompletionHandler<void(bool)>&&);
> 
>@@ -130,6 +132,8 @@ public:
> 
>     void didCreateNetworkProcess();
> 
>+    const WebResourceLoadStatisticsStore& store() const { return m_store; }
>+
> private:
>     static bool shouldBlockAndKeepCookies(const WebCore::ResourceLoadStatistics&);
>     static bool shouldBlockAndPurgeCookies(const WebCore::ResourceLoadStatistics&);
>@@ -201,3 +205,5 @@ private:
> };
> 
> } // namespace WebKit
>+
>+#endif
>diff --git a/Source/WebKit/NetworkProcess/Classifier/ResourceLoadStatisticsPersistentStorage.cpp b/Source/WebKit/NetworkProcess/Classifier/ResourceLoadStatisticsPersistentStorage.cpp
>index 3dd781b8dc70819fbfe172060939a54714c8c219..c210ecac8a4746e4140d40642e0c370a0e5a7ed0 100644
>--- a/Source/WebKit/NetworkProcess/Classifier/ResourceLoadStatisticsPersistentStorage.cpp
>+++ b/Source/WebKit/NetworkProcess/Classifier/ResourceLoadStatisticsPersistentStorage.cpp
>@@ -26,6 +26,8 @@
> #include "config.h"
> #include "ResourceLoadStatisticsPersistentStorage.h"
> 
>+#if ENABLE(RESOURCE_LOAD_STATISTICS)
>+
> #include "Logging.h"
> #include "PersistencyUtils.h"
> #include "ResourceLoadStatisticsMemoryStore.h"
>@@ -270,3 +272,5 @@ void ResourceLoadStatisticsPersistentStorage::excludeFromBackup() const
> #endif
> 
> } // namespace WebKit
>+
>+#endif
>diff --git a/Source/WebKit/NetworkProcess/Classifier/ResourceLoadStatisticsPersistentStorage.h b/Source/WebKit/NetworkProcess/Classifier/ResourceLoadStatisticsPersistentStorage.h
>index 12aa9b8aec2fd5001f1d2cc6aa33dbb2728ee6be..4c033e353d4f308f7f760012ca96296303c10730 100644
>--- a/Source/WebKit/NetworkProcess/Classifier/ResourceLoadStatisticsPersistentStorage.h
>+++ b/Source/WebKit/NetworkProcess/Classifier/ResourceLoadStatisticsPersistentStorage.h
>@@ -25,6 +25,8 @@
> 
> #pragma once
> 
>+#if ENABLE(RESOURCE_LOAD_STATISTICS)
>+
> #include <wtf/Forward.h>
> #include <wtf/MonotonicTime.h>
> #include <wtf/RunLoop.h>
>@@ -75,3 +77,5 @@ private:
> };
> 
> }
>+
>+#endif
>diff --git a/Source/WebKit/NetworkProcess/Classifier/WebResourceLoadStatisticsStore.cpp b/Source/WebKit/NetworkProcess/Classifier/WebResourceLoadStatisticsStore.cpp
>index f2d297392ad3d75ef285480bffcecb6492dacfee..8e7735abf779ffdde8ea7502eba3d5e0c01690a8 100644
>--- a/Source/WebKit/NetworkProcess/Classifier/WebResourceLoadStatisticsStore.cpp
>+++ b/Source/WebKit/NetworkProcess/Classifier/WebResourceLoadStatisticsStore.cpp
>@@ -26,6 +26,9 @@
> #include "config.h"
> #include "WebResourceLoadStatisticsStore.h"
> 
>+#if ENABLE(RESOURCE_LOAD_STATISTICS)
>+
>+#include "APIDictionary.h"
> #include "Logging.h"
> #include "NetworkSession.h"
> #include "ResourceLoadStatisticsMemoryStore.h"
>@@ -33,11 +36,14 @@
> #include "WebFrameProxy.h"
> #include "WebPageProxy.h"
> #include "WebProcessMessages.h"
>+#include "WebProcessPool.h"
> #include "WebProcessProxy.h"
> #include "WebResourceLoadStatisticsStoreMessages.h"
> #include "WebResourceLoadStatisticsTelemetry.h"
> #include "WebsiteDataFetchOption.h"
> #include "WebsiteDataStore.h"
>+#include <WebCore/DiagnosticLoggingClient.h>
>+#include <WebCore/DiagnosticLoggingKeys.h>
> #include <WebCore/NetworkStorageSession.h>
> #include <WebCore/ResourceLoadStatistics.h>
> #include <wtf/CallbackAggregator.h>
>@@ -88,13 +94,27 @@ void WebResourceLoadStatisticsStore::setNotifyPagesWhenDataRecordsWereScanned(bo
>     });
> }
> 
>-void WebResourceLoadStatisticsStore::setShouldClassifyResourcesBeforeDataRecordsRemoval(bool value)
>+void WebResourceLoadStatisticsStore::setNotifyPagesWhenDataRecordsWereScanned(bool value, CompletionHandler<void()>&& completionHandler)
>+{
>+    ASSERT(RunLoop::isMain());
>+    
>+    postTask([this, value, completionHandler = WTFMove(completionHandler)]() mutable {
>+        if (m_memoryStore)
>+            m_memoryStore->setNotifyPagesWhenDataRecordsWereScanned(value);
>+        
>+        postTaskReply(WTFMove(completionHandler));
>+    });
>+}
>+
>+void WebResourceLoadStatisticsStore::setShouldClassifyResourcesBeforeDataRecordsRemoval(bool value, CompletionHandler<void()>&& completionHandler)
> {
>     ASSERT(RunLoop::isMain());
> 
>-    postTask([this, value] {
>+    postTask([this, value, completionHandler = WTFMove(completionHandler)]() mutable {
>         if (m_memoryStore)
>             m_memoryStore->setShouldClassifyResourcesBeforeDataRecordsRemoval(value);
>+
>+        postTaskReply(WTFMove(completionHandler));
>     });
> }
> 
>@@ -108,6 +128,14 @@ void WebResourceLoadStatisticsStore::setShouldSubmitTelemetry(bool value)
>     });
> }
> 
>+void WebResourceLoadStatisticsStore::setNotifyPagesWhenTelemetryWasCaptured(bool value, CompletionHandler<void()>&& completionHandler)
>+{
>+    ASSERT(RunLoop::isMain());
>+
>+    WebKit::WebResourceLoadStatisticsTelemetry::setNotifyPagesWhenTelemetryWasCaptured(value);
>+    completionHandler();
>+}
>+
> WebResourceLoadStatisticsStore::WebResourceLoadStatisticsStore(WebsiteDataStore& websiteDataStore)
>     : m_websiteDataStore(makeWeakPtr(websiteDataStore))
>     , m_statisticsQueue(WorkQueue::create("WebResourceLoadStatisticsStore Process Data Queue", WorkQueue::Type::Serial, WorkQueue::QOS::Utility))
>@@ -133,6 +161,9 @@ WebResourceLoadStatisticsStore::WebResourceLoadStatisticsStore(NetworkSession& n
>     postTask([this, resourceLoadStatisticsDirectory = resourceLoadStatisticsDirectory.isolatedCopy()] {
>         m_memoryStore = std::make_unique<ResourceLoadStatisticsMemoryStore>(*this, m_statisticsQueue);
>         m_persistentStorage = std::make_unique<ResourceLoadStatisticsPersistentStorage>(*m_memoryStore, m_statisticsQueue, resourceLoadStatisticsDirectory);
>+
>+        // FIXME(193297): This should be revised after the UIProcess version goes away.
>+        m_memoryStore->didCreateNetworkProcess();
>     });
>     
>     m_dailyTasksTimer.startRepeating(24_h);
>@@ -194,20 +225,28 @@ void WebResourceLoadStatisticsStore::setPrevalentResourceForDebugMode(const URL&
> {
>     ASSERT(RunLoop::isMain());
> 
>-    postTask([this, primaryDomain = isolatedPrimaryDomain(url), completionHandler = WTFMove(completionHandler)]() mutable {
>+    setPrevalentResourceForDebugMode(WebCore::ResourceLoadStatistics::primaryDomain(url), WTFMove(completionHandler));
>+}
>+
>+void WebResourceLoadStatisticsStore::setPrevalentResourceForDebugMode(const String& primaryDomain, CompletionHandler<void()>&& completionHandler)
>+{
>+    ASSERT(RunLoop::isMain());
>+    
>+    postTask([this, primaryDomain = primaryDomain.isolatedCopy(), completionHandler = WTFMove(completionHandler)]() mutable {
>         if (m_memoryStore)
>             m_memoryStore->setPrevalentResourceForDebugMode(primaryDomain);
>         postTaskReply(WTFMove(completionHandler));
>     });
> }
> 
>-void WebResourceLoadStatisticsStore::scheduleStatisticsAndDataRecordsProcessing()
>+void WebResourceLoadStatisticsStore::scheduleStatisticsAndDataRecordsProcessing(CompletionHandler<void()>&& completionHandler)
> {
>     ASSERT(RunLoop::isMain());
>-
>-    postTask([this] {
>+    
>+    postTask([this, completionHandler = WTFMove(completionHandler)]() mutable {
>         if (m_memoryStore)
>             m_memoryStore->processStatisticsAndDataRecords();
>+        postTaskReply(WTFMove(completionHandler));
>     });
> }
> 
>@@ -233,46 +272,45 @@ void WebResourceLoadStatisticsStore::resourceLoadStatisticsUpdated(Vector<WebCor
>     });
> }
> 
>-void WebResourceLoadStatisticsStore::hasStorageAccess(String&& subFrameHost, String&& topFrameHost, uint64_t frameID, uint64_t pageID, CompletionHandler<void (bool)>&& completionHandler)
>+void WebResourceLoadStatisticsStore::hasStorageAccess(const String& subFrameHost, const String& topFrameHost, Optional<uint64_t> frameID, uint64_t pageID, CompletionHandler<void(bool)>&& completionHandler)
> {
>     ASSERT(subFrameHost != topFrameHost);
>     ASSERT(RunLoop::isMain());
> 
>-    postTask([this, subFramePrimaryDomain = isolatedPrimaryDomain(subFrameHost), topFramePrimaryDomain = isolatedPrimaryDomain(topFrameHost), frameID, pageID, completionHandler = WTFMove(completionHandler)] () mutable {
>+    postTask([this, subFramePrimaryDomain = subFrameHost.isolatedCopy(), topFramePrimaryDomain = topFrameHost.isolatedCopy(), frameID, pageID, completionHandler = WTFMove(completionHandler)]() mutable {
>         if (!m_memoryStore) {
>-            postTaskReply([completionHandler = WTFMove(completionHandler)] () mutable {
>+            postTaskReply([completionHandler = WTFMove(completionHandler)]() mutable {
>                 completionHandler(false);
>             });
>             return;
>         }
>         m_memoryStore->hasStorageAccess(subFramePrimaryDomain, topFramePrimaryDomain, frameID, pageID, [completionHandler = WTFMove(completionHandler)](bool hasStorageAccess) mutable {
>-            postTaskReply([completionHandler = WTFMove(completionHandler), hasStorageAccess] () mutable {
>+            postTaskReply([completionHandler = WTFMove(completionHandler), hasStorageAccess]() mutable {
>                 completionHandler(hasStorageAccess);
>             });
>         });
>     });
> }
> 
>-#if ENABLE(RESOURCE_LOAD_STATISTICS)
> bool WebResourceLoadStatisticsStore::hasStorageAccessForFrame(const String& resourceDomain, const String& firstPartyDomain, uint64_t frameID, uint64_t pageID)
> {
>     return m_networkSession ? m_networkSession->networkStorageSession().hasStorageAccess(resourceDomain, firstPartyDomain, frameID, pageID) : false;
> }
>-#endif
> 
> void WebResourceLoadStatisticsStore::callHasStorageAccessForFrameHandler(const String& resourceDomain, const String& firstPartyDomain, uint64_t frameID, uint64_t pageID, CompletionHandler<void(bool hasAccess)>&& callback)
> {
>     ASSERT(RunLoop::isMain());
> 
>-#if ENABLE(RESOURCE_LOAD_STATISTICS)
>     if (m_websiteDataStore) {
>         m_websiteDataStore->hasStorageAccessForFrameHandler(resourceDomain, firstPartyDomain, frameID, pageID, WTFMove(callback));
>         return;
>-    } else {
>-        callback(hasStorageAccessForFrame(resourceDomain, firstPartyDomain, frameID, pageID));
>+    }
>+
>+    if (m_networkSession) {
>+        callback(m_networkSession->networkStorageSession().hasStorageAccess(resourceDomain, firstPartyDomain, frameID, pageID));
>         return;
>     }
>-#endif
>+
>     callback(false);
> }
> 
>@@ -281,6 +319,11 @@ void WebResourceLoadStatisticsStore::requestStorageAccess(String&& subFrameHost,
>     ASSERT(subFrameHost != topFrameHost);
>     ASSERT(RunLoop::isMain());
> 
>+    requestStorageAccess(subFrameHost, topFrameHost, frameID, pageID, promptEnabled, WTFMove(completionHandler));
>+}
>+    
>+void WebResourceLoadStatisticsStore::requestStorageAccess(const String& subFrameHost, const String& topFrameHost, Optional<uint64_t> frameID, uint64_t pageID, bool promptEnabled, CompletionHandler<void(StorageAccessStatus)>&& completionHandler)
>+{
>     auto subFramePrimaryDomain = isolatedPrimaryDomain(subFrameHost);
>     auto topFramePrimaryDomain = isolatedPrimaryDomain(topFrameHost);
>     if (subFramePrimaryDomain == topFramePrimaryDomain) {
>@@ -288,16 +331,16 @@ void WebResourceLoadStatisticsStore::requestStorageAccess(String&& subFrameHost,
>         return;
>     }
> 
>-    postTask([this, subFramePrimaryDomain = crossThreadCopy(subFramePrimaryDomain), topFramePrimaryDomain = crossThreadCopy(topFramePrimaryDomain), frameID, pageID, promptEnabled, completionHandler = WTFMove(completionHandler)] () mutable {
>+    postTask([this, subFramePrimaryDomain = crossThreadCopy(subFramePrimaryDomain), topFramePrimaryDomain = crossThreadCopy(topFramePrimaryDomain), frameID, pageID, promptEnabled, completionHandler = WTFMove(completionHandler)]() mutable {
>         if (!m_memoryStore) {
>-            postTaskReply([completionHandler = WTFMove(completionHandler)] () mutable {
>+            postTaskReply([completionHandler = WTFMove(completionHandler)]() mutable {
>                 completionHandler(StorageAccessStatus::CannotRequestAccess);
>             });
>             return;
>         }
> 
>-        m_memoryStore->requestStorageAccess(WTFMove(subFramePrimaryDomain), WTFMove(topFramePrimaryDomain), frameID, pageID, promptEnabled, [completionHandler = WTFMove(completionHandler)](StorageAccessStatus status) mutable {
>-            postTaskReply([completionHandler = WTFMove(completionHandler), status] () mutable {
>+        m_memoryStore->requestStorageAccess(WTFMove(subFramePrimaryDomain), WTFMove(topFramePrimaryDomain), frameID.value(), pageID, promptEnabled, [completionHandler = WTFMove(completionHandler)](StorageAccessStatus status) mutable {
>+            postTaskReply([completionHandler = WTFMove(completionHandler), status]() mutable {
>                 completionHandler(status);
>             });
>         });
>@@ -320,23 +363,22 @@ void WebResourceLoadStatisticsStore::requestStorageAccessUnderOpener(String&& pr
> void WebResourceLoadStatisticsStore::grantStorageAccess(String&& subFrameHost, String&& topFrameHost, uint64_t frameID, uint64_t pageID, bool userWasPromptedNow, CompletionHandler<void(bool)>&& completionHandler)
> {
>     ASSERT(RunLoop::isMain());
>-    postTask([this, subFrameHost = crossThreadCopy(subFrameHost), topFrameHost = crossThreadCopy(topFrameHost), frameID, pageID, userWasPromptedNow, completionHandler = WTFMove(completionHandler)] () mutable {
>+    postTask([this, subFrameHost = crossThreadCopy(subFrameHost), topFrameHost = crossThreadCopy(topFrameHost), frameID, pageID, userWasPromptedNow, completionHandler = WTFMove(completionHandler)]() mutable {
>         if (!m_memoryStore) {
>-            postTaskReply([completionHandler = WTFMove(completionHandler)] () mutable {
>+            postTaskReply([completionHandler = WTFMove(completionHandler)]() mutable {
>                 completionHandler(false);
>             });
>             return;
>         }
> 
>         m_memoryStore->grantStorageAccess(WTFMove(subFrameHost), WTFMove(topFrameHost), frameID, pageID, userWasPromptedNow, [completionHandler = WTFMove(completionHandler)](bool wasGrantedAccess) mutable {
>-            postTaskReply([completionHandler = WTFMove(completionHandler), wasGrantedAccess] () mutable {
>+            postTaskReply([completionHandler = WTFMove(completionHandler), wasGrantedAccess]() mutable {
>                 completionHandler(wasGrantedAccess);
>             });
>         });
>     });
> }
> 
>-#if ENABLE(RESOURCE_LOAD_STATISTICS)
> bool WebResourceLoadStatisticsStore::grantStorageAccess(const String& resourceDomain, const String& firstPartyDomain, Optional<uint64_t> frameID, uint64_t pageID)
> {
>     bool isStorageGranted = false;
>@@ -349,22 +391,17 @@ bool WebResourceLoadStatisticsStore::grantStorageAccess(const String& resourceDo
> 
>     return isStorageGranted;
> }
>-#endif
> 
> void WebResourceLoadStatisticsStore::callGrantStorageAccessHandler(const String& subFramePrimaryDomain, const String& topFramePrimaryDomain, Optional<uint64_t> frameID, uint64_t pageID, CompletionHandler<void(bool)>&& callback)
> {
>     ASSERT(RunLoop::isMain());
> 
>-#if ENABLE(RESOURCE_LOAD_STATISTICS)
>     if (m_websiteDataStore) {
>         m_websiteDataStore->grantStorageAccessHandler(subFramePrimaryDomain, topFramePrimaryDomain, frameID, pageID, WTFMove(callback));
>         return;
>-    } else {
>-        callback(grantStorageAccess(subFramePrimaryDomain, topFramePrimaryDomain, frameID, pageID));
>-        return;
>     }
>-#endif
>-    callback(false);
>+
>+    callback(grantStorageAccess(subFramePrimaryDomain, topFramePrimaryDomain, frameID, pageID));
> }
> 
> void WebResourceLoadStatisticsStore::didCreateNetworkProcess()
>@@ -378,25 +415,21 @@ void WebResourceLoadStatisticsStore::didCreateNetworkProcess()
>     });
> }
> 
>-#if ENABLE(RESOURCE_LOAD_STATISTICS)
> void WebResourceLoadStatisticsStore::removeAllStorageAccess()
> {
>     if (m_networkSession)
>         m_networkSession->networkStorageSession().removeAllStorageAccess();
> }
>-#endif
> 
> void WebResourceLoadStatisticsStore::removeAllStorageAccess(CompletionHandler<void()>&& completionHandler)
> {
>     ASSERT(RunLoop::isMain());
> 
>-#if ENABLE(RESOURCE_LOAD_STATISTICS)
>     if (m_websiteDataStore) {
>         m_websiteDataStore->removeAllStorageAccessHandler(WTFMove(completionHandler));
>         return;
>     }
>     removeAllStorageAccess();
>-#endif
>     completionHandler();
> }
> 
>@@ -418,13 +451,15 @@ void WebResourceLoadStatisticsStore::performDailyTasks()
>     });
> }
> 
>-void WebResourceLoadStatisticsStore::submitTelemetry()
>+void WebResourceLoadStatisticsStore::submitTelemetry(CompletionHandler<void()>&& completionHandler)
> {
>     ASSERT(RunLoop::isMain());
> 
>-    postTask([this] {
>+    postTask([this, completionHandler = WTFMove(completionHandler)]() mutable  {
>         if (m_memoryStore)
>             WebResourceLoadStatisticsTelemetry::calculateAndSubmit(*m_memoryStore);
>+
>+        postTaskReply(WTFMove(completionHandler));
>     });
> }
> 
>@@ -476,7 +511,7 @@ void WebResourceLoadStatisticsStore::logUserInteraction(const URL& url, Completi
>         return;
>     }
> 
>-    logUserInteraction(isolatedPrimaryDomain(url), WTFMove(completionHandler));
>+    logUserInteraction(WebCore::ResourceLoadStatistics::primaryDomain(url), WTFMove(completionHandler));
> }
> 
> void WebResourceLoadStatisticsStore::logUserInteraction(const String& targetPrimaryDomain, CompletionHandler<void()>&& completionHandler)
>@@ -499,7 +534,14 @@ void WebResourceLoadStatisticsStore::clearUserInteraction(const URL& url, Comple
>         return;
>     }
> 
>-    postTask([this, primaryDomain = isolatedPrimaryDomain(url), completionHandler = WTFMove(completionHandler)]() mutable {
>+    clearUserInteraction(WebCore::ResourceLoadStatistics::primaryDomain(url), WTFMove(completionHandler));
>+}
>+
>+void WebResourceLoadStatisticsStore::clearUserInteraction(const String& targetPrimaryDomain, CompletionHandler<void()>&& completionHandler)
>+{
>+    ASSERT(RunLoop::isMain());
>+    
>+    postTask([this, primaryDomain = targetPrimaryDomain.isolatedCopy(), completionHandler = WTFMove(completionHandler)]() mutable {
>         if (m_memoryStore)
>             m_memoryStore->clearUserInteraction(primaryDomain);
>         postTaskReply(WTFMove(completionHandler));
>@@ -515,9 +557,14 @@ void WebResourceLoadStatisticsStore::hasHadUserInteraction(const URL& url, Compl
>         return;
>     }
> 
>-    postTask([this, primaryDomain = isolatedPrimaryDomain(url), completionHandler = WTFMove(completionHandler)] () mutable {
>+    hasHadUserInteraction(WebCore::ResourceLoadStatistics::primaryDomain(url), WTFMove(completionHandler));
>+}
>+
>+void WebResourceLoadStatisticsStore::hasHadUserInteraction(const String& primaryDomain, CompletionHandler<void(bool)>&& completionHandler)
>+{
>+    postTask([this, primaryDomain = primaryDomain.isolatedCopy(), completionHandler = WTFMove(completionHandler)]() mutable {
>         bool hadUserInteraction = m_memoryStore ? m_memoryStore->hasHadUserInteraction(primaryDomain) : false;
>-        postTaskReply([hadUserInteraction, completionHandler = WTFMove(completionHandler)] () mutable {
>+        postTaskReply([hadUserInteraction, completionHandler = WTFMove(completionHandler)]() mutable {
>             completionHandler(hadUserInteraction);
>         });
>     });
>@@ -532,9 +579,16 @@ void WebResourceLoadStatisticsStore::setLastSeen(const URL& url, Seconds seconds
>         return;
>     }
> 
>-    postTask([this, primaryDomain = isolatedPrimaryDomain(url), seconds, completionHandler = WTFMove(completionHandler)]() mutable {
>+    setLastSeen(WebCore::ResourceLoadStatistics::primaryDomain(url), seconds, WTFMove(completionHandler));
>+}
>+
>+void WebResourceLoadStatisticsStore::setLastSeen(const String& resourceDomain, Seconds seconds, CompletionHandler<void()>&& completionHandler)
>+{
>+    ASSERT(RunLoop::isMain());
>+    
>+    postTask([this, resourceDomain = resourceDomain.isolatedCopy(), seconds, completionHandler = WTFMove(completionHandler)]() mutable {
>         if (m_memoryStore)
>-            m_memoryStore->setLastSeen(primaryDomain, seconds);
>+            m_memoryStore->setLastSeen(resourceDomain, seconds);
>         postTaskReply(WTFMove(completionHandler));
>     });
> }
>@@ -548,9 +602,16 @@ void WebResourceLoadStatisticsStore::setPrevalentResource(const URL& url, Comple
>         return;
>     }
> 
>-    postTask([this, primaryDomain = isolatedPrimaryDomain(url), completionHandler = WTFMove(completionHandler)]() mutable {
>+    setPrevalentResource(WebCore::ResourceLoadStatistics::primaryDomain(url), WTFMove(completionHandler));
>+}
>+
>+void WebResourceLoadStatisticsStore::setPrevalentResource(const String& resourceDomain, CompletionHandler<void()>&& completionHandler)
>+{
>+    ASSERT(RunLoop::isMain());
>+
>+    postTask([this, resourceDomain = resourceDomain.isolatedCopy(), completionHandler = WTFMove(completionHandler)]() mutable {
>         if (m_memoryStore)
>-            m_memoryStore->setPrevalentResource(primaryDomain);
>+            m_memoryStore->setPrevalentResource(resourceDomain);
>         postTaskReply(WTFMove(completionHandler));
>     });
> }
>@@ -564,7 +625,14 @@ void WebResourceLoadStatisticsStore::setVeryPrevalentResource(const URL& url, Co
>         return;
>     }
> 
>-    postTask([this, primaryDomain = isolatedPrimaryDomain(url), completionHandler = WTFMove(completionHandler)]() mutable {
>+    setVeryPrevalentResource(WebCore::ResourceLoadStatistics::primaryDomain(url), WTFMove(completionHandler));
>+}
>+
>+void WebResourceLoadStatisticsStore::setVeryPrevalentResource(const String& primaryDomain, CompletionHandler<void()>&& completionHandler)
>+{
>+    ASSERT(RunLoop::isMain());
>+
>+    postTask([this, primaryDomain = primaryDomain.isolatedCopy(), completionHandler = WTFMove(completionHandler)]() mutable {
>         if (m_memoryStore)
>             m_memoryStore->setVeryPrevalentResource(primaryDomain);
>         postTaskReply(WTFMove(completionHandler));
>@@ -575,9 +643,9 @@ void WebResourceLoadStatisticsStore::dumpResourceLoadStatistics(CompletionHandle
> {
>     ASSERT(RunLoop::isMain());
> 
>-    postTask([this, completionHandler = WTFMove(completionHandler)] () mutable {
>+    postTask([this, completionHandler = WTFMove(completionHandler)]() mutable {
>         String result = m_memoryStore ? m_memoryStore->dumpResourceLoadStatistics() : emptyString();
>-        postTaskReply([result = result.isolatedCopy(), completionHandler = WTFMove(completionHandler)] () mutable {
>+        postTaskReply([result = result.isolatedCopy(), completionHandler = WTFMove(completionHandler)]() mutable {
>             completionHandler(result);
>         });
>     });
>@@ -592,14 +660,21 @@ void WebResourceLoadStatisticsStore::isPrevalentResource(const URL& url, Complet
>         return;
>     }
> 
>-    postTask([this, primaryDomain = isolatedPrimaryDomain(url), completionHandler = WTFMove(completionHandler)] () mutable {
>+    isPrevalentResource(WebCore::ResourceLoadStatistics::primaryDomain(url), WTFMove(completionHandler));
>+}
>+
>+void WebResourceLoadStatisticsStore::isPrevalentResource(const String& primaryDomain, CompletionHandler<void(bool)>&& completionHandler)
>+{
>+    ASSERT(RunLoop::isMain());
>+    
>+    postTask([this, primaryDomain = primaryDomain.isolatedCopy(), completionHandler = WTFMove(completionHandler)]() mutable {
>         bool isPrevalentResource = m_memoryStore ? m_memoryStore->isPrevalentResource(primaryDomain) : false;
>-        postTaskReply([isPrevalentResource, completionHandler = WTFMove(completionHandler)] () mutable {
>+        postTaskReply([isPrevalentResource, completionHandler = WTFMove(completionHandler)]() mutable {
>             completionHandler(isPrevalentResource);
>         });
>     });
> }
>-
>+    
> void WebResourceLoadStatisticsStore::isVeryPrevalentResource(const URL& url, CompletionHandler<void(bool)>&& completionHandler)
> {
>     ASSERT(RunLoop::isMain());
>@@ -609,9 +684,16 @@ void WebResourceLoadStatisticsStore::isVeryPrevalentResource(const URL& url, Com
>         return;
>     }
>     
>-    postTask([this, primaryDomain = isolatedPrimaryDomain(url), completionHandler = WTFMove(completionHandler)] () mutable {
>+    isVeryPrevalentResource(WebCore::ResourceLoadStatistics::primaryDomain(url), WTFMove(completionHandler));
>+}
>+
>+void WebResourceLoadStatisticsStore::isVeryPrevalentResource(const String& primaryDomain, CompletionHandler<void(bool)>&& completionHandler)
>+{
>+    ASSERT(RunLoop::isMain());
>+    
>+    postTask([this, primaryDomain = primaryDomain.isolatedCopy(), completionHandler = WTFMove(completionHandler)]() mutable {
>         bool isVeryPrevalentResource = m_memoryStore ? m_memoryStore->isVeryPrevalentResource(primaryDomain) : false;
>-        postTaskReply([isVeryPrevalentResource, completionHandler = WTFMove(completionHandler)] () mutable {
>+        postTaskReply([isVeryPrevalentResource, completionHandler = WTFMove(completionHandler)]() mutable {
>             completionHandler(isVeryPrevalentResource);
>         });
>     });
>@@ -620,10 +702,17 @@ void WebResourceLoadStatisticsStore::isVeryPrevalentResource(const URL& url, Com
> void WebResourceLoadStatisticsStore::isRegisteredAsSubresourceUnder(const URL& subresource, const URL& topFrame, CompletionHandler<void(bool)>&& completionHandler)
> {
>     ASSERT(RunLoop::isMain());
>-    
>-    postTask([this, subresourcePrimaryDomain = isolatedPrimaryDomain(subresource), topFramePrimaryDomain = isolatedPrimaryDomain(topFrame), completionHandler = WTFMove(completionHandler)] () mutable {
>+
>+    isRegisteredAsSubresourceUnder(WebCore::ResourceLoadStatistics::primaryDomain(subresource), WebCore::ResourceLoadStatistics::primaryDomain(topFrame), WTFMove(completionHandler));
>+}
>+
>+void WebResourceLoadStatisticsStore::isRegisteredAsSubresourceUnder(const String& subresource, const String& topFrame, CompletionHandler<void(bool)>&& completionHandler)
>+{
>+    ASSERT(RunLoop::isMain());
>+
>+    postTask([this, subresourcePrimaryDomain = subresource.isolatedCopy(), topFramePrimaryDomain = topFrame.isolatedCopy(), completionHandler = WTFMove(completionHandler)]() mutable {
>         bool isRegisteredAsSubresourceUnder = m_memoryStore ? m_memoryStore->isRegisteredAsSubresourceUnder(subresourcePrimaryDomain, topFramePrimaryDomain) : false;
>-        postTaskReply([isRegisteredAsSubresourceUnder, completionHandler = WTFMove(completionHandler)] () mutable {
>+        postTaskReply([isRegisteredAsSubresourceUnder, completionHandler = WTFMove(completionHandler)]() mutable {
>             completionHandler(isRegisteredAsSubresourceUnder);
>         });
>     });
>@@ -633,9 +722,16 @@ void WebResourceLoadStatisticsStore::isRegisteredAsSubFrameUnder(const URL& subF
> {
>     ASSERT(RunLoop::isMain());
> 
>-    postTask([this, subFramePrimaryDomain = isolatedPrimaryDomain(subFrame), topFramePrimaryDomain = isolatedPrimaryDomain(topFrame), completionHandler = WTFMove(completionHandler)] () mutable {
>+    isRegisteredAsSubFrameUnder(WebCore::ResourceLoadStatistics::primaryDomain(subFrame), WebCore::ResourceLoadStatistics::primaryDomain(topFrame), WTFMove(completionHandler));
>+}
>+
>+void WebResourceLoadStatisticsStore::isRegisteredAsSubFrameUnder(const String& subFrame, const String& topFrame, CompletionHandler<void(bool)>&& completionHandler)
>+{
>+    ASSERT(RunLoop::isMain());
>+
>+    postTask([this, subFramePrimaryDomain = subFrame.isolatedCopy(), topFramePrimaryDomain = topFrame.isolatedCopy(), completionHandler = WTFMove(completionHandler)]() mutable {
>         bool isRegisteredAsSubFrameUnder = m_memoryStore ? m_memoryStore->isRegisteredAsSubFrameUnder(subFramePrimaryDomain, topFramePrimaryDomain) : false;
>-        postTaskReply([isRegisteredAsSubFrameUnder, completionHandler = WTFMove(completionHandler)] () mutable {
>+        postTaskReply([isRegisteredAsSubFrameUnder, completionHandler = WTFMove(completionHandler)]() mutable {
>             completionHandler(isRegisteredAsSubFrameUnder);
>         });
>     });
>@@ -645,9 +741,16 @@ void WebResourceLoadStatisticsStore::isRegisteredAsRedirectingTo(const URL& host
> {
>     ASSERT(RunLoop::isMain());
> 
>-    postTask([this, hostRedirectedFromPrimaryDomain = isolatedPrimaryDomain(hostRedirectedFrom), hostRedirectedToPrimaryDomain = isolatedPrimaryDomain(hostRedirectedTo), completionHandler = WTFMove(completionHandler)] () mutable {
>+    isRegisteredAsRedirectingTo(WebCore::ResourceLoadStatistics::primaryDomain(hostRedirectedFrom), WebCore::ResourceLoadStatistics::primaryDomain(hostRedirectedTo), WTFMove(completionHandler));
>+}
>+
>+void WebResourceLoadStatisticsStore::isRegisteredAsRedirectingTo(const String& hostRedirectedFrom, const String& hostRedirectedTo, CompletionHandler<void(bool)>&& completionHandler)
>+{
>+    ASSERT(RunLoop::isMain());
>+
>+    postTask([this, hostRedirectedFromPrimaryDomain = hostRedirectedFrom.isolatedCopy(), hostRedirectedToPrimaryDomain = hostRedirectedTo.isolatedCopy(), completionHandler = WTFMove(completionHandler)]() mutable {
>         bool isRegisteredAsRedirectingTo = m_memoryStore ? m_memoryStore->isRegisteredAsRedirectingTo(hostRedirectedFromPrimaryDomain, hostRedirectedToPrimaryDomain) : false;
>-        postTaskReply([isRegisteredAsRedirectingTo, completionHandler = WTFMove(completionHandler)] () mutable {
>+        postTaskReply([isRegisteredAsRedirectingTo, completionHandler = WTFMove(completionHandler)]() mutable {
>             completionHandler(isRegisteredAsRedirectingTo);
>         });
>     });
>@@ -662,26 +765,41 @@ void WebResourceLoadStatisticsStore::clearPrevalentResource(const URL& url, Comp
>         return;
>     }
> 
>-    postTask([this, primaryDomain = isolatedPrimaryDomain(url), completionHandler = WTFMove(completionHandler)]() mutable {
>+    clearPrevalentResource(WebCore::ResourceLoadStatistics::primaryDomain(url), WTFMove(completionHandler));
>+}
>+
>+void WebResourceLoadStatisticsStore::clearPrevalentResource(const String& resourceDomain, CompletionHandler<void()>&& completionHandler)
>+{
>+    ASSERT(RunLoop::isMain());
>+    
>+    postTask([this, resourceDomain = resourceDomain.isolatedCopy(), completionHandler = WTFMove(completionHandler)]() mutable {
>         if (m_memoryStore)
>-            m_memoryStore->clearPrevalentResource(primaryDomain);
>+            m_memoryStore->clearPrevalentResource(resourceDomain);
>         postTaskReply(WTFMove(completionHandler));
>     });
> }
> 
>-void WebResourceLoadStatisticsStore::setGrandfathered(const URL& url, bool value)
>+void WebResourceLoadStatisticsStore::setGrandfathered(const URL& url, bool value, CompletionHandler<void()>&& completionHandler)
> {
>     ASSERT(RunLoop::isMain());
> 
>     if (url.protocolIsAbout() || url.isEmpty())
>         return;
> 
>-    postTask([this, primaryDomain = isolatedPrimaryDomain(url), value] {
>+    setGrandfathered(WebCore::ResourceLoadStatistics::primaryDomain(url), value, WTFMove(completionHandler));
>+}
>+
>+void WebResourceLoadStatisticsStore::setGrandfathered(const String& domain, bool value, CompletionHandler<void()>&& completionHandler)
>+{
>+    ASSERT(RunLoop::isMain());
>+
>+    postTask([this, primaryDomain = domain.isolatedCopy(), value, completionHandler = WTFMove(completionHandler)]() mutable {
>         if (m_memoryStore)
>             m_memoryStore->setGrandfathered(primaryDomain, value);
>+        postTaskReply(WTFMove(completionHandler));
>     });
> }
>-
>+    
> void WebResourceLoadStatisticsStore::isGrandfathered(const URL& url, CompletionHandler<void (bool)>&& completionHandler)
> {
>     ASSERT(RunLoop::isMain());
>@@ -691,89 +809,156 @@ void WebResourceLoadStatisticsStore::isGrandfathered(const URL& url, CompletionH
>         return;
>     }
> 
>-    postTask([this, completionHandler = WTFMove(completionHandler), primaryDomain = isolatedPrimaryDomain(url)] () mutable {
>+    isGrandfathered(WebCore::ResourceLoadStatistics::primaryDomain(url), WTFMove(completionHandler));
>+}
>+
>+void WebResourceLoadStatisticsStore::isGrandfathered(const String& primaryDomain, CompletionHandler<void(bool)>&& completionHandler)
>+{
>+    ASSERT(RunLoop::isMain());
>+
>+    postTask([this, completionHandler = WTFMove(completionHandler), primaryDomain = primaryDomain.isolatedCopy()]() mutable {
>         bool isGrandFathered = m_memoryStore ? m_memoryStore->isGrandfathered(primaryDomain) : false;
>-        postTaskReply([isGrandFathered, completionHandler = WTFMove(completionHandler)] () mutable {
>+        postTaskReply([isGrandFathered, completionHandler = WTFMove(completionHandler)]() mutable {
>             completionHandler(isGrandFathered);
>         });
>     });
> }
> 
>-void WebResourceLoadStatisticsStore::setSubframeUnderTopFrameOrigin(const URL& subframe, const URL& topFrame)
>+void WebResourceLoadStatisticsStore::setSubframeUnderTopFrameOrigin(const URL& subframe, const URL& topFrame, CompletionHandler<void()>&& completionHandler)
> {
>     ASSERT(RunLoop::isMain());
> 
>-    if (subframe.protocolIsAbout() || subframe.isEmpty() || topFrame.protocolIsAbout() || topFrame.isEmpty())
>+    if (subframe.protocolIsAbout() || subframe.isEmpty() || topFrame.protocolIsAbout() || topFrame.isEmpty()) {
>+        completionHandler();
>         return;
>+    }
>+
>+    setSubframeUnderTopFrameOrigin(WebCore::ResourceLoadStatistics::primaryDomain(subframe), WebCore::ResourceLoadStatistics::primaryDomain(topFrame), WTFMove(completionHandler));
>+}
> 
>-    postTask([this, primaryTopFrameDomain = isolatedPrimaryDomain(topFrame), primarySubFrameDomain = isolatedPrimaryDomain(subframe)] {
>+void WebResourceLoadStatisticsStore::setSubframeUnderTopFrameOrigin(const String& subframe, const String& topFrame, CompletionHandler<void()>&& completionHandler)
>+{
>+    ASSERT(RunLoop::isMain());
>+    
>+    postTask([this, completionHandler = WTFMove(completionHandler), primaryTopFrameDomain = topFrame.isolatedCopy(), primarySubFrameDomain = subframe.isolatedCopy()]() mutable {
>         if (m_memoryStore)
>             m_memoryStore->setSubframeUnderTopFrameOrigin(primarySubFrameDomain, primaryTopFrameDomain);
>+        postTaskReply(WTFMove(completionHandler));
>     });
> }
> 
>-void WebResourceLoadStatisticsStore::setSubresourceUnderTopFrameOrigin(const URL& subresource, const URL& topFrame)
>+void WebResourceLoadStatisticsStore::setSubresourceUnderTopFrameOrigin(const URL& subresource, const URL& topFrame, CompletionHandler<void()>&& completionHandler)
> {
>     ASSERT(RunLoop::isMain());
> 
>-    if (subresource.protocolIsAbout() || subresource.isEmpty() || topFrame.protocolIsAbout() || topFrame.isEmpty())
>+    if (subresource.protocolIsAbout() || subresource.isEmpty() || topFrame.protocolIsAbout() || topFrame.isEmpty()) {
>+        completionHandler();
>         return;
>+    }
>+
>+    setSubresourceUnderTopFrameOrigin(WebCore::ResourceLoadStatistics::primaryDomain(subresource), WebCore::ResourceLoadStatistics::primaryDomain(topFrame), WTFMove(completionHandler));
>+}
> 
>-    postTask([this, primaryTopFrameDomain = isolatedPrimaryDomain(topFrame), primarySubresourceDomain = isolatedPrimaryDomain(subresource)] {
>+void WebResourceLoadStatisticsStore::setSubresourceUnderTopFrameOrigin(const String& subresource, const String& topFrame, CompletionHandler<void()>&& completionHandler)
>+{
>+    ASSERT(RunLoop::isMain());
>+    
>+    postTask([this, completionHandler = WTFMove(completionHandler), primaryTopFrameDomain = topFrame.isolatedCopy(), primarySubresourceDomain = subresource.isolatedCopy()]() mutable {
>         if (m_memoryStore)
>             m_memoryStore->setSubresourceUnderTopFrameOrigin(primarySubresourceDomain, primaryTopFrameDomain);
>+        postTaskReply(WTFMove(completionHandler));
>     });
> }
> 
>-void WebResourceLoadStatisticsStore::setSubresourceUniqueRedirectTo(const URL& subresource, const URL& hostNameRedirectedTo)
>+void WebResourceLoadStatisticsStore::setSubresourceUniqueRedirectTo(const URL& subresource, const URL& hostNameRedirectedTo, CompletionHandler<void()>&& completionHandler)
> {
>     ASSERT(RunLoop::isMain());
> 
>-    if (subresource.protocolIsAbout() || subresource.isEmpty() || hostNameRedirectedTo.protocolIsAbout() || hostNameRedirectedTo.isEmpty())
>+    if (subresource.protocolIsAbout() || subresource.isEmpty() || hostNameRedirectedTo.protocolIsAbout() || hostNameRedirectedTo.isEmpty()) {
>+        completionHandler();
>         return;
>+    }
>+
>+    setSubresourceUniqueRedirectTo(WebCore::ResourceLoadStatistics::primaryDomain(subresource), WebCore::ResourceLoadStatistics::primaryDomain(hostNameRedirectedTo), WTFMove(completionHandler));
>+}
> 
>-    postTask([this, primaryRedirectDomain = isolatedPrimaryDomain(hostNameRedirectedTo), primarySubresourceDomain = isolatedPrimaryDomain(subresource)] {
>+void WebResourceLoadStatisticsStore::setSubresourceUniqueRedirectTo(const String& subresource, const String& hostNameRedirectedTo, CompletionHandler<void()>&& completionHandler)
>+{
>+    ASSERT(RunLoop::isMain());
>+    
>+    postTask([this, completionHandler = WTFMove(completionHandler), primaryRedirectDomain = hostNameRedirectedTo.isolatedCopy(), primarySubresourceDomain = subresource.isolatedCopy()]() mutable {
>         if (m_memoryStore)
>             m_memoryStore->setSubresourceUniqueRedirectTo(primarySubresourceDomain, primaryRedirectDomain);
>+        postTaskReply(WTFMove(completionHandler));
>     });
> }
> 
>-void WebResourceLoadStatisticsStore::setSubresourceUniqueRedirectFrom(const URL& subresource, const URL& hostNameRedirectedFrom)
>+void WebResourceLoadStatisticsStore::setSubresourceUniqueRedirectFrom(const URL& subresource, const URL& hostNameRedirectedFrom, CompletionHandler<void()>&& completionHandler)
> {
>     ASSERT(RunLoop::isMain());
> 
>-    if (subresource.protocolIsAbout() || subresource.isEmpty() || hostNameRedirectedFrom.protocolIsAbout() || hostNameRedirectedFrom.isEmpty())
>+    if (subresource.protocolIsAbout() || subresource.isEmpty() || hostNameRedirectedFrom.protocolIsAbout() || hostNameRedirectedFrom.isEmpty()) {
>+        completionHandler();
>         return;
>+    }
>+
>+    setSubresourceUniqueRedirectFrom(WebCore::ResourceLoadStatistics::primaryDomain(subresource), WebCore::ResourceLoadStatistics::primaryDomain(hostNameRedirectedFrom), WTFMove(completionHandler));
>+}
>+
>+void WebResourceLoadStatisticsStore::setSubresourceUniqueRedirectFrom(const String& subresource, const String& hostNameRedirectedFrom, CompletionHandler<void()>&& completionHandler)
>+{
>+    ASSERT(RunLoop::isMain());
>     
>-    postTask([this, primaryRedirectDomain = isolatedPrimaryDomain(hostNameRedirectedFrom), primarySubresourceDomain = isolatedPrimaryDomain(subresource)] {
>+    postTask([this, completionHandler = WTFMove(completionHandler), primaryRedirectDomain = hostNameRedirectedFrom.isolatedCopy(), primarySubresourceDomain = subresource.isolatedCopy()]() mutable {
>         if (m_memoryStore)
>             m_memoryStore->setSubresourceUniqueRedirectFrom(primarySubresourceDomain, primaryRedirectDomain);
>+        postTaskReply(WTFMove(completionHandler));
>     });
> }
> 
>-void WebResourceLoadStatisticsStore::setTopFrameUniqueRedirectTo(const URL& topFrameHostName, const URL& hostNameRedirectedTo)
>+void WebResourceLoadStatisticsStore::setTopFrameUniqueRedirectTo(const URL& topFrameHostName, const URL& hostNameRedirectedTo, CompletionHandler<void()>&& completionHandler)
> {
>     ASSERT(RunLoop::isMain());
> 
>-    if (topFrameHostName.protocolIsAbout() || topFrameHostName.isEmpty() || hostNameRedirectedTo.protocolIsAbout() || hostNameRedirectedTo.isEmpty())
>+    if (topFrameHostName.protocolIsAbout() || topFrameHostName.isEmpty() || hostNameRedirectedTo.protocolIsAbout() || hostNameRedirectedTo.isEmpty()) {
>+        completionHandler();
>         return;
>+    }
>+
>+    setTopFrameUniqueRedirectTo(WebCore::ResourceLoadStatistics::primaryDomain(topFrameHostName), WebCore::ResourceLoadStatistics::primaryDomain(hostNameRedirectedTo), WTFMove(completionHandler));
>+}
>+
>+void WebResourceLoadStatisticsStore::setTopFrameUniqueRedirectTo(const String& topFrameHostName, const String& hostNameRedirectedTo, CompletionHandler<void()>&& completionHandler)
>+{
>+    ASSERT(RunLoop::isMain());
>     
>-    postTask([this, primaryRedirectDomain = isolatedPrimaryDomain(hostNameRedirectedTo), topFramePrimaryDomain = isolatedPrimaryDomain(topFrameHostName)] {
>+    postTask([this, completionHandler = WTFMove(completionHandler), topFramePrimaryDomain = topFrameHostName.isolatedCopy(), primaryRedirectDomain = hostNameRedirectedTo.isolatedCopy()]() mutable {
>         if (m_memoryStore)
>             m_memoryStore->setTopFrameUniqueRedirectTo(topFramePrimaryDomain, primaryRedirectDomain);
>+        postTaskReply(WTFMove(completionHandler));
>     });
> }
> 
>-void WebResourceLoadStatisticsStore::setTopFrameUniqueRedirectFrom(const URL& topFrameHostName, const URL& hostNameRedirectedFrom)
>+void WebResourceLoadStatisticsStore::setTopFrameUniqueRedirectFrom(const URL& topFrameHostName, const URL& hostNameRedirectedFrom, CompletionHandler<void()>&& completionHandler)
> {
>     ASSERT(RunLoop::isMain());
> 
>-    if (topFrameHostName.protocolIsAbout() || topFrameHostName.isEmpty() || hostNameRedirectedFrom.protocolIsAbout() || hostNameRedirectedFrom.isEmpty())
>+    if (topFrameHostName.protocolIsAbout() || topFrameHostName.isEmpty() || hostNameRedirectedFrom.protocolIsAbout() || hostNameRedirectedFrom.isEmpty()) {
>+        completionHandler();
>         return;
>+    }
>+
>+    setTopFrameUniqueRedirectFrom(WebCore::ResourceLoadStatistics::primaryDomain(topFrameHostName), WebCore::ResourceLoadStatistics::primaryDomain(hostNameRedirectedFrom), WTFMove(completionHandler));
>+}
>+
>+void WebResourceLoadStatisticsStore::setTopFrameUniqueRedirectFrom(const String& topFrameHostName, const String& hostNameRedirectedFrom, CompletionHandler<void()>&& completionHandler)
>+{
>+    ASSERT(RunLoop::isMain());
>     
>-    postTask([this, primaryRedirectDomain = isolatedPrimaryDomain(hostNameRedirectedFrom), topFramePrimaryDomain = isolatedPrimaryDomain(topFrameHostName)] {
>+    postTask([this, completionHandler = WTFMove(completionHandler), topFramePrimaryDomain = topFrameHostName.isolatedCopy(), primaryRedirectDomain = hostNameRedirectedFrom.isolatedCopy()]() mutable {
>         if (m_memoryStore)
>             m_memoryStore->setTopFrameUniqueRedirectFrom(topFramePrimaryDomain, primaryRedirectDomain);
>+        postTaskReply(WTFMove(completionHandler));
>     });
> }
> 
>@@ -782,12 +967,12 @@ void WebResourceLoadStatisticsStore::scheduleCookieBlockingUpdate(CompletionHand
>     // Helper function used by testing system. Should only be called from the main thread.
>     ASSERT(RunLoop::isMain());
> 
>-    postTask([this, completionHandler = WTFMove(completionHandler)] () mutable {
>+    postTask([this, completionHandler = WTFMove(completionHandler)]() mutable {
>         if (!m_memoryStore) {
>             postTaskReply(WTFMove(completionHandler));
>             return;
>         }
>-        m_memoryStore->updateCookieBlocking([completionHandler = WTFMove(completionHandler)] () mutable {
>+        m_memoryStore->updateCookieBlocking([completionHandler = WTFMove(completionHandler)]() mutable {
>             postTaskReply(WTFMove(completionHandler));
>         });
>     });
>@@ -797,7 +982,7 @@ void WebResourceLoadStatisticsStore::scheduleCookieBlockingUpdateForDomains(cons
> {
>     // Helper function used by testing system. Should only be called from the main thread.
>     ASSERT(RunLoop::isMain());
>-    postTask([this, domainsToBlock = crossThreadCopy(domainsToBlock), completionHandler = WTFMove(completionHandler)] () mutable {
>+    postTask([this, domainsToBlock = crossThreadCopy(domainsToBlock), completionHandler = WTFMove(completionHandler)]() mutable {
>         if (!m_memoryStore) {
>             postTaskReply(WTFMove(completionHandler));
>             return;
>@@ -813,7 +998,7 @@ void WebResourceLoadStatisticsStore::scheduleClearBlockingStateForDomains(const
> {
>     // Helper function used by testing system. Should only be called from the main thread.
>     ASSERT(RunLoop::isMain());
>-    postTask([this, domains = crossThreadCopy(domains), completionHandler = WTFMove(completionHandler)] () mutable {
>+    postTask([this, domains = crossThreadCopy(domains), completionHandler = WTFMove(completionHandler)]() mutable {
>         if (!m_memoryStore) {
>             postTaskReply(WTFMove(completionHandler));
>             return;
>@@ -828,7 +1013,7 @@ void WebResourceLoadStatisticsStore::scheduleClearBlockingStateForDomains(const
> void WebResourceLoadStatisticsStore::scheduleClearInMemoryAndPersistent(ShouldGrandfather shouldGrandfather, CompletionHandler<void()>&& completionHandler)
> {
>     ASSERT(RunLoop::isMain());
>-    postTask([this, protectedThis = makeRef(*this), shouldGrandfather, completionHandler = WTFMove(completionHandler)] () mutable {
>+    postTask([this, protectedThis = makeRef(*this), shouldGrandfather, completionHandler = WTFMove(completionHandler)]() mutable {
>         if (m_persistentStorage)
>             m_persistentStorage->clear();
> 
>@@ -861,113 +1046,110 @@ void WebResourceLoadStatisticsStore::scheduleClearInMemoryAndPersistent(WallTime
>     scheduleClearInMemoryAndPersistent(shouldGrandfather, WTFMove(callback));
> }
> 
>-void WebResourceLoadStatisticsStore::setTimeToLiveUserInteraction(Seconds seconds)
>+void WebResourceLoadStatisticsStore::setTimeToLiveUserInteraction(Seconds seconds, CompletionHandler<void()>&& completionHandler)
> {
>     ASSERT(RunLoop::isMain());
>-    postTask([this, seconds] {
>+    postTask([this, seconds, completionHandler = WTFMove(completionHandler)]() mutable {
>         if (m_memoryStore)
>             m_memoryStore->setTimeToLiveUserInteraction(seconds);
>+        postTaskReply(WTFMove(completionHandler));
>     });
> }
> 
>-void WebResourceLoadStatisticsStore::setMinimumTimeBetweenDataRecordsRemoval(Seconds seconds)
>+void WebResourceLoadStatisticsStore::setMinimumTimeBetweenDataRecordsRemoval(Seconds seconds, CompletionHandler<void()>&& completionHandler)
> {
>     ASSERT(RunLoop::isMain());
>-    postTask([this, seconds] {
>+    postTask([this, seconds, completionHandler = WTFMove(completionHandler)]() mutable  {
>         if (m_memoryStore)
>             m_memoryStore->setMinimumTimeBetweenDataRecordsRemoval(seconds);
>+
>+        postTaskReply(WTFMove(completionHandler));
>     });
> }
> 
>-void WebResourceLoadStatisticsStore::setGrandfatheringTime(Seconds seconds)
>+void WebResourceLoadStatisticsStore::setGrandfatheringTime(Seconds seconds, CompletionHandler<void()>&& completionHandler)
> {
>     ASSERT(RunLoop::isMain());
>-    postTask([this, seconds] {
>+    postTask([this, seconds, completionHandler = WTFMove(completionHandler)]() mutable  {
>         if (m_memoryStore)
>             m_memoryStore->setGrandfatheringTime(seconds);
>+
>+        postTaskReply(WTFMove(completionHandler));
>     });
> }
> 
>-#if ENABLE(RESOURCE_LOAD_STATISTICS)
> void WebResourceLoadStatisticsStore::setCacheMaxAgeCapForPrevalentResources(Seconds seconds)
> {
>     if (m_networkSession)
>         m_networkSession->networkStorageSession().setCacheMaxAgeCapForPrevalentResources(seconds);
> }
>-#endif
> 
> void WebResourceLoadStatisticsStore::setCacheMaxAgeCap(Seconds seconds, CompletionHandler<void()>&& completionHandler)
> {
>     ASSERT(RunLoop::isMain());
>     ASSERT(seconds >= 0_s);
>     
>-#if ENABLE(RESOURCE_LOAD_STATISTICS)
>     if (m_websiteDataStore) {
>         m_websiteDataStore->setCacheMaxAgeCapForPrevalentResources(seconds, WTFMove(completionHandler));
>         return;
>     }
>     setCacheMaxAgeCapForPrevalentResources(seconds);
>-#endif
>     completionHandler();
> }
> 
>-#if ENABLE(RESOURCE_LOAD_STATISTICS)
> void WebResourceLoadStatisticsStore::updatePrevalentDomainsToBlockCookiesFor(const Vector<String>& domainsToBlock)
> {
>     if (m_networkSession)
>         m_networkSession->networkStorageSession().setPrevalentDomainsToBlockCookiesFor(domainsToBlock);
> }
>-#endif
> 
> void WebResourceLoadStatisticsStore::callUpdatePrevalentDomainsToBlockCookiesForHandler(const Vector<String>& domainsToBlock, CompletionHandler<void()>&& completionHandler)
> {
>     ASSERT(RunLoop::isMain());
> 
>-#if ENABLE(RESOURCE_LOAD_STATISTICS)
>     if (m_websiteDataStore) {
>         m_websiteDataStore->updatePrevalentDomainsToBlockCookiesFor(domainsToBlock, WTFMove(completionHandler));
>         return;
>     }
>     updatePrevalentDomainsToBlockCookiesFor(domainsToBlock);
>-#endif
>     completionHandler();
> }
> 
>-#if ENABLE(RESOURCE_LOAD_STATISTICS)
> void WebResourceLoadStatisticsStore::removePrevalentDomains(const Vector<String>& domains)
> {
>     if (m_networkSession)
>         m_networkSession->networkStorageSession().removePrevalentDomains(domains);
> }
>-#endif
> 
> void WebResourceLoadStatisticsStore::callRemoveDomainsHandler(const Vector<String>& domains)
> {
>     ASSERT(RunLoop::isMain());
> 
>-#if ENABLE(RESOURCE_LOAD_STATISTICS)
>     if (m_websiteDataStore)
>         m_websiteDataStore->removePrevalentDomains(domains);
>     removePrevalentDomains(domains);
>-#endif
> }
>     
>-void WebResourceLoadStatisticsStore::setMaxStatisticsEntries(size_t maximumEntryCount)
>+void WebResourceLoadStatisticsStore::setMaxStatisticsEntries(size_t maximumEntryCount, CompletionHandler<void()>&& completionHandler)
> {
>     ASSERT(RunLoop::isMain());
>-    postTask([this, maximumEntryCount] {
>+    postTask([this, maximumEntryCount, completionHandler = WTFMove(completionHandler)]() mutable  {
>         if (m_memoryStore)
>             m_memoryStore->setMaxStatisticsEntries(maximumEntryCount);
>+
>+        postTaskReply(WTFMove(completionHandler));
>     });
> }
>     
>-void WebResourceLoadStatisticsStore::setPruneEntriesDownTo(size_t pruneTargetCount)
>+void WebResourceLoadStatisticsStore::setPruneEntriesDownTo(size_t pruneTargetCount, CompletionHandler<void()>&& completionHandler)
> {
>     ASSERT(RunLoop::isMain());
> 
>-    postTask([this, pruneTargetCount] {
>+    postTask([this, pruneTargetCount, completionHandler = WTFMove(completionHandler)]() mutable  {
>         if (m_memoryStore)
>             m_memoryStore->setPruneEntriesDownTo(pruneTargetCount);
>+
>+        postTaskReply(WTFMove(completionHandler));
>     });
> }
> 
>@@ -987,8 +1169,83 @@ void WebResourceLoadStatisticsStore::logTestingEvent(const String& event)
> {
>     ASSERT(RunLoop::isMain());
> 
>-    if (m_statisticsTestingCallback)
>-        m_statisticsTestingCallback(event);
>+    if (m_websiteDataStore) {
>+        m_websiteDataStore->logTestingEvent(event);
>+        return;
>+    }
>+    // FIXME(193297): Send message to UIProcess
>+}
>+
>+void WebResourceLoadStatisticsStore::notifyResourceLoadStatisticsProcessed()
>+{
>+    ASSERT(RunLoop::isMain());
>+    
>+    if (m_websiteDataStore)
>+        WebProcessProxy::notifyPageStatisticsAndDataRecordsProcessed();
>+
>+    if (m_networkSession)
>+        m_networkSession->notifyResourceLoadStatisticsProcessed();
>+}
>+
>+void WebResourceLoadStatisticsStore::deleteWebsiteDataForTopPrivatelyControlledDomainsInAllPersistentDataStores(OptionSet<WebsiteDataType> dataTypes, Vector<String>&& topPrivatelyControlledDomains, bool shouldNotifyPage, CompletionHandler<void(const HashSet<String>&)>&& completionHandler)
>+{
>+    ASSERT(RunLoop::isMain());
>+    
>+    if (m_websiteDataStore) {
>+        WebProcessProxy::deleteWebsiteDataForTopPrivatelyControlledDomainsInAllPersistentDataStores(dataTypes, WTFMove(topPrivatelyControlledDomains), shouldNotifyPage, WTFMove(completionHandler));
>+        return;
>+    }
>+
>+    if (m_networkSession) {
>+        m_networkSession->deleteWebsiteDataForTopPrivatelyControlledDomainsInAllPersistentDataStores(dataTypes, WTFMove(topPrivatelyControlledDomains), shouldNotifyPage, WTFMove(completionHandler));
>+        return;
>+    }
>+
>+    completionHandler({ });
>+}
>+
>+void WebResourceLoadStatisticsStore::topPrivatelyControlledDomainsWithWebsiteData(OptionSet<WebsiteDataType> dataTypes, bool shouldNotifyPage, CompletionHandler<void(HashSet<String>&&)>&& completionHandler)
>+{
>+    ASSERT(RunLoop::isMain());
>+    
>+    if (m_websiteDataStore) {
>+        WebProcessProxy::topPrivatelyControlledDomainsWithWebsiteData(dataTypes, shouldNotifyPage, WTFMove(completionHandler));
>+        return;
>+    }
>+
>+    if (m_networkSession) {
>+        m_networkSession->topPrivatelyControlledDomainsWithWebsiteData(dataTypes, shouldNotifyPage, WTFMove(completionHandler));
>+        return;
>+    }
>+
>+    completionHandler({ });
>+}
>+
>+void WebResourceLoadStatisticsStore::sendDiagnosticMessageWithValue(const String& message, const String& description, unsigned value, unsigned sigDigits, WebCore::ShouldSample shouldSample) const
>+{
>+    if (m_websiteDataStore) {
>+        if (auto* webPageProxy = WebPageProxy::nonEphemeralWebPageProxy())
>+            webPageProxy->logDiagnosticMessageWithValue(message, description, value, sigDigits, shouldSample);
>+    }
>+
>+    if (m_networkSession)
>+        const_cast<WebResourceLoadStatisticsStore*>(this)->networkSession()->logDiagnosticMessageWithValue(message, description, value, sigDigits, shouldSample);
>+}
>+
>+void WebResourceLoadStatisticsStore::notifyPageStatisticsTelemetryFinished(unsigned totalPrevalentResources, unsigned totalPrevalentResourcesWithUserInteraction, unsigned top3SubframeUnderTopFrameOrigins) const
>+{
>+    if (m_websiteDataStore) {
>+        API::Dictionary::MapType messageBody;
>+        messageBody.set("TotalPrevalentResources"_s, API::UInt64::create(totalPrevalentResources));
>+        messageBody.set("TotalPrevalentResourcesWithUserInteraction"_s, API::UInt64::create(totalPrevalentResourcesWithUserInteraction));
>+        messageBody.set("Top3SubframeUnderTopFrameOrigins"_s, API::UInt64::create(top3SubframeUnderTopFrameOrigins));
>+        WebProcessProxy::notifyPageStatisticsTelemetryFinished(API::Dictionary::create(messageBody).ptr());
>+    }
>+
>+    if (m_networkSession)
>+        const_cast<WebResourceLoadStatisticsStore*>(this)->networkSession()->notifyPageStatisticsTelemetryFinished(totalPrevalentResources, totalPrevalentResourcesWithUserInteraction, top3SubframeUnderTopFrameOrigins);
> }
> 
> } // namespace WebKit
>+
>+#endif
>diff --git a/Source/WebKit/NetworkProcess/Classifier/WebResourceLoadStatisticsStore.h b/Source/WebKit/NetworkProcess/Classifier/WebResourceLoadStatisticsStore.h
>index 00236a39553ec21cd184cc67255870fda57efad7..251b3925bab5ac402a8ce4d7f942e1026b46f76c 100644
>--- a/Source/WebKit/NetworkProcess/Classifier/WebResourceLoadStatisticsStore.h
>+++ b/Source/WebKit/NetworkProcess/Classifier/WebResourceLoadStatisticsStore.h
>@@ -1,5 +1,5 @@
> /*
>- * Copyright (C) 2016-2018 Apple Inc. All rights reserved.
>+ * Copyright (C) 2016-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
>@@ -25,6 +25,8 @@
> 
> #pragma once
> 
>+#if ENABLE(RESOURCE_LOAD_STATISTICS)
>+
> #include "Connection.h"
> #include "WebsiteDataType.h"
> #include <wtf/CompletionHandler.h>
>@@ -42,6 +44,7 @@ class WorkQueue;
> namespace WebCore {
> class ResourceRequest;
> struct ResourceLoadStatistics;
>+enum class ShouldSample : bool;
> }
> 
> namespace WebKit {
>@@ -53,12 +56,17 @@ class WebFrameProxy;
> class WebProcessProxy;
> class WebsiteDataStore;
> 
>-enum class StorageAccessStatus {
>+enum class StorageAccessStatus : unsigned {
>     CannotRequestAccess,
>     RequiresUserPrompt,
>     HasAccess
> };
> 
>+enum class ShouldGrandfather {
>+    No,
>+    Yes,
>+};
>+
> class WebResourceLoadStatisticsStore final : public ThreadSafeRefCounted<WebResourceLoadStatisticsStore, WTF::DestructionThread::Main>, public IPC::MessageReceiver {
> public:
>     static Ref<WebResourceLoadStatisticsStore> create(WebsiteDataStore& websiteDataStore)
>@@ -78,10 +86,10 @@ public:
>     WorkQueue& statisticsQueue() { return m_statisticsQueue.get(); }
> 
>     void setNotifyPagesWhenDataRecordsWereScanned(bool);
>-    void setShouldClassifyResourcesBeforeDataRecordsRemoval(bool);
>+    void setNotifyPagesWhenTelemetryWasCaptured(bool, CompletionHandler<void()>&&);
>+    void setShouldClassifyResourcesBeforeDataRecordsRemoval(bool, CompletionHandler<void()>&&);
>     void setShouldSubmitTelemetry(bool);
> 
>-    void hasStorageAccess(String&& subFrameHost, String&& topFrameHost, uint64_t frameID, uint64_t pageID, CompletionHandler<void(bool)>&& callback);
>     void requestStorageAccess(String&& subFrameHost, String&& topFrameHost, uint64_t frameID, uint64_t pageID, bool promptEnabled, CompletionHandler<void(StorageAccessStatus)>&&);
>     void grantStorageAccess(String&& subFrameHost, String&& topFrameHost, uint64_t frameID, uint64_t pageID, bool userWasPromptedNow, CompletionHandler<void(bool)>&&);
>     void requestStorageAccessCallback(bool wasGranted, uint64_t contextId);
>@@ -93,57 +101,76 @@ public:
>     void logUserInteraction(const URL&, CompletionHandler<void()>&&);
>     void logUserInteraction(const String& targetPrimaryDomain, CompletionHandler<void()>&&);
>     void clearUserInteraction(const URL&, CompletionHandler<void()>&&);
>+    void clearUserInteraction(const String& targetPrimaryDomain, CompletionHandler<void()>&&);
>+    void deleteWebsiteDataForTopPrivatelyControlledDomainsInAllPersistentDataStores(OptionSet<WebsiteDataType>, Vector<String>&& topPrivatelyControlledDomains, bool shouldNotifyPage, CompletionHandler<void(const HashSet<String>&)>&&);
>+    void topPrivatelyControlledDomainsWithWebsiteData(OptionSet<WebsiteDataType>, bool shouldNotifyPage, CompletionHandler<void(HashSet<String>&&)>&&);
>     bool grantStorageAccess(const String& resourceDomain, const String& firstPartyDomain, Optional<uint64_t> frameID, uint64_t pageID);
>     void hasHadUserInteraction(const URL&, CompletionHandler<void(bool)>&&);
>+    void hasHadUserInteraction(const String& resourceDomain, CompletionHandler<void(bool)>&&);
>+    void hasStorageAccess(const String& subFrameHost, const String& topFrameHost, Optional<uint64_t> frameID, uint64_t pageID, CompletionHandler<void(bool)>&& callback);
>     bool hasStorageAccessForFrame(const String& resourceDomain, const String& firstPartyDomain, uint64_t frameID, uint64_t pageID);
>+    void requestStorageAccess(const String& resourceDomain, const String& firstPartyDomain, Optional<uint64_t> frameID, uint64_t pageID, bool promptEnabled, CompletionHandler<void(StorageAccessStatus)>&&);
>     void setLastSeen(const URL&, Seconds, CompletionHandler<void()>&&);
>+    void setLastSeen(const String& resourceDomain, Seconds, CompletionHandler<void()>&&);
>     void setPrevalentResource(const URL&, CompletionHandler<void()>&&);
>+    void setPrevalentResource(const String& resourceDomain, CompletionHandler<void()>&&);
>     void setVeryPrevalentResource(const URL&, CompletionHandler<void()>&&);
>+    void setVeryPrevalentResource(const String& resourceDomain, CompletionHandler<void()>&&);
>     void dumpResourceLoadStatistics(CompletionHandler<void(const String&)>&&);
>     void isPrevalentResource(const URL&, CompletionHandler<void(bool)>&&);
>+    void isPrevalentResource(const String&, CompletionHandler<void(bool)>&&);
>     void isVeryPrevalentResource(const URL&, CompletionHandler<void(bool)>&&);
>+    void isVeryPrevalentResource(const String&, CompletionHandler<void(bool)>&&);
>     void isRegisteredAsSubresourceUnder(const URL& subresource, const URL& topFrame, CompletionHandler<void(bool)>&&);
>+    void isRegisteredAsSubresourceUnder(const String& subresource, const String& topFrame, CompletionHandler<void(bool)>&&);
>     void isRegisteredAsSubFrameUnder(const URL& subFrame, const URL& topFrame, CompletionHandler<void(bool)>&&);
>+    void isRegisteredAsSubFrameUnder(const String& subFrame, const String& topFrame, CompletionHandler<void(bool)>&&);
>     void isRegisteredAsRedirectingTo(const URL& hostRedirectedFrom, const URL& hostRedirectedTo, CompletionHandler<void(bool)>&&);
>+    void isRegisteredAsRedirectingTo(const String& hostRedirectedFrom, const String& hostRedirectedTo, CompletionHandler<void(bool)>&&);
>     void clearPrevalentResource(const URL&, CompletionHandler<void()>&&);
>-    void setGrandfathered(const URL&, bool);
>+    void clearPrevalentResource(const String&, CompletionHandler<void()>&&);
>+    void setGrandfathered(const URL&, bool, CompletionHandler<void()>&&);
>+    void setGrandfathered(const String&, bool, CompletionHandler<void()>&&);
>     void isGrandfathered(const URL&, CompletionHandler<void(bool)>&&);
>+    void isGrandfathered(const String&, CompletionHandler<void(bool)>&&);
>     void removeAllStorageAccess();
>     void removePrevalentDomains(const Vector<String>& domainsToBlock);
>     void setCacheMaxAgeCapForPrevalentResources(Seconds);
>-    void setSubframeUnderTopFrameOrigin(const URL& subframe, const URL& topFrame);
>-    void setSubresourceUnderTopFrameOrigin(const URL& subresource, const URL& topFrame);
>-    void setSubresourceUniqueRedirectTo(const URL& subresource, const URL& hostNameRedirectedTo);
>-    void setSubresourceUniqueRedirectFrom(const URL& subresource, const URL& hostNameRedirectedFrom);
>-    void setTopFrameUniqueRedirectTo(const URL& topFrameHostName, const URL& hostNameRedirectedTo);
>-    void setTopFrameUniqueRedirectFrom(const URL& topFrameHostName, const URL& hostNameRedirectedFrom);
>+    void setNotifyPagesWhenDataRecordsWereScanned(bool, CompletionHandler<void()>&&);
>+    void setSubframeUnderTopFrameOrigin(const URL& subframe, const URL& topFrame, CompletionHandler<void()>&&);
>+    void setSubframeUnderTopFrameOrigin(const String& subframe, const String& topFrame, CompletionHandler<void()>&&);
>+    void setSubresourceUnderTopFrameOrigin(const URL& subresource, const URL& topFrame, CompletionHandler<void()>&&);
>+    void setSubresourceUnderTopFrameOrigin(const String& subresource, const String& topFrame, CompletionHandler<void()>&&);
>+    void setSubresourceUniqueRedirectTo(const URL& subresource, const URL& hostNameRedirectedTo, CompletionHandler<void()>&&);
>+    void setSubresourceUniqueRedirectTo(const String& subresource, const String& hostNameRedirectedTo, CompletionHandler<void()>&&);
>+    void setSubresourceUniqueRedirectFrom(const URL& subresource, const URL& hostNameRedirectedFrom, CompletionHandler<void()>&&);
>+    void setSubresourceUniqueRedirectFrom(const String& subresource, const String& hostNameRedirectedFrom, CompletionHandler<void()>&&);
>+    void setTopFrameUniqueRedirectTo(const URL& topFrameHostName, const URL& hostNameRedirectedTo, CompletionHandler<void()>&&);
>+    void setTopFrameUniqueRedirectTo(const String& topFrameHostName, const String& hostNameRedirectedTo, CompletionHandler<void()>&&);
>+    void setTopFrameUniqueRedirectFrom(const URL& topFrameHostName, const URL& hostNameRedirectedFrom, CompletionHandler<void()>&&);
>+    void setTopFrameUniqueRedirectFrom(const String& topFrameHostName, const String& hostNameRedirectedFrom, CompletionHandler<void()>&&);
>     void scheduleCookieBlockingUpdate(CompletionHandler<void()>&&);
>     void scheduleCookieBlockingUpdateForDomains(const Vector<String>& domainsToBlock, CompletionHandler<void()>&&);
>     void scheduleClearBlockingStateForDomains(const Vector<String>& domains, CompletionHandler<void()>&&);
>-    void scheduleStatisticsAndDataRecordsProcessing();
>-    void submitTelemetry();
>+    void scheduleStatisticsAndDataRecordsProcessing(CompletionHandler<void()>&&);
>+    void submitTelemetry(CompletionHandler<void()>&&);
>     void updatePrevalentDomainsToBlockCookiesFor(const Vector<String>& domainsToBlock);
>-
>-    enum class ShouldGrandfather {
>-        No,
>-        Yes,
>-    };
>     void scheduleClearInMemoryAndPersistent(ShouldGrandfather, CompletionHandler<void()>&&);
>     void scheduleClearInMemoryAndPersistent(WallTime modifiedSince, ShouldGrandfather, CompletionHandler<void()>&&);
> 
>-    void setTimeToLiveUserInteraction(Seconds);
>-    void setMinimumTimeBetweenDataRecordsRemoval(Seconds);
>-    void setGrandfatheringTime(Seconds);
>+    void setTimeToLiveUserInteraction(Seconds, CompletionHandler<void()>&&);
>+    void setMinimumTimeBetweenDataRecordsRemoval(Seconds, CompletionHandler<void()>&&);
>+    void setGrandfatheringTime(Seconds, CompletionHandler<void()>&&);
>     void setCacheMaxAgeCap(Seconds, CompletionHandler<void()>&&);
>-    void setMaxStatisticsEntries(size_t);
>-    void setPruneEntriesDownTo(size_t);
>+    void setMaxStatisticsEntries(size_t, CompletionHandler<void()>&&);
>+    void setPruneEntriesDownTo(size_t, CompletionHandler<void()>&&);
> 
>     void resetParametersToDefaultValues(CompletionHandler<void()>&&);
> 
>     void setResourceLoadStatisticsDebugMode(bool, CompletionHandler<void()>&&);
>     void setPrevalentResourceForDebugMode(const URL&, CompletionHandler<void()>&&);
>-    
>-    void setStatisticsTestingCallback(WTF::Function<void(const String&)>&& callback) { m_statisticsTestingCallback = WTFMove(callback); }
>+    void setPrevalentResourceForDebugMode(const String& resourceDomain, CompletionHandler<void()>&&);
>+
>     void logTestingEvent(const String&);
>     void callGrantStorageAccessHandler(const String& subFramePrimaryDomain, const String& topFramePrimaryDomain, Optional<uint64_t> frameID, uint64_t pageID, CompletionHandler<void(bool)>&&);
>     void removeAllStorageAccess(CompletionHandler<void()>&&);
>@@ -153,9 +180,14 @@ public:
> 
>     void didCreateNetworkProcess();
> 
>+    void notifyResourceLoadStatisticsProcessed();
>+
>     WebsiteDataStore* websiteDataStore() { return m_websiteDataStore.get(); }
>     NetworkSession* networkSession() { return m_networkSession.get(); }
> 
>+    void sendDiagnosticMessageWithValue(const String& message, const String& description, unsigned value, unsigned sigDigits, WebCore::ShouldSample) const;
>+    void notifyPageStatisticsTelemetryFinished(unsigned totalPrevalentResources, unsigned totalPrevalentResourcesWithUserInteraction, unsigned top3SubframeUnderTopFrameOrigins) const;
>+
> private:
>     explicit WebResourceLoadStatisticsStore(WebsiteDataStore&);
>     explicit WebResourceLoadStatisticsStore(NetworkSession&, const String&);
>@@ -186,9 +218,9 @@ private:
> 
>     bool m_hasScheduledProcessStats { false };
> 
>-    WTF::Function<void(const String&)> m_statisticsTestingCallback;
>-
>     bool m_firstNetworkProcessCreated { false };
> };
> 
> } // namespace WebKit
>+
>+#endif
>diff --git a/Source/WebKit/NetworkProcess/Classifier/WebResourceLoadStatisticsTelemetry.cpp b/Source/WebKit/NetworkProcess/Classifier/WebResourceLoadStatisticsTelemetry.cpp
>index f9692e12912a6c1c098d3b9f60804ae2ff37df9a..da00eb8544a071f45497ea48dfe14f5333b14dd0 100644
>--- a/Source/WebKit/NetworkProcess/Classifier/WebResourceLoadStatisticsTelemetry.cpp
>+++ b/Source/WebKit/NetworkProcess/Classifier/WebResourceLoadStatisticsTelemetry.cpp
>@@ -26,7 +26,10 @@
> #include "config.h"
> #include "WebResourceLoadStatisticsTelemetry.h"
> 
>+#if ENABLE(RESOURCE_LOAD_STATISTICS)
>+
> #include "ResourceLoadStatisticsMemoryStore.h"
>+#include "WebPageProxy.h"
> #include "WebProcessPool.h"
> #include "WebProcessProxy.h"
> #include <WebCore/DiagnosticLoggingKeys.h>
>@@ -127,27 +130,7 @@ static unsigned median(const Vector<PrevalentResourceTelemetry>& v, unsigned beg
>     return median(part);
> }
>     
>-static WebPageProxy* nonEphemeralWebPageProxy()
>-{
>-    auto processPools = WebProcessPool::allProcessPools();
>-    if (processPools.isEmpty())
>-        return nullptr;
>-    
>-    auto processPool = processPools[0];
>-    if (!processPool)
>-        return nullptr;
>-    
>-    for (auto& webProcess : processPool->processes()) {
>-        for (auto& page : webProcess->pages()) {
>-            if (page->sessionID().isEphemeral())
>-                continue;
>-            return page;
>-        }
>-    }
>-    return nullptr;
>-}
>-    
>-static void submitTopList(unsigned numberOfResourcesFromTheTop, const Vector<PrevalentResourceTelemetry>& sortedPrevalentResources, const Vector<PrevalentResourceTelemetry>& sortedPrevalentResourcesWithoutUserInteraction, WebPageProxy& webPageProxy)
>+static void submitTopList(unsigned numberOfResourcesFromTheTop, const Vector<PrevalentResourceTelemetry>& sortedPrevalentResources, const Vector<PrevalentResourceTelemetry>& sortedPrevalentResourcesWithoutUserInteraction, const WebResourceLoadStatisticsStore& store)
> {
>     WTF::Function<unsigned(const PrevalentResourceTelemetry& telemetry)> subframeUnderTopFrameOriginsGetter = [] (auto& t) {
>         return t.subframeUnderTopFrameOrigins;
>@@ -181,63 +164,59 @@ static void submitTopList(unsigned numberOfResourcesFromTheTop, const Vector<Pre
>     preambleBuilder.appendNumber(numberOfResourcesFromTheTop);
>     String descriptionPreamble = preambleBuilder.toString();
>     
>-    webPageProxy.logDiagnosticMessageWithValue(DiagnosticLoggingKeys::resourceLoadStatisticsTelemetryKey(), descriptionPreamble + "PrevalentResourcesWithUserInteraction",
>+    store.sendDiagnosticMessageWithValue(DiagnosticLoggingKeys::resourceLoadStatisticsTelemetryKey(), descriptionPreamble + "PrevalentResourcesWithUserInteraction",
>         topPrevalentResourcesWithUserInteraction, significantFiguresForLoggedValues, ShouldSample::No);
>-    webPageProxy.logDiagnosticMessageWithValue(DiagnosticLoggingKeys::resourceLoadStatisticsTelemetryKey(), descriptionPreamble + "SubframeUnderTopFrameOrigins",
>+    store.sendDiagnosticMessageWithValue(DiagnosticLoggingKeys::resourceLoadStatisticsTelemetryKey(), descriptionPreamble + "SubframeUnderTopFrameOrigins",
>         topSubframeUnderTopFrameOrigins, significantFiguresForLoggedValues, ShouldSample::No);
>-    webPageProxy.logDiagnosticMessageWithValue(DiagnosticLoggingKeys::resourceLoadStatisticsTelemetryKey(), descriptionPreamble + "SubresourceUnderTopFrameOrigins",
>+    store.sendDiagnosticMessageWithValue(DiagnosticLoggingKeys::resourceLoadStatisticsTelemetryKey(), descriptionPreamble + "SubresourceUnderTopFrameOrigins",
>         topSubresourceUnderTopFrameOrigins, significantFiguresForLoggedValues, ShouldSample::No);
>-    webPageProxy.logDiagnosticMessageWithValue(DiagnosticLoggingKeys::resourceLoadStatisticsTelemetryKey(), descriptionPreamble + "SubresourceUniqueRedirectsTo",
>+    store.sendDiagnosticMessageWithValue(DiagnosticLoggingKeys::resourceLoadStatisticsTelemetryKey(), descriptionPreamble + "SubresourceUniqueRedirectsTo",
>         topSubresourceUniqueRedirectsTo, significantFiguresForLoggedValues, ShouldSample::No);
>-    webPageProxy.logDiagnosticMessageWithValue(DiagnosticLoggingKeys::resourceLoadStatisticsTelemetryKey(), descriptionPreamble + "NumberOfTimesDataRecordsRemoved",
>+    store.sendDiagnosticMessageWithValue(DiagnosticLoggingKeys::resourceLoadStatisticsTelemetryKey(), descriptionPreamble + "NumberOfTimesDataRecordsRemoved",
>         topNumberOfTimesDataRecordsRemoved, significantFiguresForLoggedValues, ShouldSample::No);
>-    webPageProxy.logDiagnosticMessageWithValue(DiagnosticLoggingKeys::resourceLoadStatisticsTelemetryKey(), descriptionPreamble + "NumberOfTimesAccessedAsFirstPartyDueToUserInteraction",
>+    store.sendDiagnosticMessageWithValue(DiagnosticLoggingKeys::resourceLoadStatisticsTelemetryKey(), descriptionPreamble + "NumberOfTimesAccessedAsFirstPartyDueToUserInteraction",
>         topNumberOfTimesAccessedAsFirstPartyDueToUserInteraction, significantFiguresForLoggedValues, ShouldSample::No);
>-    webPageProxy.logDiagnosticMessageWithValue(DiagnosticLoggingKeys::resourceLoadStatisticsTelemetryKey(), descriptionPreamble + "NumberOfTimesAccessedAsFirstPartyDueToStorageAccessAPI",
>+    store.sendDiagnosticMessageWithValue(DiagnosticLoggingKeys::resourceLoadStatisticsTelemetryKey(), descriptionPreamble + "NumberOfTimesAccessedAsFirstPartyDueToStorageAccessAPI",
>         topNumberOfTimesAccessedAsFirstPartyDueToStorageAccessAPI, significantFiguresForLoggedValues, ShouldSample::No);
> }
>     
>-static void submitTopLists(const Vector<PrevalentResourceTelemetry>& sortedPrevalentResources, const Vector<PrevalentResourceTelemetry>& sortedPrevalentResourcesWithoutUserInteraction, WebPageProxy& webPageProxy)
>+static void submitTopLists(const Vector<PrevalentResourceTelemetry>& sortedPrevalentResources, const Vector<PrevalentResourceTelemetry>& sortedPrevalentResourcesWithoutUserInteraction, const WebResourceLoadStatisticsStore& store)
> {
>-    submitTopList(1, sortedPrevalentResources, sortedPrevalentResourcesWithoutUserInteraction, webPageProxy);
>+    submitTopList(1, sortedPrevalentResources, sortedPrevalentResourcesWithoutUserInteraction, store);
>     
>     if (sortedPrevalentResourcesWithoutUserInteraction.size() < 3)
>         return;
>-    submitTopList(3, sortedPrevalentResources, sortedPrevalentResourcesWithoutUserInteraction, webPageProxy);
>+    submitTopList(3, sortedPrevalentResources, sortedPrevalentResourcesWithoutUserInteraction, store);
>     
>     if (sortedPrevalentResourcesWithoutUserInteraction.size() < 10)
>         return;
>-    submitTopList(10, sortedPrevalentResources, sortedPrevalentResourcesWithoutUserInteraction, webPageProxy);
>+    submitTopList(10, sortedPrevalentResources, sortedPrevalentResourcesWithoutUserInteraction, store);
>     
>     if (sortedPrevalentResourcesWithoutUserInteraction.size() < 50)
>         return;
>-    submitTopList(50, sortedPrevalentResources, sortedPrevalentResourcesWithoutUserInteraction, webPageProxy);
>+    submitTopList(50, sortedPrevalentResources, sortedPrevalentResourcesWithoutUserInteraction, store);
>     
>     if (sortedPrevalentResourcesWithoutUserInteraction.size() < 100)
>         return;
>-    submitTopList(100, sortedPrevalentResources, sortedPrevalentResourcesWithoutUserInteraction, webPageProxy);
>+    submitTopList(100, sortedPrevalentResources, sortedPrevalentResourcesWithoutUserInteraction, store);
> }
>     
> // This function is for testing purposes.
>-void static notifyPages(unsigned totalPrevalentResources, unsigned totalPrevalentResourcesWithUserInteraction, unsigned top3SubframeUnderTopFrameOrigins)
>+void static notifyPages(unsigned totalPrevalentResources, unsigned totalPrevalentResourcesWithUserInteraction, unsigned top3SubframeUnderTopFrameOrigins, const WebResourceLoadStatisticsStore& store)
> {
>-    RunLoop::main().dispatch([totalPrevalentResources, totalPrevalentResourcesWithUserInteraction, top3SubframeUnderTopFrameOrigins] {
>-        API::Dictionary::MapType messageBody;
>-        messageBody.set("TotalPrevalentResources"_s, API::UInt64::create(totalPrevalentResources));
>-        messageBody.set("TotalPrevalentResourcesWithUserInteraction"_s, API::UInt64::create(totalPrevalentResourcesWithUserInteraction));
>-        messageBody.set("Top3SubframeUnderTopFrameOrigins"_s, API::UInt64::create(top3SubframeUnderTopFrameOrigins));
>-        WebProcessProxy::notifyPageStatisticsTelemetryFinished(API::Dictionary::create(messageBody).ptr());
>+    RunLoop::main().dispatch([totalPrevalentResources, totalPrevalentResourcesWithUserInteraction, top3SubframeUnderTopFrameOrigins, store = makeRef(store)] {
>+        store->notifyPageStatisticsTelemetryFinished(totalPrevalentResources, totalPrevalentResourcesWithUserInteraction, top3SubframeUnderTopFrameOrigins);
>     });
> }
>     
> // This function is for testing purposes.
>-void static notifyPages(const Vector<PrevalentResourceTelemetry>& sortedPrevalentResources, const Vector<PrevalentResourceTelemetry>& sortedPrevalentResourcesWithoutUserInteraction, unsigned totalNumberOfPrevalentResourcesWithUserInteraction)
>+void static notifyPages(const Vector<PrevalentResourceTelemetry>& sortedPrevalentResources, const Vector<PrevalentResourceTelemetry>& sortedPrevalentResourcesWithoutUserInteraction, unsigned totalNumberOfPrevalentResourcesWithUserInteraction, const WebResourceLoadStatisticsStore& store)
> {
>     WTF::Function<unsigned(const PrevalentResourceTelemetry& telemetry)> subframeUnderTopFrameOriginsGetter = [] (const PrevalentResourceTelemetry& t) {
>         return t.subframeUnderTopFrameOrigins;
>     };
>     
>-    notifyPages(sortedPrevalentResources.size(), totalNumberOfPrevalentResourcesWithUserInteraction, median(sortedPrevalentResourcesWithoutUserInteraction, 0, 2, subframeUnderTopFrameOriginsGetter));
>+    notifyPages(sortedPrevalentResources.size(), totalNumberOfPrevalentResourcesWithUserInteraction, median(sortedPrevalentResourcesWithoutUserInteraction, 0, 2, subframeUnderTopFrameOriginsGetter), store);
> }
>     
> void WebResourceLoadStatisticsTelemetry::calculateAndSubmit(const ResourceLoadStatisticsMemoryStore& resourceLoadStatisticsStore)
>@@ -246,7 +225,7 @@ void WebResourceLoadStatisticsTelemetry::calculateAndSubmit(const ResourceLoadSt
>     
>     auto sortedPrevalentResources = sortedPrevalentResourceTelemetry(resourceLoadStatisticsStore);
>     if (notifyPagesWhenTelemetryWasCaptured && sortedPrevalentResources.isEmpty()) {
>-        notifyPages(0, 0, 0);
>+        notifyPages(0, 0, 0, resourceLoadStatisticsStore.store());
>         return;
>     }
>     
>@@ -262,16 +241,16 @@ void WebResourceLoadStatisticsTelemetry::calculateAndSubmit(const ResourceLoadSt
>     }
>     
>     // Dispatch on the main thread to make sure the WebPageProxy we're using doesn't go away.
>-    RunLoop::main().dispatch([sortedPrevalentResources = WTFMove(sortedPrevalentResources), sortedPrevalentResourcesWithoutUserInteraction = WTFMove(sortedPrevalentResourcesWithoutUserInteraction), prevalentResourcesDaysSinceUserInteraction = WTFMove(prevalentResourcesDaysSinceUserInteraction)] () {
>-        auto webPageProxy = nonEphemeralWebPageProxy();
>+    RunLoop::main().dispatch([sortedPrevalentResources = WTFMove(sortedPrevalentResources), sortedPrevalentResourcesWithoutUserInteraction = WTFMove(sortedPrevalentResourcesWithoutUserInteraction), prevalentResourcesDaysSinceUserInteraction = WTFMove(prevalentResourcesDaysSinceUserInteraction), &resourceLoadStatisticsStore] () {
>+        auto webPageProxy = WebPageProxy::nonEphemeralWebPageProxy();
>         if (!webPageProxy) {
>             if (notifyPagesWhenTelemetryWasCaptured)
>-                notifyPages(0, 0, 0);
>+                notifyPages(0, 0, 0, resourceLoadStatisticsStore.store());
>             return;
>         }
>         
>         if (notifyPagesWhenTelemetryWasCaptured) {
>-            notifyPages(sortedPrevalentResources, sortedPrevalentResourcesWithoutUserInteraction, prevalentResourcesDaysSinceUserInteraction.size());
>+            notifyPages(sortedPrevalentResources, sortedPrevalentResourcesWithoutUserInteraction, prevalentResourcesDaysSinceUserInteraction.size(), resourceLoadStatisticsStore.store());
>             // The notify pages function is for testing so we don't need to do an actual submission.
>             return;
>         }
>@@ -284,7 +263,7 @@ void WebResourceLoadStatisticsTelemetry::calculateAndSubmit(const ResourceLoadSt
>         if (prevalentResourcesDaysSinceUserInteraction.size() > 1)
>             webPageProxy->logDiagnosticMessageWithValue(DiagnosticLoggingKeys::resourceLoadStatisticsTelemetryKey(), "medianPrevalentResourcesWithUserInteractionDaysSinceUserInteraction"_s, median(prevalentResourcesDaysSinceUserInteraction), significantFiguresForLoggedValues, ShouldSample::No);
>         
>-        submitTopLists(sortedPrevalentResources, sortedPrevalentResourcesWithoutUserInteraction, *webPageProxy);
>+        submitTopLists(sortedPrevalentResources, sortedPrevalentResourcesWithoutUserInteraction, resourceLoadStatisticsStore.store());
>     });
> }
>     
>@@ -294,3 +273,5 @@ void WebResourceLoadStatisticsTelemetry::setNotifyPagesWhenTelemetryWasCaptured(
> }
>     
> }
>+
>+#endif
>diff --git a/Source/WebKit/NetworkProcess/Classifier/WebResourceLoadStatisticsTelemetry.h b/Source/WebKit/NetworkProcess/Classifier/WebResourceLoadStatisticsTelemetry.h
>index f96e61a1af0ab7353b031db753f9ddb6f52c629b..b92d821f262182b6a2b268dc4b3fe2a886694d99 100644
>--- a/Source/WebKit/NetworkProcess/Classifier/WebResourceLoadStatisticsTelemetry.h
>+++ b/Source/WebKit/NetworkProcess/Classifier/WebResourceLoadStatisticsTelemetry.h
>@@ -25,6 +25,8 @@
> 
> #pragma once
> 
>+#if ENABLE(RESOURCE_LOAD_STATISTICS)
>+
> #include <wtf/text/WTFString.h>
> 
> namespace WebKit {
>@@ -38,3 +40,5 @@ void setNotifyPagesWhenTelemetryWasCaptured(bool);
>     
> }
> }
>+
>+#endif
>diff --git a/Source/WebKit/NetworkProcess/NetworkConnectionToWebProcess.cpp b/Source/WebKit/NetworkProcess/NetworkConnectionToWebProcess.cpp
>index 6413203565bf414307bbb83d54795249e32ec9b8..0666b1e465f930ccdc26a960cd6751f7ae34f74e 100644
>--- a/Source/WebKit/NetworkProcess/NetworkConnectionToWebProcess.cpp
>+++ b/Source/WebKit/NetworkProcess/NetworkConnectionToWebProcess.cpp
>@@ -1,5 +1,5 @@
> /*
>- * Copyright (C) 2012-2018 Apple Inc. All rights reserved.
>+ * Copyright (C) 2012-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
>@@ -49,6 +49,7 @@
> #include "WebErrors.h"
> #include "WebIDBConnectionToClient.h"
> #include "WebIDBConnectionToClientMessages.h"
>+#include "WebResourceLoadStatisticsStore.h"
> #include "WebSWServerConnection.h"
> #include "WebSWServerConnectionMessages.h"
> #include "WebSWServerToContextConnection.h"
>@@ -581,6 +582,19 @@ void NetworkConnectionToWebProcess::removeStorageAccessForAllFramesOnPage(PAL::S
> #endif
> }
> 
>+void NetworkConnectionToWebProcess::logUserInteraction(PAL::SessionID sessionID, const String& topLevelOrigin)
>+{
>+#if ENABLE(RESOURCE_LOAD_STATISTICS)
>+    if (auto networkSession = networkProcess().networkSession(sessionID)) {
>+        if (auto* resourceLoadStatistics = networkSession->resourceLoadStatistics())
>+            resourceLoadStatistics->logUserInteraction(topLevelOrigin, [] { });
>+    }
>+#else
>+    UNUSED_PARAM(sessionID);
>+    UNUSED_PARAM(topLevelOrigin);
>+#endif
>+}
>+
> void NetworkConnectionToWebProcess::addOriginAccessWhitelistEntry(const String& sourceOrigin, const String& destinationProtocol, const String& destinationHost, bool allowDestinationSubdomains)
> {
>     SecurityPolicy::addOriginAccessWhitelistEntry(SecurityOrigin::createFromString(sourceOrigin).get(), destinationProtocol, destinationHost, allowDestinationSubdomains);
>diff --git a/Source/WebKit/NetworkProcess/NetworkConnectionToWebProcess.h b/Source/WebKit/NetworkProcess/NetworkConnectionToWebProcess.h
>index e6119b17df9e62bb3138dad509b27fd03046e5b0..088de8fded14754838dfaa9d827f7e57e9291a88 100644
>--- a/Source/WebKit/NetworkProcess/NetworkConnectionToWebProcess.h
>+++ b/Source/WebKit/NetworkProcess/NetworkConnectionToWebProcess.h
>@@ -1,5 +1,5 @@
> /*
>- * Copyright (C) 2012-2017 Apple Inc. All rights reserved.
>+ * Copyright (C) 2012-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
>@@ -194,6 +194,7 @@ private:
> 
>     void removeStorageAccessForFrame(PAL::SessionID, uint64_t frameID, uint64_t pageID);
>     void removeStorageAccessForAllFramesOnPage(PAL::SessionID, uint64_t pageID);
>+    void logUserInteraction(PAL::SessionID, const String& topLevelOrigin);
> 
>     void addOriginAccessWhitelistEntry(const String& sourceOrigin, const String& destinationProtocol, const String& destinationHost, bool allowDestinationSubdomains);
>     void removeOriginAccessWhitelistEntry(const String& sourceOrigin, const String& destinationProtocol, const String& destinationHost, bool allowDestinationSubdomains);
>diff --git a/Source/WebKit/NetworkProcess/NetworkConnectionToWebProcess.messages.in b/Source/WebKit/NetworkProcess/NetworkConnectionToWebProcess.messages.in
>index 932b9345202357d0f632a0915b51094c711fe55f..f245bca7dc6b2c71a79cc8a39059e9d14435df60 100644
>--- a/Source/WebKit/NetworkProcess/NetworkConnectionToWebProcess.messages.in
>+++ b/Source/WebKit/NetworkProcess/NetworkConnectionToWebProcess.messages.in
>@@ -58,6 +58,9 @@ messages -> NetworkConnectionToWebProcess LegacyReceiver {
> 
>     RemoveStorageAccessForFrame(PAL::SessionID sessionID, uint64_t frameID, uint64_t pageID);
>     RemoveStorageAccessForAllFramesOnPage(PAL::SessionID sessionID, uint64_t pageID);
>+#if ENABLE(RESOURCE_LOAD_STATISTICS)
>+    LogUserInteraction(PAL::SessionID sessionID, String topLevelOrigin)
>+#endif
> 
>     AddOriginAccessWhitelistEntry(String sourceOrigin, String destinationProtocol, String destinationHost, bool allowDestinationSubdomains);
>     RemoveOriginAccessWhitelistEntry(String sourceOrigin, String destinationProtocol, String destinationHost, bool allowDestinationSubdomains);
>diff --git a/Source/WebKit/NetworkProcess/NetworkProcess.cpp b/Source/WebKit/NetworkProcess/NetworkProcess.cpp
>index 1900efe0540855dc529225226e171addf1d0d68e..2a98b304a13c6c69c4a4075fce05811e1176fa1e 100644
>--- a/Source/WebKit/NetworkProcess/NetworkProcess.cpp
>+++ b/Source/WebKit/NetworkProcess/NetworkProcess.cpp
>@@ -1,5 +1,5 @@
> /*
>- * Copyright (C) 2012-2018 Apple Inc. All rights reserved.
>+ * Copyright (C) 2012-2019 Apple Inc. All rights reserved.
>  * Copyright (C) 2018 Sony Interactive Entertainment Inc.
>  *
>  * Redistribution and use in source and binary forms, with or without
>@@ -497,6 +497,18 @@ void NetworkProcess::writeBlobToFilePath(const URL& url, const String& path, San
> }
> 
> #if ENABLE(RESOURCE_LOAD_STATISTICS)
>+void NetworkProcess::dumpResourceLoadStatistics(PAL::SessionID sessionID, uint64_t contextId)
>+{
>+    if (auto* networkSession = this->networkSession(sessionID)) {
>+        if (auto* resourceLoadStatistics = networkSession->resourceLoadStatistics()) {
>+            resourceLoadStatistics->dumpResourceLoadStatistics([this, contextId](const String& dumpedStatistics) {
>+                parentProcessConnection()->send(Messages::NetworkProcessProxy::DidDumpResourceLoadStatistics(dumpedStatistics, contextId), 0);
>+            });
>+        }
>+    } else
>+        ASSERT_NOT_REACHED();
>+}
>+
> void NetworkProcess::updatePrevalentDomainsToBlockCookiesFor(PAL::SessionID sessionID, const Vector<String>& domainsToBlock, uint64_t contextId)
> {
>     if (auto* networkStorageSession = NetworkStorageSession::storageSession(sessionID))
>@@ -504,6 +516,33 @@ void NetworkProcess::updatePrevalentDomainsToBlockCookiesFor(PAL::SessionID sess
>     parentProcessConnection()->send(Messages::NetworkProcessProxy::DidUpdateBlockCookies(contextId), 0);
> }
> 
>+void NetworkProcess::isGrandfathered(PAL::SessionID sessionID, const String& targetPrimaryDomain, CompletionHandler<void(bool)>&& completionHandler)
>+{
>+    if (auto* networkSession = this->networkSession(sessionID)) {
>+        if (auto* resourceLoadStatistics = networkSession->resourceLoadStatistics())
>+            resourceLoadStatistics->isGrandfathered(targetPrimaryDomain, WTFMove(completionHandler));
>+    } else
>+        ASSERT_NOT_REACHED();
>+}
>+
>+void NetworkProcess::isPrevalentResource(PAL::SessionID sessionID, const String& resourceDomain, CompletionHandler<void(bool)>&& completionHandler)
>+{
>+    if (auto* networkSession = this->networkSession(sessionID)) {
>+        if (auto* resourceLoadStatistics = networkSession->resourceLoadStatistics())
>+            resourceLoadStatistics->isPrevalentResource(resourceDomain, WTFMove(completionHandler));
>+    } else
>+        ASSERT_NOT_REACHED();
>+}
>+
>+void NetworkProcess::isVeryPrevalentResource(PAL::SessionID sessionID, const String& resourceDomain, CompletionHandler<void(bool)>&& completionHandler)
>+{
>+    if (auto* networkSession = this->networkSession(sessionID)) {
>+        if (auto* resourceLoadStatistics = networkSession->resourceLoadStatistics())
>+            resourceLoadStatistics->isVeryPrevalentResource(resourceDomain, WTFMove(completionHandler));
>+    } else
>+        ASSERT_NOT_REACHED();
>+}
>+
> void NetworkProcess::setAgeCapForClientSideCookies(PAL::SessionID sessionID, Optional<Seconds> seconds, uint64_t contextId)
> {
>     if (auto* networkStorageSession = NetworkStorageSession::storageSession(sessionID))
>@@ -511,10 +550,214 @@ void NetworkProcess::setAgeCapForClientSideCookies(PAL::SessionID sessionID, Opt
>     parentProcessConnection()->send(Messages::NetworkProcessProxy::DidSetAgeCapForClientSideCookies(contextId), 0);
> }
> 
>+void NetworkProcess::setGrandfathered(PAL::SessionID sessionID, const String& resourceDomain, bool isGrandfathered, CompletionHandler<void()>&& completionHandler)
>+{
>+    if (auto* networkSession = this->networkSession(sessionID)) {
>+        if (auto* resourceLoadStatistics = networkSession->resourceLoadStatistics())
>+            resourceLoadStatistics->setGrandfathered(resourceDomain, isGrandfathered, WTFMove(completionHandler));
>+    } else
>+        ASSERT_NOT_REACHED();
>+}
>+
>+void NetworkProcess::setPrevalentResource(PAL::SessionID sessionID, const String& resourceDomain, CompletionHandler<void()>&& completionHandler)
>+{
>+    if (auto* networkSession = this->networkSession(sessionID)) {
>+        if (auto* resourceLoadStatistics = networkSession->resourceLoadStatistics())
>+            resourceLoadStatistics->setPrevalentResource(resourceDomain, WTFMove(completionHandler));
>+    } else
>+        ASSERT_NOT_REACHED();
>+}
>+
>+void NetworkProcess::setPrevalentResourceForDebugMode(PAL::SessionID sessionID, String resourceDomain, CompletionHandler<void()>&& completionHandler)
>+{
>+    if (auto* networkSession = this->networkSession(sessionID)) {
>+        if (auto* resourceLoadStatistics = networkSession->resourceLoadStatistics())
>+            resourceLoadStatistics->setPrevalentResourceForDebugMode(resourceDomain, WTFMove(completionHandler));
>+    } else
>+        ASSERT_NOT_REACHED();
>+}
>+
>+void NetworkProcess::setVeryPrevalentResource(PAL::SessionID sessionID, const String& resourceDomain, CompletionHandler<void()>&& completionHandler)
>+{
>+    if (auto* networkSession = this->networkSession(sessionID)) {
>+        if (auto* resourceLoadStatistics = networkSession->resourceLoadStatistics())
>+            resourceLoadStatistics->setVeryPrevalentResource(resourceDomain, WTFMove(completionHandler));
>+    } else
>+        ASSERT_NOT_REACHED();
>+}
>+
>+void NetworkProcess::clearPrevalentResource(PAL::SessionID sessionID, const String& resourceDomain, CompletionHandler<void()>&& completionHandler)
>+{
>+    if (auto* networkSession = this->networkSession(sessionID)) {
>+        if (auto* resourceLoadStatistics = networkSession->resourceLoadStatistics())
>+            resourceLoadStatistics->clearPrevalentResource(resourceDomain, WTFMove(completionHandler));
>+    } else
>+        ASSERT_NOT_REACHED();
>+}
>+
>+void NetworkProcess::submitTelemetry(PAL::SessionID sessionID, CompletionHandler<void()>&& completionHandler)
>+{
>+    if (auto* networkSession = this->networkSession(sessionID)) {
>+        if (auto* resourceLoadStatistics = networkSession->resourceLoadStatistics())
>+            resourceLoadStatistics->submitTelemetry(WTFMove(completionHandler));
>+    } else
>+        ASSERT_NOT_REACHED();
>+}
>+
>+void NetworkProcess::scheduleCookieBlockingUpdate(PAL::SessionID sessionID, CompletionHandler<void()>&& completionHandler)
>+{
>+    if (auto* networkSession = this->networkSession(sessionID)) {
>+        if (auto* resourceLoadStatistics = networkSession->resourceLoadStatistics())
>+            resourceLoadStatistics->scheduleCookieBlockingUpdate(WTFMove(completionHandler));
>+    } else
>+        ASSERT_NOT_REACHED();
>+}
>+
>+void NetworkProcess::scheduleClearInMemoryAndPersistent(PAL::SessionID sessionID, Optional<WallTime> modifiedSince, bool shouldGrandfather, CompletionHandler<void()>&& completionHandler)
>+{
>+    if (auto* networkSession = this->networkSession(sessionID)) {
>+        if (auto* resourceLoadStatistics = networkSession->resourceLoadStatistics()) {
>+            auto grandfather = shouldGrandfather ? ShouldGrandfather::Yes : ShouldGrandfather::No;
>+            if (modifiedSince)
>+                resourceLoadStatistics->scheduleClearInMemoryAndPersistent(modifiedSince.value(), grandfather, WTFMove(completionHandler));
>+            else
>+                resourceLoadStatistics->scheduleClearInMemoryAndPersistent(grandfather, WTFMove(completionHandler));
>+        }
>+    } else
>+        ASSERT_NOT_REACHED();
>+}
>+
>+void NetworkProcess::resetParametersToDefaultValues(PAL::SessionID sessionID, CompletionHandler<void()>&& completionHandler)
>+{
>+    if (auto* networkSession = this->networkSession(sessionID)) {
>+        if (auto* resourceLoadStatistics = networkSession->resourceLoadStatistics())
>+            resourceLoadStatistics->resetParametersToDefaultValues(WTFMove(completionHandler));
>+    } else
>+        ASSERT_NOT_REACHED();
>+}
>+
>+void NetworkProcess::scheduleStatisticsAndDataRecordsProcessing(PAL::SessionID sessionID, CompletionHandler<void()>&& completionHandler)
>+{
>+    if (auto* networkSession = this->networkSession(sessionID)) {
>+        if (auto* resourceLoadStatistics = networkSession->resourceLoadStatistics())
>+            resourceLoadStatistics->scheduleStatisticsAndDataRecordsProcessing(WTFMove(completionHandler));
>+    } else
>+        ASSERT_NOT_REACHED();
>+}
>+
>+void NetworkProcess::setNotifyPagesWhenDataRecordsWereScanned(PAL::SessionID sessionID, bool value, CompletionHandler<void()>&& completionHandler)
>+{
>+    if (auto* networkSession = this->networkSession(sessionID)) {
>+        if (auto* resourceLoadStatistics = networkSession->resourceLoadStatistics())
>+            resourceLoadStatistics->setNotifyPagesWhenDataRecordsWereScanned(value, WTFMove(completionHandler));
>+    } else
>+        ASSERT_NOT_REACHED();
>+}
>+
>+void NetworkProcess::setNotifyPagesWhenTelemetryWasCaptured(PAL::SessionID sessionID, bool value, CompletionHandler<void()>&& completionHandler)
>+{
>+    if (auto* networkSession = this->networkSession(sessionID)) {
>+        if (auto* resourceLoadStatistics = networkSession->resourceLoadStatistics())
>+            resourceLoadStatistics->setNotifyPagesWhenTelemetryWasCaptured(value, WTFMove(completionHandler));
>+    } else
>+        ASSERT_NOT_REACHED();
>+}
>+
>+void NetworkProcess::setSubframeUnderTopFrameOrigin(PAL::SessionID sessionID, String subframe, String topFrame, CompletionHandler<void()>&& completionHandler)
>+{
>+    if (auto* networkSession = this->networkSession(sessionID)) {
>+        if (auto* resourceLoadStatistics = networkSession->resourceLoadStatistics())
>+            resourceLoadStatistics->setSubframeUnderTopFrameOrigin(subframe, topFrame, WTFMove(completionHandler));
>+    } else
>+        ASSERT_NOT_REACHED();
>+}
>+
>+void NetworkProcess::isRegisteredAsRedirectingTo(PAL::SessionID sessionID, const String& redirectedFrom, const String& redirectedTo, CompletionHandler<void(bool)>&& completionHandler)
>+{
>+    if (auto* networkSession = this->networkSession(sessionID)) {
>+        if (auto* resourceLoadStatistics = networkSession->resourceLoadStatistics())
>+            resourceLoadStatistics->isRegisteredAsRedirectingTo(redirectedFrom, redirectedTo, WTFMove(completionHandler));
>+    } else
>+        ASSERT_NOT_REACHED();
>+}
>+
>+void NetworkProcess::isRegisteredAsSubFrameUnder(PAL::SessionID sessionID, const String& subframe, const String& topFrame, CompletionHandler<void(bool)>&& completionHandler)
>+{
>+    if (auto* networkSession = this->networkSession(sessionID)) {
>+        if (auto* resourceLoadStatistics = networkSession->resourceLoadStatistics())
>+            resourceLoadStatistics->isRegisteredAsSubFrameUnder(subframe, topFrame, WTFMove(completionHandler));
>+    } else
>+        ASSERT_NOT_REACHED();
>+}
>+
>+void NetworkProcess::setSubresourceUnderTopFrameOrigin(PAL::SessionID sessionID, String subresource, String topFrame, CompletionHandler<void()>&& completionHandler)
>+{
>+    if (auto* networkSession = this->networkSession(sessionID)) {
>+        if (auto* resourceLoadStatistics = networkSession->resourceLoadStatistics())
>+            resourceLoadStatistics->setSubresourceUnderTopFrameOrigin(subresource, topFrame, WTFMove(completionHandler));
>+    } else
>+        ASSERT_NOT_REACHED();
>+}
>+
>+void NetworkProcess::setSubresourceUniqueRedirectTo(PAL::SessionID sessionID, String subresource, String hostNameRedirectedTo, CompletionHandler<void()>&& completionHandler)
>+{
>+    if (auto* networkSession = this->networkSession(sessionID)) {
>+        if (auto* resourceLoadStatistics = networkSession->resourceLoadStatistics())
>+            resourceLoadStatistics->setSubresourceUniqueRedirectTo(subresource, hostNameRedirectedTo, WTFMove(completionHandler));
>+    } else
>+        ASSERT_NOT_REACHED();
>+}
>+
>+void NetworkProcess::setSubresourceUniqueRedirectFrom(PAL::SessionID sessionID, String subresource, String hostNameRedirectedFrom, CompletionHandler<void()>&& completionHandler)
>+{
>+    if (auto* networkSession = this->networkSession(sessionID)) {
>+        if (auto* resourceLoadStatistics = networkSession->resourceLoadStatistics())
>+            resourceLoadStatistics->setSubresourceUniqueRedirectFrom(subresource, hostNameRedirectedFrom, WTFMove(completionHandler));
>+    } else
>+        ASSERT_NOT_REACHED();
>+}
>+
>+void NetworkProcess::isRegisteredAsSubresourceUnder(PAL::SessionID sessionID, const String& subresource, const String& topFrame, CompletionHandler<void(bool)>&& completionHandler)
>+{
>+    if (auto* networkSession = this->networkSession(sessionID)) {
>+        if (auto* resourceLoadStatistics = networkSession->resourceLoadStatistics())
>+            resourceLoadStatistics->isRegisteredAsSubresourceUnder(subresource, topFrame, WTFMove(completionHandler));
>+    } else
>+        ASSERT_NOT_REACHED();
>+}
>+
>+void NetworkProcess::setTopFrameUniqueRedirectTo(PAL::SessionID sessionID, String topFrameHostName, String hostNameRedirectedTo, CompletionHandler<void()>&& completionHandler)
>+{
>+    if (auto* networkSession = this->networkSession(sessionID)) {
>+        if (auto* resourceLoadStatistics = networkSession->resourceLoadStatistics())
>+            resourceLoadStatistics->setTopFrameUniqueRedirectTo(topFrameHostName, hostNameRedirectedTo, WTFMove(completionHandler));
>+    } else
>+        ASSERT_NOT_REACHED();
>+}
>+
>+void NetworkProcess::setTopFrameUniqueRedirectFrom(PAL::SessionID sessionID, String topFrameHostName, String hostNameRedirectedFrom, CompletionHandler<void()>&& completionHandler)
>+{
>+    if (auto* networkSession = this->networkSession(sessionID)) {
>+        if (auto* resourceLoadStatistics = networkSession->resourceLoadStatistics())
>+            resourceLoadStatistics->setTopFrameUniqueRedirectFrom(topFrameHostName, hostNameRedirectedFrom, WTFMove(completionHandler));
>+    } else
>+        ASSERT_NOT_REACHED();
>+}
>+    
>+    
>+void NetworkProcess::setLastSeen(PAL::SessionID sessionID, const String& resourceDomain, Seconds seconds, CompletionHandler<void()>&& completionHandler)
>+{
>+    if (auto* networkSession = this->networkSession(sessionID)) {
>+        if (auto* resourceLoadStatistics = networkSession->resourceLoadStatistics())
>+            resourceLoadStatistics->setLastSeen(resourceDomain, seconds, WTFMove(completionHandler));
>+    } else
>+        ASSERT_NOT_REACHED();
>+}
>+
> void NetworkProcess::hasStorageAccessForFrame(PAL::SessionID sessionID, const String& resourceDomain, const String& firstPartyDomain, uint64_t frameID, uint64_t pageID, uint64_t contextId)
> {
>     if (auto* networkStorageSession = NetworkStorageSession::storageSession(sessionID))
>-        parentProcessConnection()->send(Messages::NetworkProcessProxy::StorageAccessRequestResult(networkStorageSession->hasStorageAccess(resourceDomain, firstPartyDomain, frameID, pageID), contextId), 0);
>+        parentProcessConnection()->send(Messages::NetworkProcessProxy::StorageAccessOperationResult(networkStorageSession->hasStorageAccess(resourceDomain, firstPartyDomain, frameID, pageID), contextId), 0);
>     else
>         ASSERT_NOT_REACHED();
> }
>@@ -527,7 +770,28 @@ void NetworkProcess::getAllStorageAccessEntries(PAL::SessionID sessionID, uint64
>         ASSERT_NOT_REACHED();
> }
> 
>-void NetworkProcess::grantStorageAccess(PAL::SessionID sessionID, const String& resourceDomain, const String& firstPartyDomain, Optional<uint64_t> frameID, uint64_t pageID, uint64_t contextId)
>+void NetworkProcess::hasStorageAccess(PAL::SessionID sessionID, const String& resourceDomain, const String& firstPartyDomain, Optional<uint64_t> frameID, uint64_t pageID, CompletionHandler<void(bool)>&& completionHandler)
>+{
>+    if (auto* networkSession = this->networkSession(sessionID)) {
>+        if (auto* resourceLoadStatistics = networkSession->resourceLoadStatistics())
>+            resourceLoadStatistics->hasStorageAccess(resourceDomain, firstPartyDomain, frameID, pageID, WTFMove(completionHandler));
>+    } else
>+        ASSERT_NOT_REACHED();
>+}
>+
>+void NetworkProcess::requestStorageAccess(PAL::SessionID sessionID, const String& resourceDomain, const String& firstPartyDomain, Optional<uint64_t> frameID, uint64_t pageID, bool promptEnabled, uint64_t contextId)
>+{
>+    if (auto* networkSession = this->networkSession(sessionID)) {
>+        if (auto* resourceLoadStatistics = networkSession->resourceLoadStatistics()) {
>+            resourceLoadStatistics->requestStorageAccess(resourceDomain, firstPartyDomain, frameID, pageID, promptEnabled, [this, contextId](StorageAccessStatus promptAccepted) {
>+                parentProcessConnection()->send(Messages::NetworkProcessProxy::StorageAccessRequestResult(static_cast<unsigned>(promptAccepted), contextId), 0);
>+            });
>+        }
>+    } else
>+        ASSERT_NOT_REACHED();
>+}
>+
>+void NetworkProcess::grantStorageAccess(PAL::SessionID sessionID, const String& resourceDomain, const String& firstPartyDomain, Optional<uint64_t> frameID, uint64_t pageID, bool userWasPrompted, uint64_t contextId)
> {
>     bool isStorageGranted = false;
>     if (auto* networkStorageSession = NetworkStorageSession::storageSession(sessionID)) {
>@@ -537,7 +801,7 @@ void NetworkProcess::grantStorageAccess(PAL::SessionID sessionID, const String&
>     } else
>         ASSERT_NOT_REACHED();
> 
>-    parentProcessConnection()->send(Messages::NetworkProcessProxy::StorageAccessRequestResult(isStorageGranted, contextId), 0);
>+    parentProcessConnection()->send(Messages::NetworkProcessProxy::StorageAccessOperationResult(isStorageGranted, contextId), 0);
> }
> 
> void NetworkProcess::logFrameNavigation(PAL::SessionID sessionID, const String& targetPrimaryDomain, const String& mainFramePrimaryDomain, const String& sourcePrimaryDomain, const String& targetHost, const String& mainFrameHost, bool isRedirect, bool isMainFrame)
>@@ -549,18 +813,34 @@ void NetworkProcess::logFrameNavigation(PAL::SessionID sessionID, const String&
>         ASSERT_NOT_REACHED();
> }
> 
>-void NetworkProcess::logUserInteraction(PAL::SessionID sessionID, const String& targetPrimaryDomain, uint64_t contextId)
>+void NetworkProcess::logUserInteraction(PAL::SessionID sessionID, const String& targetPrimaryDomain, CompletionHandler<void()>&& completionHandler)
>+{
>+    if (auto* networkSession = this->networkSession(sessionID)) {
>+        if (auto* resourceLoadStatistics = networkSession->resourceLoadStatistics())
>+            resourceLoadStatistics->logUserInteraction(targetPrimaryDomain, WTFMove(completionHandler));
>+    } else
>+        ASSERT_NOT_REACHED();
>+}
>+
>+void NetworkProcess::hadUserInteraction(PAL::SessionID sessionID, const String& resourceDomain, CompletionHandler<void(bool)>&& completionHandler)
> {
>     if (auto* networkSession = this->networkSession(sessionID)) {
>         if (auto* resourceLoadStatistics = networkSession->resourceLoadStatistics()) {
>-            resourceLoadStatistics->logUserInteraction(targetPrimaryDomain, [this, contextId] {
>-                parentProcessConnection()->send(Messages::NetworkProcessProxy::DidLogUserInteraction(contextId), 0);
>-            });        
>+            resourceLoadStatistics->hasHadUserInteraction(resourceDomain, WTFMove(completionHandler));
>         }
>     } else
>         ASSERT_NOT_REACHED();
> }
> 
>+void NetworkProcess::clearUserInteraction(PAL::SessionID sessionID, const String& resourceDomain, CompletionHandler<void()>&& completionHandler)
>+{
>+    if (auto* networkSession = this->networkSession(sessionID)) {
>+        if (auto* resourceLoadStatistics = networkSession->resourceLoadStatistics())
>+            resourceLoadStatistics->clearUserInteraction(resourceDomain, WTFMove(completionHandler));
>+    } else
>+        ASSERT_NOT_REACHED();
>+}
>+
> void NetworkProcess::removeAllStorageAccess(PAL::SessionID sessionID, uint64_t contextId)
> {
>     if (auto* networkStorageSession = NetworkStorageSession::storageSession(sessionID))
>@@ -585,13 +865,82 @@ void NetworkProcess::setCacheMaxAgeCapForPrevalentResources(PAL::SessionID sessi
>     parentProcessConnection()->send(Messages::NetworkProcessProxy::DidSetCacheMaxAgeCapForPrevalentResources(contextId), 0);
> }
> 
>+void NetworkProcess::setGrandfatheringTime(PAL::SessionID sessionID, Seconds seconds, CompletionHandler<void()>&& completionHandler)
>+{
>+    if (auto* networkSession = this->networkSession(sessionID)) {
>+        if (auto* resourceLoadStatistics = networkSession->resourceLoadStatistics())
>+            resourceLoadStatistics->setGrandfatheringTime(seconds, WTFMove(completionHandler));
>+    } else
>+        ASSERT_NOT_REACHED();
>+}
>+
>+void NetworkProcess::setMaxStatisticsEntries(PAL::SessionID sessionID, uint64_t maximumEntryCount, CompletionHandler<void()>&& completionHandler)
>+{
>+    if (auto* networkSession = this->networkSession(sessionID)) {
>+        if (auto* resourceLoadStatistics = networkSession->resourceLoadStatistics())
>+            resourceLoadStatistics->setMaxStatisticsEntries(maximumEntryCount, WTFMove(completionHandler));
>+    } else
>+        ASSERT_NOT_REACHED();
>+}
>+
>+void NetworkProcess::setMinimumTimeBetweenDataRecordsRemoval(PAL::SessionID sessionID, Seconds seconds, CompletionHandler<void()>&& completionHandler)
>+{
>+    if (auto* networkSession = this->networkSession(sessionID)) {
>+        if (auto* resourceLoadStatistics = networkSession->resourceLoadStatistics())
>+            resourceLoadStatistics->setMinimumTimeBetweenDataRecordsRemoval(seconds, WTFMove(completionHandler));
>+    } else
>+        ASSERT_NOT_REACHED();
>+}
>+
>+void NetworkProcess::setPruneEntriesDownTo(PAL::SessionID sessionID, uint64_t pruneTargetCount, CompletionHandler<void()>&& completionHandler)
>+{
>+    if (auto* networkSession = this->networkSession(sessionID)) {
>+        if (auto* resourceLoadStatistics = networkSession->resourceLoadStatistics())
>+            resourceLoadStatistics->setPruneEntriesDownTo(pruneTargetCount, WTFMove(completionHandler));
>+    } else
>+        ASSERT_NOT_REACHED();
>+}
>+
>+void NetworkProcess::setTimeToLiveUserInteraction(PAL::SessionID sessionID, Seconds seconds, CompletionHandler<void()>&& completionHandler)
>+{
>+    if (auto* networkSession = this->networkSession(sessionID)) {
>+        if (auto* resourceLoadStatistics = networkSession->resourceLoadStatistics())
>+            resourceLoadStatistics->setTimeToLiveUserInteraction(seconds, WTFMove(completionHandler));
>+    } else
>+        ASSERT_NOT_REACHED();
>+}
>+
>+void NetworkProcess::setShouldClassifyResourcesBeforeDataRecordsRemoval(PAL::SessionID sessionID, bool value, CompletionHandler<void()>&& completionHandler)
>+{
>+    if (auto* networkSession = this->networkSession(sessionID)) {
>+        if (auto* resourceLoadStatistics = networkSession->resourceLoadStatistics())
>+            resourceLoadStatistics->setShouldClassifyResourcesBeforeDataRecordsRemoval(value, WTFMove(completionHandler));
>+    } else
>+        ASSERT_NOT_REACHED();
>+}
>+
>+void NetworkProcess::setResourceLoadStatisticsEnabled(bool enabled)
>+{
>+    for (auto& networkSession : m_networkSessions.values())
>+        networkSession.get().setResourceLoadStatisticsEnabled(enabled);
>+}
>+
>+void NetworkProcess::setResourceLoadStatisticsDebugMode(PAL::SessionID sessionID, bool debugMode, CompletionHandler<void()>&& completionHandler)
>+{
>+    if (auto* networkSession = this->networkSession(sessionID)) {
>+        if (auto* resourceLoadStatistics = networkSession->resourceLoadStatistics())
>+            resourceLoadStatistics->setResourceLoadStatisticsDebugMode(debugMode, WTFMove(completionHandler));
>+    } else
>+        ASSERT_NOT_REACHED();
>+}
>+
> void NetworkProcess::resetCacheMaxAgeCapForPrevalentResources(PAL::SessionID sessionID, uint64_t contextId)
> {
>     if (auto* networkStorageSession = NetworkStorageSession::storageSession(sessionID))
>         networkStorageSession->resetCacheMaxAgeCapForPrevalentResources();
>     else
>         ASSERT_NOT_REACHED();
>-    parentProcessConnection()->send(Messages::NetworkProcessProxy::DidResetCacheMaxAgeCapForPrevalentResources(contextId), 0);
>+    parentProcessConnection()->send(Messages::NetworkProcessProxy::DidUpdateRuntimeSettings(contextId), 0);
> }
> #endif // ENABLE(RESOURCE_LOAD_STATISTICS)
> 
>@@ -650,8 +999,6 @@ void NetworkProcess::fetchWebsiteData(PAL::SessionID sessionID, OptionSet<Websit
> 
>         ~CallbackAggregator()
>         {
>-            ASSERT(RunLoop::isMain());
>-
>             RunLoop::main().dispatch([completionHandler = WTFMove(m_completionHandler), websiteData = WTFMove(m_websiteData)] () mutable {
>                 completionHandler(websiteData);
>             });
>@@ -756,6 +1103,23 @@ void NetworkProcess::deleteWebsiteData(PAL::SessionID sessionID, OptionSet<Websi
> 
>     if (websiteDataTypes.contains(WebsiteDataType::DiskCache) && !sessionID.isEphemeral())
>         clearDiskCache(modifiedSince, [clearTasksHandler = WTFMove(clearTasksHandler)] { });
>+
>+#if ENABLE(RESOURCE_LOAD_STATISTICS)
>+    if (websiteDataTypes.contains(WebsiteDataType::ResourceLoadStatistics)) {
>+        if (auto* networkSession = this->networkSession(sessionID)) {
>+            if (auto* resourceLoadStatistics = networkSession->resourceLoadStatistics()) {
>+                auto deletedTypesRaw = websiteDataTypes.toRaw();
>+                auto monitoredTypesRaw = WebResourceLoadStatisticsStore::monitoredDataTypes().toRaw();
>+
>+                // If we are deleting all of the data types that the resource load statistics store monitors
>+                // we do not need to re-grandfather old data.
>+                auto shouldGrandfather = ((monitoredTypesRaw & deletedTypesRaw) == monitoredTypesRaw) ? ShouldGrandfather::No : ShouldGrandfather::Yes;
>+
>+                resourceLoadStatistics->scheduleClearInMemoryAndPersistent(modifiedSince, shouldGrandfather, [clearTasksHandler = clearTasksHandler.copyRef()] { });
>+            }
>+        }
>+    }
>+#endif
> }
> 
> static void clearDiskCacheEntries(NetworkCache::Cache* cache, const Vector<SecurityOriginData>& origins, CompletionHandler<void()>&& completionHandler)
>@@ -822,6 +1186,259 @@ void NetworkProcess::deleteWebsiteDataForOrigins(PAL::SessionID sessionID, Optio
>         clearDiskCacheEntries(cache(), originDatas, [clearTasksHandler = WTFMove(clearTasksHandler)] { });
> }
> 
>+#if ENABLE(RESOURCE_LOAD_STATISTICS)
>+static Vector<String> filterForTopLevelDomains(const Vector<String>& topLevelDomains, const HashSet<String>& foundValues)
>+{
>+    Vector<String> result;
>+    for (const auto& hostname : topLevelDomains) {
>+        if (foundValues.contains(hostname))
>+            result.append(hostname);
>+    }
>+    
>+    return result;
>+}
>+
>+static Vector<WebsiteData::Entry> filterForTopLevelDomains(const Vector<String>& topLevelDomains, const Vector<WebsiteData::Entry>& foundValues)
>+{
>+    Vector<WebsiteData::Entry> result;
>+    for (const auto& value : foundValues) {
>+        if (topLevelDomains.contains(value.origin.host))
>+            result.append(value);
>+    }
>+    
>+    return result;
>+}
>+
>+void NetworkProcess::deleteWebsiteDataForTopPrivatelyControlledDomainsInAllPersistentDataStores(PAL::SessionID sessionID, OptionSet<WebsiteDataType> websiteDataTypes, Vector<String>&& topPrivatelyControlledDomains, bool shouldNotifyPage, CompletionHandler<void(const HashSet<String>&)>&& completionHandler)
>+{
>+    OptionSet<WebsiteDataFetchOption> fetchOptions = WebsiteDataFetchOption::DoNotCreateProcesses;
>+
>+    struct CallbackAggregator final : public RefCounted<CallbackAggregator> {
>+        explicit CallbackAggregator(CompletionHandler<void(const HashSet<String>&)>&& completionHandler)
>+            : m_completionHandler(WTFMove(completionHandler))
>+        {
>+        }
>+        
>+        ~CallbackAggregator()
>+        {
>+            RunLoop::main().dispatch([completionHandler = WTFMove(m_completionHandler), websiteData = WTFMove(m_websiteData)] () mutable {
>+                HashSet<String> origins;
>+                for (const auto& hostnameWithCookies : websiteData.hostNamesWithCookies)
>+                    origins.add(hostnameWithCookies);
>+
>+                for (const auto& hostnameWithHSTS : websiteData.hostNamesWithHSTSCache)
>+                    origins.add(hostnameWithHSTS);
>+
>+                for (const auto& entry : websiteData.entries)
>+                    origins.add(entry.origin.host);
>+
>+                completionHandler(origins);
>+            });
>+        }
>+        
>+        CompletionHandler<void(const HashSet<String>&)> m_completionHandler;
>+        WebsiteData m_websiteData;
>+    };
>+    
>+    auto callbackAggregator = adoptRef(*new CallbackAggregator([this, completionHandler = WTFMove(completionHandler), shouldNotifyPage] (const HashSet<String>& originsWithData) mutable {
>+        if (shouldNotifyPage)
>+            parentProcessConnection()->send(Messages::NetworkProcessProxy::NotifyWebsiteDataDeletionForTopPrivatelyOwnedDomainsFinished(), 0);
>+        
>+        RunLoop::main().dispatch([completionHandler = WTFMove(completionHandler), originsWithData = crossThreadCopy(originsWithData)] () mutable {
>+            completionHandler(originsWithData);
>+        });
>+    }));
>+
>+    auto& websiteDataStore = callbackAggregator->m_websiteData;
>+
>+    Vector<String> hostnamesWithCookiesToDelete;
>+    if (websiteDataTypes.contains(WebsiteDataType::Cookies)) {
>+        if (auto* networkStorageSession = NetworkStorageSession::storageSession(sessionID)) {
>+            networkStorageSession->getHostnamesWithCookies(websiteDataStore.hostNamesWithCookies);
>+            hostnamesWithCookiesToDelete = filterForTopLevelDomains(topPrivatelyControlledDomains, websiteDataStore.hostNamesWithCookies);
>+            networkStorageSession->deleteCookiesForHostnames(hostnamesWithCookiesToDelete);
>+        }
>+    }
>+
>+    Vector<String> hostnamesWithHSTSToDelete;
>+#if PLATFORM(COCOA)
>+    if (websiteDataTypes.contains(WebsiteDataType::HSTSCache)) {
>+        if (auto* networkStorageSession = NetworkStorageSession::storageSession(sessionID)) {
>+            getHostNamesWithHSTSCache(*networkStorageSession, websiteDataStore.hostNamesWithHSTSCache);
>+            hostnamesWithHSTSToDelete = filterForTopLevelDomains(topPrivatelyControlledDomains, websiteDataStore.hostNamesWithHSTSCache);
>+            deleteHSTSCacheForHostNames(*networkStorageSession, hostnamesWithHSTSToDelete);
>+        }
>+    }
>+#endif
>+
>+    /*
>+    // FIXME: No API to delete credentials by origin
>+    if (websiteDataTypes.contains(WebsiteDataType::Credentials)) {
>+        if (NetworkStorageSession::storageSession(sessionID))
>+            websiteDataStore.originsWithCredentials = NetworkStorageSession::storageSession(sessionID)->credentialStorage().originsWithCredentials();
>+    }
>+    */
>+    
>+    if (websiteDataTypes.contains(WebsiteDataType::DOMCache)) {
>+        CacheStorage::Engine::fetchEntries(*this, sessionID, fetchOptions.contains(WebsiteDataFetchOption::ComputeSizes), [this, topPrivatelyControlledDomains, sessionID, callbackAggregator = callbackAggregator.copyRef()](auto entries) mutable {
>+            
>+            auto entriesToDelete = filterForTopLevelDomains(topPrivatelyControlledDomains, entries);
>+
>+            callbackAggregator->m_websiteData.entries.appendVector(entriesToDelete);
>+            
>+            for (auto& entry : entriesToDelete)
>+                CacheStorage::Engine::clearCachesForOrigin(*this, sessionID, SecurityOriginData { entry.origin }, [callbackAggregator = callbackAggregator.copyRef()] { });
>+        });
>+    }
>+    
>+#if ENABLE(INDEXED_DATABASE)
>+    auto path = m_idbDatabasePaths.get(sessionID);
>+    if (!path.isEmpty() && websiteDataTypes.contains(WebsiteDataType::IndexedDBDatabases)) {
>+        // FIXME: Pick the right database store based on the session ID.
>+        postStorageTask(CrossThreadTask([this, sessionID, callbackAggregator = callbackAggregator.copyRef(), path = WTFMove(path), topPrivatelyControlledDomains]() mutable {
>+            RunLoop::main().dispatch([this, sessionID, topPrivatelyControlledDomains = crossThreadCopy(topPrivatelyControlledDomains), callbackAggregator = callbackAggregator.copyRef(), securityOrigins = indexedDatabaseOrigins(path)] {
>+                Vector<SecurityOriginData> entriesToDelete;
>+                for (const auto& securityOrigin : securityOrigins) {
>+                    if (!topPrivatelyControlledDomains.contains(securityOrigin.host))
>+                        continue;
>+
>+                    entriesToDelete.append(securityOrigin);
>+                    callbackAggregator->m_websiteData.entries.append({ securityOrigin, WebsiteDataType::IndexedDBDatabases, 0 });
>+                }
>+
>+                idbServer(sessionID).closeAndDeleteDatabasesForOrigins(entriesToDelete, [callbackAggregator = callbackAggregator.copyRef()] { });
>+            });
>+        }));
>+    }
>+#endif
>+    
>+#if ENABLE(SERVICE_WORKER)
>+    path = m_swDatabasePaths.get(sessionID);
>+    if (!path.isEmpty() && websiteDataTypes.contains(WebsiteDataType::ServiceWorkerRegistrations)) {
>+        swServerForSession(sessionID).getOriginsWithRegistrations([this, sessionID, topPrivatelyControlledDomains, callbackAggregator = callbackAggregator.copyRef()](const HashSet<SecurityOriginData>& securityOrigins) mutable {
>+            for (auto& securityOrigin : securityOrigins) {
>+                if (!topPrivatelyControlledDomains.contains(securityOrigin.host))
>+                    continue;
>+                callbackAggregator->m_websiteData.entries.append({ securityOrigin, WebsiteDataType::ServiceWorkerRegistrations, 0 });
>+                swServerForSession(sessionID).clear(securityOrigin, [callbackAggregator = callbackAggregator.copyRef()] { });
>+            }
>+        });
>+    }
>+#endif
>+    
>+    if (websiteDataTypes.contains(WebsiteDataType::DiskCache)) {
>+        fetchDiskCacheEntries(cache(), sessionID, fetchOptions, [this, topPrivatelyControlledDomains, callbackAggregator = callbackAggregator.copyRef()](auto entries) mutable {
>+
>+            Vector<SecurityOriginData> entriesToDelete;
>+            for (auto& entry : entries) {
>+                if (!topPrivatelyControlledDomains.contains(entry.origin.host))
>+                    continue;
>+                entriesToDelete.append(entry.origin);
>+                callbackAggregator->m_websiteData.entries.append(entry);
>+            }
>+            clearDiskCacheEntries(cache(), entriesToDelete, [callbackAggregator = callbackAggregator.copyRef()] { });
>+        });
>+    }
>+}
>+
>+void NetworkProcess::topPrivatelyControlledDomainsWithWebsiteData(PAL::SessionID sessionID, OptionSet<WebsiteDataType> websiteDataTypes, bool shouldNotifyPage, CompletionHandler<void(HashSet<String>&&)>&& completionHandler)
>+{
>+    OptionSet<WebsiteDataFetchOption> fetchOptions = WebsiteDataFetchOption::DoNotCreateProcesses;
>+    
>+    struct CallbackAggregator final : public RefCounted<CallbackAggregator> {
>+        explicit CallbackAggregator(CompletionHandler<void(HashSet<String>&&)>&& completionHandler)
>+            : m_completionHandler(WTFMove(completionHandler))
>+        {
>+        }
>+        
>+        ~CallbackAggregator()
>+        {
>+            RunLoop::main().dispatch([completionHandler = WTFMove(m_completionHandler), websiteData = WTFMove(m_websiteData)] () mutable {
>+                HashSet<String> origins;
>+                for (const auto& hostnameWithCookies : websiteData.hostNamesWithCookies)
>+                    origins.add(hostnameWithCookies);
>+                
>+                for (const auto& hostnameWithHSTS : websiteData.hostNamesWithHSTSCache)
>+                    origins.add(hostnameWithHSTS);
>+                
>+                for (const auto& entry : websiteData.entries)
>+                    origins.add(entry.origin.host);
>+                
>+                completionHandler(WTFMove(origins));
>+            });
>+        }
>+        
>+        CompletionHandler<void(HashSet<String>&&)> m_completionHandler;
>+        WebsiteData m_websiteData;
>+    };
>+    
>+    auto callbackAggregator = adoptRef(*new CallbackAggregator([this, completionHandler = WTFMove(completionHandler), shouldNotifyPage] (HashSet<String>&& originsWithData) mutable {
>+        if (shouldNotifyPage)
>+            parentProcessConnection()->send(Messages::NetworkProcessProxy::NotifyWebsiteDataScanForTopPrivatelyControlledDomainsFinished(), 0);
>+
>+        RunLoop::main().dispatch([completionHandler = WTFMove(completionHandler), originsWithData = crossThreadCopy(originsWithData)] () mutable {
>+            completionHandler(WTFMove(originsWithData));
>+        });
>+    }));
>+    
>+    auto& websiteDataStore = callbackAggregator->m_websiteData;
>+    
>+    Vector<String> hostnamesWithCookiesToDelete;
>+    if (websiteDataTypes.contains(WebsiteDataType::Cookies)) {
>+        if (auto* networkStorageSession = NetworkStorageSession::storageSession(sessionID))
>+            networkStorageSession->getHostnamesWithCookies(websiteDataStore.hostNamesWithCookies);
>+    }
>+    
>+    Vector<String> hostnamesWithHSTSToDelete;
>+#if PLATFORM(COCOA)
>+    if (websiteDataTypes.contains(WebsiteDataType::HSTSCache)) {
>+        if (auto* networkStorageSession = NetworkStorageSession::storageSession(sessionID))
>+            getHostNamesWithHSTSCache(*networkStorageSession, websiteDataStore.hostNamesWithHSTSCache);
>+    }
>+#endif
>+
>+    if (websiteDataTypes.contains(WebsiteDataType::Credentials)) {
>+        if (NetworkStorageSession::storageSession(sessionID))
>+            websiteDataStore.originsWithCredentials = NetworkStorageSession::storageSession(sessionID)->credentialStorage().originsWithCredentials();
>+    }
>+    
>+    if (websiteDataTypes.contains(WebsiteDataType::DOMCache)) {
>+        CacheStorage::Engine::fetchEntries(*this, sessionID, fetchOptions.contains(WebsiteDataFetchOption::ComputeSizes), [callbackAggregator = callbackAggregator.copyRef()](auto entries) mutable {
>+            callbackAggregator->m_websiteData.entries.appendVector(entries);
>+        });
>+    }
>+    
>+#if ENABLE(INDEXED_DATABASE)
>+    auto path = m_idbDatabasePaths.get(sessionID);
>+    if (!path.isEmpty() && websiteDataTypes.contains(WebsiteDataType::IndexedDBDatabases)) {
>+        // FIXME: Pick the right database store based on the session ID.
>+        postStorageTask(CrossThreadTask([this, callbackAggregator = callbackAggregator.copyRef(), path = WTFMove(path)]() mutable {
>+            RunLoop::main().dispatch([callbackAggregator = callbackAggregator.copyRef(), securityOrigins = indexedDatabaseOrigins(path)] {
>+                for (const auto& securityOrigin : securityOrigins)
>+                    callbackAggregator->m_websiteData.entries.append({ securityOrigin, WebsiteDataType::IndexedDBDatabases, 0 });
>+            });
>+        }));
>+    }
>+#endif
>+    
>+#if ENABLE(SERVICE_WORKER)
>+    path = m_swDatabasePaths.get(sessionID);
>+    if (!path.isEmpty() && websiteDataTypes.contains(WebsiteDataType::ServiceWorkerRegistrations)) {
>+        swServerForSession(sessionID).getOriginsWithRegistrations([callbackAggregator = callbackAggregator.copyRef()](const HashSet<SecurityOriginData>& securityOrigins) mutable {
>+            for (auto& securityOrigin : securityOrigins)
>+                callbackAggregator->m_websiteData.entries.append({ securityOrigin, WebsiteDataType::ServiceWorkerRegistrations, 0 });
>+        });
>+    }
>+#endif
>+    
>+    if (websiteDataTypes.contains(WebsiteDataType::DiskCache)) {
>+        fetchDiskCacheEntries(cache(), sessionID, fetchOptions, [callbackAggregator = callbackAggregator.copyRef()](auto entries) mutable {
>+            callbackAggregator->m_websiteData.entries.appendVector(entries);
>+        });
>+    }
>+}
>+#endif // ENABLE(RESOURCE_LOAD_STATISTICS)
>+
> CacheStorage::Engine* NetworkProcess::findCacheEngine(const PAL::SessionID& sessionID)
> {
>     return m_cacheEngines.get(sessionID);
>diff --git a/Source/WebKit/NetworkProcess/NetworkProcess.h b/Source/WebKit/NetworkProcess/NetworkProcess.h
>index aec3ea40dacb16049550e771bd800b69fa5861e9..59794a2e3b465edb8d627fc70e4b4a46a76d1909 100644
>--- a/Source/WebKit/NetworkProcess/NetworkProcess.h
>+++ b/Source/WebKit/NetworkProcess/NetworkProcess.h
>@@ -159,17 +159,57 @@ public:
>     void addWebsiteDataStore(WebsiteDataStoreParameters&&);
> 
> #if ENABLE(RESOURCE_LOAD_STATISTICS)
>+    void clearPrevalentResource(PAL::SessionID, const String& resourceDomain, CompletionHandler<void()>&&);
>+    void clearUserInteraction(PAL::SessionID, const String& resourceDomain, CompletionHandler<void()>&&);
>+    void deleteWebsiteDataForTopPrivatelyControlledDomainsInAllPersistentDataStores(PAL::SessionID, OptionSet<WebsiteDataType>, Vector<String>&& topPrivatelyControlledDomains, bool shouldNotifyPage, CompletionHandler<void(const HashSet<String>&)>&&);
>+    void dumpResourceLoadStatistics(PAL::SessionID, uint64_t contextId);
>     void updatePrevalentDomainsToBlockCookiesFor(PAL::SessionID, const Vector<String>& domainsToBlock, uint64_t contextId);
>+    void isGrandfathered(PAL::SessionID, const String& targetPrimaryDomain, CompletionHandler<void(bool)>&&);
>+    void isPrevalentResource(PAL::SessionID, const String& resourceDomain, CompletionHandler<void(bool)>&&);
>+    void isVeryPrevalentResource(PAL::SessionID, const String& resourceDomain, CompletionHandler<void(bool)>&&);
>     void setAgeCapForClientSideCookies(PAL::SessionID, Optional<Seconds>, uint64_t contextId);
>+    void isRegisteredAsRedirectingTo(PAL::SessionID, const String& redirectedFrom, const String& redirectedTo, CompletionHandler<void(bool)>&&);
>+    void isRegisteredAsSubFrameUnder(PAL::SessionID, const String& subframe, const String& topFrame, CompletionHandler<void(bool)>&&);
>+    void isRegisteredAsSubresourceUnder(PAL::SessionID, const String& subresource, const String& topFrame, CompletionHandler<void(bool)>&&);
>+    void setGrandfathered(PAL::SessionID, const String& resourceDomain, bool isGrandfathered, CompletionHandler<void()>&&);
>+    void setMaxStatisticsEntries(PAL::SessionID, uint64_t maximumEntryCount, CompletionHandler<void()>&&);
>+    void setPrevalentResource(PAL::SessionID, const String& resourceDomain, CompletionHandler<void()>&&);
>+    void setPrevalentResourceForDebugMode(PAL::SessionID, String resourceDomain, CompletionHandler<void()>&&);
>+    void setVeryPrevalentResource(PAL::SessionID, const String& resourceDomain, CompletionHandler<void()>&&);
>+    void setPruneEntriesDownTo(PAL::SessionID, uint64_t pruneTargetCount, CompletionHandler<void()>&&);
>+    void hadUserInteraction(PAL::SessionID, const String& resourceDomain, CompletionHandler<void(bool)>&&);
>     void hasStorageAccessForFrame(PAL::SessionID, const String& resourceDomain, const String& firstPartyDomain, uint64_t frameID, uint64_t pageID, uint64_t contextId);
>     void getAllStorageAccessEntries(PAL::SessionID, uint64_t contextId);
>-    void grantStorageAccess(PAL::SessionID, const String& resourceDomain, const String& firstPartyDomain, Optional<uint64_t> frameID, uint64_t pageID, uint64_t contextId);
>+    void grantStorageAccess(PAL::SessionID, const String& resourceDomain, const String& firstPartyDomain, Optional<uint64_t> frameID, uint64_t pageID, bool userWasPrompted, uint64_t contextId);
>+    void hasStorageAccess(PAL::SessionID, const String& resourceDomain, const String& firstPartyDomain, Optional<uint64_t> frameID, uint64_t pageID, CompletionHandler<void(bool)>&&);
>     void logFrameNavigation(PAL::SessionID, const String& targetPrimaryDomain, const String& mainFramePrimaryDomain, const String& sourcePrimaryDomain, const String& targetHost, const String& mainFrameHost, bool isRedirect, bool isMainFrame);
>-    void logUserInteraction(PAL::SessionID, const String& targetPrimaryDomain, uint64_t contextId);
>+    void logUserInteraction(PAL::SessionID, const String& targetPrimaryDomain, CompletionHandler<void()>&&);
>     void removeAllStorageAccess(PAL::SessionID, uint64_t contextId);
>     void removePrevalentDomains(PAL::SessionID, const Vector<String>& domains);
>-    void setCacheMaxAgeCapForPrevalentResources(PAL::SessionID, Seconds, uint64_t contextId);
>+    void requestStorageAccess(PAL::SessionID, const String& resourceDomain, const String& firstPartyDomain, Optional<uint64_t> frameID, uint64_t pageID, bool promptEnabled, uint64_t contextId);
>     void resetCacheMaxAgeCapForPrevalentResources(PAL::SessionID, uint64_t contextId);
>+    void resetParametersToDefaultValues(PAL::SessionID, CompletionHandler<void()>&&);
>+    void scheduleClearInMemoryAndPersistent(PAL::SessionID, Optional<WallTime> modifiedSince, bool shouldGrandfather, CompletionHandler<void()>&&);
>+    void scheduleCookieBlockingUpdate(PAL::SessionID, CompletionHandler<void()>&&);
>+    void scheduleStatisticsAndDataRecordsProcessing(PAL::SessionID, CompletionHandler<void()>&&);
>+    void submitTelemetry(PAL::SessionID, CompletionHandler<void()>&&);
>+    void setCacheMaxAgeCapForPrevalentResources(PAL::SessionID, Seconds, uint64_t contextId);
>+    void setGrandfatheringTime(PAL::SessionID, Seconds, CompletionHandler<void()>&&);
>+    void setLastSeen(PAL::SessionID, const String& resourceDomain, Seconds, CompletionHandler<void()>&&);
>+    void setMinimumTimeBetweenDataRecordsRemoval(PAL::SessionID, Seconds, CompletionHandler<void()>&&);
>+    void setNotifyPagesWhenDataRecordsWereScanned(PAL::SessionID, bool value, CompletionHandler<void()>&&);
>+    void setNotifyPagesWhenTelemetryWasCaptured(PAL::SessionID, bool value, CompletionHandler<void()>&&);
>+    void setResourceLoadStatisticsEnabled(bool);
>+    void setResourceLoadStatisticsDebugMode(PAL::SessionID, bool debugMode, CompletionHandler<void()>&&d);
>+    void setShouldClassifyResourcesBeforeDataRecordsRemoval(PAL::SessionID, bool value, CompletionHandler<void()>&&);
>+    void setSubframeUnderTopFrameOrigin(PAL::SessionID, String subframe, String topFrame, CompletionHandler<void()>&&);
>+    void setSubresourceUnderTopFrameOrigin(PAL::SessionID, String subresource, String topFrame, CompletionHandler<void()>&&);
>+    void setSubresourceUniqueRedirectTo(PAL::SessionID, String subresource, String hostNameRedirectedTo, CompletionHandler<void()>&&);
>+    void setSubresourceUniqueRedirectFrom(PAL::SessionID, String subresource, String hostNameRedirectedFrom, CompletionHandler<void()>&&);
>+    void setTimeToLiveUserInteraction(PAL::SessionID, Seconds, CompletionHandler<void()>&&);
>+    void setTopFrameUniqueRedirectTo(PAL::SessionID, String topFrameHostName, String hostNameRedirectedTo, CompletionHandler<void()>&&);
>+    void setTopFrameUniqueRedirectFrom(PAL::SessionID, String topFrameHostName, String hostNameRedirectedFrom, CompletionHandler<void()>&&);
>+    void topPrivatelyControlledDomainsWithWebsiteData(PAL::SessionID, OptionSet<WebsiteDataType>, bool shouldNotifyPage, CompletionHandler<void(HashSet<String>&&)>&&);
> #endif
> 
>     using CacheStorageParametersCallback = CompletionHandler<void(const String&, uint64_t quota)>;
>diff --git a/Source/WebKit/NetworkProcess/NetworkProcess.messages.in b/Source/WebKit/NetworkProcess/NetworkProcess.messages.in
>index 8ba1675dc88e64b659acc9f413e86a5c1c36e7d9..62565812aae650a2a0e5544d7a4dca6c04db9643 100644
>--- a/Source/WebKit/NetworkProcess/NetworkProcess.messages.in
>+++ b/Source/WebKit/NetworkProcess/NetworkProcess.messages.in
>@@ -85,16 +85,54 @@ messages -> NetworkProcess LegacyReceiver {
>     PreconnectTo(URL url, enum:bool WebCore::StoredCredentialsPolicy storedCredentialsPolicy);
> 
> #if ENABLE(RESOURCE_LOAD_STATISTICS)
>+    ClearPrevalentResource(PAL::SessionID sessionID, String resourceDomain) -> () Async
>+    ClearUserInteraction(PAL::SessionID sessionID, String resourceDomain) -> () Async
>+    DumpResourceLoadStatistics(PAL::SessionID sessionID, uint64_t contextId)
>+    SetResourceLoadStatisticsEnabled(bool enabled)
>     UpdatePrevalentDomainsToBlockCookiesFor(PAL::SessionID sessionID, Vector<String> domainsToBlock, uint64_t contextId)
>+    IsGrandfathered(PAL::SessionID sessionID, String targetPrimaryDomain) -> (bool isGrandfathered) Async
>+    IsPrevalentResource(PAL::SessionID sessionID, String targetPrimaryDomain) -> (bool isPrevalent) Async
>+    IsVeryPrevalentResource(PAL::SessionID sessionID, String targetPrimaryDomain) -> (bool isVeryPrevalent) Async
>     SetAgeCapForClientSideCookies(PAL::SessionID sessionID, Optional<Seconds> seconds, uint64_t contextId)
>+    SetLastSeen(PAL::SessionID sessionID, String resourceDomain, Seconds seconds) -> () Async
>+    SetPrevalentResource(PAL::SessionID sessionID, String resourceDomain) -> () Async
>+    SetPrevalentResourceForDebugMode(PAL::SessionID sessionID, String resourceDomain) -> () Async
>+    HadUserInteraction(PAL::SessionID sessionID, String resourceDomain) -> (bool hadUserInteraction) Async
>     HasStorageAccessForFrame(PAL::SessionID sessionID, String resourceDomain, String firstPartyDomain, uint64_t frameID, uint64_t pageID, uint64_t contextId)
>+    HasStorageAccess(PAL::SessionID sessionID, String resourceDomain, String firstPartyDomain, Optional<uint64_t> frameID, uint64_t pageID) -> (bool hadUserInteraction) Async
>     GetAllStorageAccessEntries(PAL::SessionID sessionID, uint64_t contextId)
>-    GrantStorageAccess(PAL::SessionID sessionID, String resourceDomain, String firstPartyDomain, Optional<uint64_t> frameID, uint64_t pageID, uint64_t contextId)
>+    GrantStorageAccess(PAL::SessionID sessionID, String resourceDomain, String firstPartyDomain, Optional<uint64_t> frameID, uint64_t pageID, bool userWasPrompted, uint64_t contextId)
>+    IsRegisteredAsRedirectingTo(PAL::SessionID sessionID, String redirectedFrom, String redirectedTo) -> (bool isRedirectingTo) Async
>+    IsRegisteredAsSubFrameUnder(PAL::SessionID sessionID, String subframe, String topFrame) -> (bool isSubframeUnder) Async
>+    IsRegisteredAsSubresourceUnder(PAL::SessionID sessionID, String subresource, String topFrame) -> (bool isSubresourceUnder) Async
>     LogFrameNavigation(PAL::SessionID sessionID, String targetPrimaryDomain, String mainFramePrimaryDomain, String sourcePrimaryDomain, String targetHost, String mainFrameHost, bool isRedirect, bool isMainFrame)
>-    LogUserInteraction(PAL::SessionID sessionID, String targetPrimaryDomain, uint64_t contextId)
>+    LogUserInteraction(PAL::SessionID sessionID, String targetPrimaryDomain) -> () Async
>     RemoveAllStorageAccess(PAL::SessionID sessionID, uint64_t contextId)
>     RemovePrevalentDomains(PAL::SessionID sessionID, Vector<String> domainsWithInteraction)
>+    RequestStorageAccess(PAL::SessionID sessionID, String resourceDomain, String firstPartyDomain, Optional<uint64_t> frameID, uint64_t pageID, bool promptEnabled, uint64_t contextId)
>+    ResetParametersToDefaultValues(PAL::SessionID sessionID) -> () Async
>+    ScheduleClearInMemoryAndPersistent(PAL::SessionID sessionID, Optional<WallTime> modifiedSince, bool shouldGrandfather) -> () Async
>+    ScheduleCookieBlockingUpdate(PAL::SessionID sessionID) -> () Async
>+    ScheduleStatisticsAndDataRecordsProcessing(PAL::SessionID sessionID) -> () Async
>+    SubmitTelemetry(PAL::SessionID sessionID) -> () Async
>     SetCacheMaxAgeCapForPrevalentResources(PAL::SessionID sessionID, Seconds seconds, uint64_t contextId)
>+    SetGrandfathered(PAL::SessionID sessionID, String resourceDomain, bool isGrandfathered) -> () Async
>+    SetGrandfatheringTime(PAL::SessionID sessionID, Seconds seconds) -> () Async
>+    SetMaxStatisticsEntries(PAL::SessionID sessionID, uint64_t maximumEntryCount) -> () Async
>+    SetMinimumTimeBetweenDataRecordsRemoval(PAL::SessionID sessionID, Seconds seconds) -> () Async
>+    SetPruneEntriesDownTo(PAL::SessionID sessionID, uint64_t maximumEntryCount) -> () Async
>+    SetShouldClassifyResourcesBeforeDataRecordsRemoval(PAL::SessionID sessionID, bool value) -> () Async
>+    SetNotifyPagesWhenDataRecordsWereScanned(PAL::SessionID sessionID, bool value) -> () Async
>+    SetNotifyPagesWhenTelemetryWasCaptured(PAL::SessionID sessionID, bool value) -> () Async
>+    SetResourceLoadStatisticsDebugMode(PAL::SessionID sessionID, bool debugMode) -> () Async
>+    SetVeryPrevalentResource(PAL::SessionID sessionID, String resourceDomain) -> () Async
>+    SetSubframeUnderTopFrameOrigin(PAL::SessionID sessionID, String subframe, String topFrame) -> () Async
>+    SetSubresourceUnderTopFrameOrigin(PAL::SessionID sessionID, String subresource, String topFrame) -> () Async
>+    SetSubresourceUniqueRedirectTo(PAL::SessionID sessionID, String subresource, String hostNameRedirectedTo) -> () Async
>+    SetSubresourceUniqueRedirectFrom(PAL::SessionID sessionID, String subresource, String hostNameRedirectedFrom) -> () Async
>+    SetTimeToLiveUserInteraction(PAL::SessionID sessionID, Seconds seconds) -> () Async
>+    SetTopFrameUniqueRedirectTo(PAL::SessionID sessionID, String topFrameHostName, String hostNameRedirectedTo) -> () Async
>+    SetTopFrameUniqueRedirectFrom(PAL::SessionID sessionID, String topFrameHostName, String hostNameRedirectedFrom) -> () Async
>     ResetCacheMaxAgeCapForPrevalentResources(PAL::SessionID sessionID, uint64_t contextId)
> #endif
> 
>diff --git a/Source/WebKit/NetworkProcess/NetworkSession.cpp b/Source/WebKit/NetworkProcess/NetworkSession.cpp
>index 820546d85abfad43a9d690338cba4919b145c386..21798a1505cbdea1421adc959627155472d64ae6 100644
>--- a/Source/WebKit/NetworkProcess/NetworkSession.cpp
>+++ b/Source/WebKit/NetworkProcess/NetworkSession.cpp
>@@ -26,6 +26,9 @@
> #include "config.h"
> #include "NetworkSession.h"
> 
>+#include "NetworkProcess.h"
>+#include "NetworkProcessProxyMessages.h"
>+#include "WebProcessProxy.h"
> #include "WebResourceLoadStatisticsStore.h"
> #include <WebCore/NetworkStorageSession.h>
> 
>@@ -78,12 +81,44 @@ void NetworkSession::invalidateAndCancel()
>         task->invalidateAndCancel();
> }
> 
>-void NetworkSession::enableResourceLoadStatistics()
>+#if ENABLE(RESOURCE_LOAD_STATISTICS)
>+void NetworkSession::setResourceLoadStatisticsEnabled(bool enable)
> {
>+    if (!enable) {
>+        m_resourceLoadStatistics = nullptr;
>+        return;
>+    }
>+
>     if (m_resourceLoadStatistics)
>         return;
> 
>     m_resourceLoadStatistics = WebResourceLoadStatisticsStore::create(*this, m_resourceLoadStatisticsDirectory);
> }
> 
>+void NetworkSession::notifyResourceLoadStatisticsProcessed()
>+{
>+    m_networkProcess->parentProcessConnection()->send(Messages::NetworkProcessProxy::NotifyResourceLoadStatisticsProcessed(), 0);
>+}
>+
>+void NetworkSession::logDiagnosticMessageWithValue(const String& message, const String& description, unsigned value, unsigned significantFigures, WebCore::ShouldSample shouldSample)
>+{
>+    m_networkProcess->parentProcessConnection()->send(Messages::WebPageProxy::LogDiagnosticMessageWithValue(message, description, value, significantFigures, shouldSample), 0);
>+}
>+
>+void NetworkSession::notifyPageStatisticsTelemetryFinished(unsigned totalPrevalentResources, unsigned totalPrevalentResourcesWithUserInteraction, unsigned top3SubframeUnderTopFrameOrigins)
>+{
>+    m_networkProcess->parentProcessConnection()->send(Messages::NetworkProcessProxy::NotifyResourceLoadStatisticsTelemetryFinished(totalPrevalentResources, totalPrevalentResourcesWithUserInteraction, top3SubframeUnderTopFrameOrigins), 0);
>+}
>+
>+void NetworkSession::deleteWebsiteDataForTopPrivatelyControlledDomainsInAllPersistentDataStores(OptionSet<WebsiteDataType> dataTypes, Vector<String>&& topPrivatelyControlledDomains, bool shouldNotifyPage, CompletionHandler<void(const HashSet<String>&)>&& completionHandler)
>+{
>+    m_networkProcess->deleteWebsiteDataForTopPrivatelyControlledDomainsInAllPersistentDataStores(m_sessionID, dataTypes, WTFMove(topPrivatelyControlledDomains), shouldNotifyPage, WTFMove(completionHandler));
>+}
>+
>+void NetworkSession::topPrivatelyControlledDomainsWithWebsiteData(OptionSet<WebsiteDataType> dataTypes, bool shouldNotifyPage, CompletionHandler<void(HashSet<String>&&)>&& completionHandler)
>+{
>+    m_networkProcess->topPrivatelyControlledDomainsWithWebsiteData(m_sessionID, dataTypes, shouldNotifyPage, WTFMove(completionHandler));
>+}
>+#endif
>+
> } // namespace WebKit
>diff --git a/Source/WebKit/NetworkProcess/NetworkSession.h b/Source/WebKit/NetworkProcess/NetworkSession.h
>index 4292db757a9381b85a4b95ce325659a7fa39c7be..e84107afde26fb902921f1000239fdd14d1ba599 100644
>--- a/Source/WebKit/NetworkProcess/NetworkSession.h
>+++ b/Source/WebKit/NetworkProcess/NetworkSession.h
>@@ -1,5 +1,5 @@
> /*
>- * Copyright (C) 2015 Apple Inc. All rights reserved.
>+ * Copyright (C) 2015-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
>@@ -35,6 +35,7 @@
> 
> namespace WebCore {
> class NetworkStorageSession;
>+enum class ShouldSample : bool;
> }
> 
> namespace WebKit {
>@@ -44,6 +45,8 @@ class NetworkProcess;
> class WebResourceLoadStatisticsStore;
> struct NetworkSessionCreationParameters;
> 
>+enum class WebsiteDataType;
>+    
> class NetworkSession : public RefCounted<NetworkSession>, public CanMakeWeakPtr<NetworkSession> {
> public:
>     static Ref<NetworkSession> create(NetworkProcess&, NetworkSessionCreationParameters&&);
>@@ -61,9 +64,16 @@ public:
>     void registerNetworkDataTask(NetworkDataTask& task) { m_dataTaskSet.add(&task); }
>     void unregisterNetworkDataTask(NetworkDataTask& task) { m_dataTaskSet.remove(&task); }
> 
>+#if ENABLE(RESOURCE_LOAD_STATISTICS)
>     WebResourceLoadStatisticsStore* resourceLoadStatistics() const { return m_resourceLoadStatistics.get(); }
>-    void enableResourceLoadStatistics();
>-    
>+    void setResourceLoadStatisticsEnabled(bool);
>+    void notifyResourceLoadStatisticsProcessed();
>+    void deleteWebsiteDataForTopPrivatelyControlledDomainsInAllPersistentDataStores(OptionSet<WebsiteDataType>, Vector<String>&& topPrivatelyControlledDomains, bool shouldNotifyPage, CompletionHandler<void(const HashSet<String>&)>&&);
>+    void topPrivatelyControlledDomainsWithWebsiteData(OptionSet<WebsiteDataType>, bool shouldNotifyPage, CompletionHandler<void(HashSet<String>&&)>&&);
>+    void logDiagnosticMessageWithValue(const String& message, const String& description, unsigned value, unsigned significantFigures, WebCore::ShouldSample);
>+    void notifyPageStatisticsTelemetryFinished(unsigned totalPrevalentResources, unsigned totalPrevalentResourcesWithUserInteraction, unsigned top3SubframeUnderTopFrameOrigins);
>+#endif
>+
> protected:
>     NetworkSession(NetworkProcess&, PAL::SessionID);
> 
>@@ -71,7 +81,9 @@ protected:
>     Ref<NetworkProcess> m_networkProcess;
>     HashSet<NetworkDataTask*> m_dataTaskSet;
>     String m_resourceLoadStatisticsDirectory;
>+#if ENABLE(RESOURCE_LOAD_STATISTICS)
>     RefPtr<WebResourceLoadStatisticsStore> m_resourceLoadStatistics;
>+#endif
> };
> 
> } // namespace WebKit
>diff --git a/Source/WebKit/NetworkProcess/cocoa/NetworkDataTaskCocoa.mm b/Source/WebKit/NetworkProcess/cocoa/NetworkDataTaskCocoa.mm
>index f8ac20acd1c33a5bdb8840dc11debd88bac017b8..a61f9385a6774bd0b75c53969ce132878b3b973f 100644
>--- a/Source/WebKit/NetworkProcess/cocoa/NetworkDataTaskCocoa.mm
>+++ b/Source/WebKit/NetworkProcess/cocoa/NetworkDataTaskCocoa.mm
>@@ -348,9 +348,8 @@ void NetworkDataTaskCocoa::willPerformHTTPRedirection(WebCore::ResourceResponse&
>     if (isTopLevelNavigation())
>         request.setFirstPartyForCookies(request.url());
> 
>-    bool shouldBlockCookies = false;
> #if ENABLE(RESOURCE_LOAD_STATISTICS)
>-    shouldBlockCookies = m_session->networkStorageSession().shouldBlockCookies(request, m_frameID, m_pageID);
>+    bool shouldBlockCookies = m_session->networkStorageSession().shouldBlockCookies(request, m_frameID, m_pageID);
> #if !RELEASE_LOG_DISABLED
>     if (m_session->shouldLogCookieInformation())
>         RELEASE_LOG_IF(isAlwaysOnLoggingAllowed(), Network, "%p - NetworkDataTaskCocoa::willPerformHTTPRedirection::logCookieInformation: pageID = %llu, frameID = %llu, taskID = %lu: %s cookies for redirect URL %s", this, m_pageID, m_frameID, (unsigned long)[m_task taskIdentifier], (shouldBlockCookies ? "Blocking" : "Not blocking"), request.url().string().utf8().data());
>@@ -378,7 +377,11 @@ void NetworkDataTaskCocoa::willPerformHTTPRedirection(WebCore::ResourceResponse&
>     if (m_client)
>         m_client->willPerformHTTPRedirection(WTFMove(redirectResponse), WTFMove(request), [completionHandler = WTFMove(completionHandler), this, protectedThis = makeRef(*this)] (auto&& request) mutable {
>             if (!request.isNull()) {
>+#if ENABLE(RESOURCE_LOAD_STATISTICS)
>                 bool shouldBlockCookies = m_session->networkStorageSession().shouldBlockCookies(request, m_frameID, m_pageID);
>+#else
>+                bool shouldBlockCookies = false;
>+#endif
>                 restrictRequestReferrerToOriginIfNeeded(request, shouldBlockCookies);
>             }
>             completionHandler(WTFMove(request));
>diff --git a/Source/WebKit/NetworkProcess/cocoa/NetworkSessionCocoa.mm b/Source/WebKit/NetworkProcess/cocoa/NetworkSessionCocoa.mm
>index 0ecd886eb40f0802b112cb77796152f518937442..932935d895bdb89321f7c8ab8214193b42ce5a57 100644
>--- a/Source/WebKit/NetworkProcess/cocoa/NetworkSessionCocoa.mm
>+++ b/Source/WebKit/NetworkProcess/cocoa/NetworkSessionCocoa.mm
>@@ -377,7 +377,7 @@ - (void)URLSession:(NSURLSession *)session task:(NSURLSessionTask *)task needNew
>     completionHandler(WebCore::createHTTPBodyNSInputStream(*body).get());
> }
> 
>-#if HAVE(CFNETWORK_WITH_IGNORE_HSTS)
>+#if HAVE(CFNETWORK_WITH_IGNORE_HSTS) && ENABLE(RESOURCE_LOAD_STATISTICS)
> static NSURLRequest* downgradeRequest(NSURLRequest *request)
> {
>     NSMutableURLRequest *nsMutableRequest = [[request mutableCopy] autorelease];
>@@ -398,7 +398,9 @@ static bool schemeWasUpgradedDueToDynamicHSTS(NSURLRequest *request)
>     return [request respondsToSelector:@selector(_schemeWasUpgradedDueToDynamicHSTS)]
>         && [request _schemeWasUpgradedDueToDynamicHSTS];
> }
>+#endif
> 
>+#if HAVE(CFNETWORK_WITH_IGNORE_HSTS)
> static void setIgnoreHSTS(NSMutableURLRequest *request, bool ignoreHSTS)
> {
>     if ([request respondsToSelector:@selector(_setIgnoreHSTS:)])
>@@ -444,7 +446,7 @@ - (void)URLSession:(NSURLSession *)session task:(NSURLSessionTask *)task willPer
>         auto completionHandlerCopy = Block_copy(completionHandler);
> 
>         bool shouldIgnoreHSTS = false;
>-#if HAVE(CFNETWORK_WITH_IGNORE_HSTS)
>+#if HAVE(CFNETWORK_WITH_IGNORE_HSTS) && ENABLE(RESOURCE_LOAD_STATISTICS)        
>         shouldIgnoreHSTS = schemeWasUpgradedDueToDynamicHSTS(request) && WebCore::NetworkStorageSession::storageSession(_session->sessionID())->shouldBlockCookies(request, networkDataTask->frameID(), networkDataTask->pageID());
>         if (shouldIgnoreHSTS) {
>             request = downgradeRequest(request);
>@@ -477,7 +479,7 @@ - (void)URLSession:(NSURLSession *)session task:(NSURLSessionTask*)task _schemeU
> 
>     if (auto* networkDataTask = [self existingTask:task]) {
>         bool shouldIgnoreHSTS = false;
>-#if HAVE(CFNETWORK_WITH_IGNORE_HSTS)
>+#if HAVE(CFNETWORK_WITH_IGNORE_HSTS) && ENABLE(RESOURCE_LOAD_STATISTICS)
>         shouldIgnoreHSTS = schemeWasUpgradedDueToDynamicHSTS(request) && WebCore::NetworkStorageSession::storageSession(_session->sessionID())->shouldBlockCookies(request, networkDataTask->frameID(), networkDataTask->pageID());
>         if (shouldIgnoreHSTS) {
>             request = downgradeRequest(request);
>@@ -944,9 +946,10 @@ NetworkSessionCocoa::NetworkSessionCocoa(NetworkProcess& networkProcess, Network
>     m_statelessSessionDelegate = adoptNS([[WKNetworkSessionDelegate alloc] initWithNetworkSession:*this withCredentials:false]);
>     m_statelessSession = [NSURLSession sessionWithConfiguration:configuration delegate:static_cast<id>(m_statelessSessionDelegate.get()) delegateQueue:[NSOperationQueue mainQueue]];
> 
>+#if ENABLE(RESOURCE_LOAD_STATISTICS)
>     m_resourceLoadStatisticsDirectory = parameters.resourceLoadStatisticsDirectory;
>-    if (parameters.enableResourceLoadStatistics)
>-        enableResourceLoadStatistics();
>+    setResourceLoadStatisticsEnabled(parameters.enableResourceLoadStatistics);
>+#endif
> }
> 
> NetworkSessionCocoa::~NetworkSessionCocoa()
>diff --git a/Source/WebKit/UIProcess/API/C/WKWebsiteDataStoreRef.cpp b/Source/WebKit/UIProcess/API/C/WKWebsiteDataStoreRef.cpp
>index 61e93c84fd46babf72325424874550d11e7a5c54..ba333c9f5fd35fd820eb855e0f525376be2f4c31 100644
>--- a/Source/WebKit/UIProcess/API/C/WKWebsiteDataStoreRef.cpp
>+++ b/Source/WebKit/UIProcess/API/C/WKWebsiteDataStoreRef.cpp
>@@ -36,7 +36,6 @@
> #include "WKSecurityOriginRef.h"
> #include "WKString.h"
> #include "WebResourceLoadStatisticsStore.h"
>-#include "WebResourceLoadStatisticsTelemetry.h"
> #include "WebsiteData.h"
> #include "WebsiteDataFetchOption.h"
> #include "WebsiteDataRecord.h"
>@@ -76,386 +75,324 @@ void WKWebsiteDataStoreSetResourceLoadStatisticsDebugMode(WKWebsiteDataStoreRef
> 
> void WKWebsiteDataStoreSetResourceLoadStatisticsDebugModeWithCompletionHandler(WKWebsiteDataStoreRef dataStoreRef, bool enable, void* context, WKWebsiteDataStoreStatisticsDebugModeFunction completionHandler)
> {
>-    auto* store = WebKit::toImpl(dataStoreRef)->websiteDataStore().resourceLoadStatistics();
>-    if (!store) {
>-        completionHandler(context);
>-        return;
>-    }
>-    
>-    store->setResourceLoadStatisticsDebugMode(enable, [context, completionHandler] {
>+#if ENABLE(RESOURCE_LOAD_STATISTICS)
>+    WebKit::toImpl(dataStoreRef)->websiteDataStore().setResourceLoadStatisticsDebugMode(enable, [context, completionHandler] {
>         completionHandler(context);
>     });
>+#else
>+    completionHandler(context);
>+#endif
> }
> 
> void WKWebsiteDataStoreSetResourceLoadStatisticsPrevalentResourceForDebugMode(WKWebsiteDataStoreRef dataStoreRef, WKStringRef host, void* context, WKWebsiteDataStoreStatisticsDebugModeFunction completionHandler)
> {
>-    auto* store = WebKit::toImpl(dataStoreRef)->websiteDataStore().resourceLoadStatistics();
>-    if (!store) {
>-        completionHandler(context);
>-        return;
>-    }
>-    
>-    store->setPrevalentResourceForDebugMode(URL(URL(), WebKit::toImpl(host)->string()), [context, completionHandler] {
>+#if ENABLE(RESOURCE_LOAD_STATISTICS)
>+    WebKit::toImpl(dataStoreRef)->websiteDataStore().setPrevalentResourceForDebugMode(URL(URL(), WebKit::toImpl(host)->string()), [context, completionHandler] {
>         completionHandler(context);
>     });
>+#else
>+    completionHandler(context);
>+#endif
> }
> void WKWebsiteDataStoreSetStatisticsLastSeen(WKWebsiteDataStoreRef dataStoreRef, WKStringRef host, double seconds, void* context, WKWebsiteDataStoreStatisticsLastSeenFunction completionHandler)
> {
>-    auto* store = WebKit::toImpl(dataStoreRef)->websiteDataStore().resourceLoadStatistics();
>-    if (!store) {
>-        completionHandler(context);
>-        return;
>-    }
>-
>-    store->setLastSeen(URL(URL(), WebKit::toImpl(host)->string()), Seconds { seconds }, [context, completionHandler] {
>+#if ENABLE(RESOURCE_LOAD_STATISTICS)
>+    WebKit::toImpl(dataStoreRef)->websiteDataStore().setLastSeen(URL(URL(), WebKit::toImpl(host)->string()), Seconds { seconds }, [context, completionHandler] {
>         completionHandler(context);
>     });
>+#else
>+    completionHandler(context);
>+#endif
> }
> 
> void WKWebsiteDataStoreSetStatisticsPrevalentResource(WKWebsiteDataStoreRef dataStoreRef, WKStringRef host, bool value, void* context, WKWebsiteDataStoreStatisticsPrevalentResourceFunction completionHandler)
> {
>-    auto* store = WebKit::toImpl(dataStoreRef)->websiteDataStore().resourceLoadStatistics();
>-    if (!store) {
>-        completionHandler(context);
>-        return;
>-    }
>+#if ENABLE(RESOURCE_LOAD_STATISTICS)
>+    auto& websiteDataStore = WebKit::toImpl(dataStoreRef)->websiteDataStore();
> 
>     if (value)
>-        store->setPrevalentResource(URL(URL(), WebKit::toImpl(host)->string()), [context, completionHandler] {
>+        websiteDataStore.setPrevalentResource(URL(URL(), WebKit::toImpl(host)->string()), [context, completionHandler] {
>             completionHandler(context);
>         });
>     else
>-        store->clearPrevalentResource(URL(URL(), WebKit::toImpl(host)->string()), [context, completionHandler] {
>+        websiteDataStore.clearPrevalentResource(URL(URL(), WebKit::toImpl(host)->string()), [context, completionHandler] {
>             completionHandler(context);
>         });
>+#else
>+    completionHandler(context);
>+#endif
> }
> 
> void WKWebsiteDataStoreSetStatisticsVeryPrevalentResource(WKWebsiteDataStoreRef dataStoreRef, WKStringRef host, bool value, void* context, WKWebsiteDataStoreStatisticsVeryPrevalentResourceFunction completionHandler)
> {
>-    auto* store = WebKit::toImpl(dataStoreRef)->websiteDataStore().resourceLoadStatistics();
>-    if (!store) {
>-        completionHandler(context);
>-        return;
>-    }
>+#if ENABLE(RESOURCE_LOAD_STATISTICS)
>+    auto& websiteDataStore = WebKit::toImpl(dataStoreRef)->websiteDataStore();
> 
>     if (value)
>-        store->setVeryPrevalentResource(URL(URL(), WebKit::toImpl(host)->string()), [context, completionHandler] {
>+        websiteDataStore.setVeryPrevalentResource(URL(URL(), WebKit::toImpl(host)->string()), [context, completionHandler] {
>             completionHandler(context);
>         });
>     else
>-        store->clearPrevalentResource(URL(URL(), WebKit::toImpl(host)->string()), [context, completionHandler] {
>+        websiteDataStore.clearPrevalentResource(URL(URL(), WebKit::toImpl(host)->string()), [context, completionHandler] {
>             completionHandler(context);
>         });
>+#else
>+    completionHandler(context);
>+#endif
> }
> 
> void WKWebsiteDataStoreDumpResourceLoadStatistics(WKWebsiteDataStoreRef dataStoreRef, void* context, WKWebsiteDataStoreDumpResourceLoadStatisticsFunction callback)
> {
>-    auto* store = WebKit::toImpl(dataStoreRef)->websiteDataStore().resourceLoadStatistics();
>-    if (!store) {
>-        callback(WebKit::toAPI(emptyString().impl()), context);
>-        return;
>-    }
>-
>-    store->dumpResourceLoadStatistics([context, callback] (const String& resourceLoadStatistics) {
>+#if ENABLE(RESOURCE_LOAD_STATISTICS)
>+    WebKit::toImpl(dataStoreRef)->websiteDataStore().dumpResourceLoadStatistics([context, callback] (const String& resourceLoadStatistics) {
>         callback(WebKit::toAPI(resourceLoadStatistics.impl()), context);
>     });
>+#else
>+    callback(WebKit::toAPI(emptyString().impl()), context);
>+#endif
> }
> 
> void WKWebsiteDataStoreIsStatisticsPrevalentResource(WKWebsiteDataStoreRef dataStoreRef, WKStringRef host, void* context, WKWebsiteDataStoreIsStatisticsPrevalentResourceFunction callback)
> {
>-    auto* store = WebKit::toImpl(dataStoreRef)->websiteDataStore().resourceLoadStatistics();
>-    if (!store) {
>-        callback(false, context);
>-        return;
>-    }
>-
>-    store->isPrevalentResource(URL(URL(), WebKit::toImpl(host)->string()), [context, callback](bool isPrevalentResource) {
>+#if ENABLE(RESOURCE_LOAD_STATISTICS)
>+    WebKit::toImpl(dataStoreRef)->websiteDataStore().isPrevalentResource(URL(URL(), WebKit::toImpl(host)->string()), [context, callback](bool isPrevalentResource) {
>         callback(isPrevalentResource, context);
>     });
>+#else
>+    callback(false, context);
>+#endif
> }
> 
> void WKWebsiteDataStoreIsStatisticsVeryPrevalentResource(WKWebsiteDataStoreRef dataStoreRef, WKStringRef host, void* context, WKWebsiteDataStoreIsStatisticsPrevalentResourceFunction callback)
> {
>-    auto* store = WebKit::toImpl(dataStoreRef)->websiteDataStore().resourceLoadStatistics();
>-    if (!store) {
>-        callback(false, context);
>-        return;
>-    }
>-    
>-    store->isVeryPrevalentResource(URL(URL(), WebKit::toImpl(host)->string()), [context, callback](bool isVeryPrevalentResource) {
>+#if ENABLE(RESOURCE_LOAD_STATISTICS)
>+    WebKit::toImpl(dataStoreRef)->websiteDataStore().isVeryPrevalentResource(URL(URL(), WebKit::toImpl(host)->string()), [context, callback](bool isVeryPrevalentResource) {
>         callback(isVeryPrevalentResource, context);
>     });
>+#else
>+    callback(false, context);
>+#endif
> }
> 
> void WKWebsiteDataStoreIsStatisticsRegisteredAsSubresourceUnder(WKWebsiteDataStoreRef dataStoreRef, WKStringRef subresourceHost, WKStringRef topFrameHost, void* context, WKWebsiteDataStoreIsStatisticsRegisteredAsSubresourceUnderFunction callback)
> {
>-    auto* store = WebKit::toImpl(dataStoreRef)->websiteDataStore().resourceLoadStatistics();
>-    if (!store) {
>-        callback(false, context);
>-        return;
>-    }
>-    
>-    store->isRegisteredAsSubresourceUnder(URL(URL(), WebKit::toImpl(subresourceHost)->string()), URL(URL(), WebKit::toImpl(topFrameHost)->string()), [context, callback](bool isRegisteredAsSubresourceUnder) {
>+#if ENABLE(RESOURCE_LOAD_STATISTICS)
>+    WebKit::toImpl(dataStoreRef)->websiteDataStore().isRegisteredAsSubresourceUnder(URL(URL(), WebKit::toImpl(subresourceHost)->string()), URL(URL(), WebKit::toImpl(topFrameHost)->string()), [context, callback](bool isRegisteredAsSubresourceUnder) {
>         callback(isRegisteredAsSubresourceUnder, context);
>     });
>+#else
>+    callback(false, context);
>+#endif
> }
> 
> void WKWebsiteDataStoreIsStatisticsRegisteredAsSubFrameUnder(WKWebsiteDataStoreRef dataStoreRef, WKStringRef subFrameHost, WKStringRef topFrameHost, void* context, WKWebsiteDataStoreIsStatisticsRegisteredAsSubFrameUnderFunction callback)
> {
>-    auto* store = WebKit::toImpl(dataStoreRef)->websiteDataStore().resourceLoadStatistics();
>-    if (!store) {
>-        callback(false, context);
>-        return;
>-    }
>-
>-    store->isRegisteredAsSubFrameUnder(URL(URL(), WebKit::toImpl(subFrameHost)->string()), URL(URL(), WebKit::toImpl(topFrameHost)->string()), [context, callback](bool isRegisteredAsSubFrameUnder) {
>+#if ENABLE(RESOURCE_LOAD_STATISTICS)
>+    WebKit::toImpl(dataStoreRef)->websiteDataStore().isRegisteredAsSubFrameUnder(URL(URL(), WebKit::toImpl(subFrameHost)->string()), URL(URL(), WebKit::toImpl(topFrameHost)->string()), [context, callback](bool isRegisteredAsSubFrameUnder) {
>         callback(isRegisteredAsSubFrameUnder, context);
>     });
>+#else
>+    callback(false, context);
>+#endif
> }
> 
> void WKWebsiteDataStoreIsStatisticsRegisteredAsRedirectingTo(WKWebsiteDataStoreRef dataStoreRef, WKStringRef hostRedirectedFrom, WKStringRef hostRedirectedTo, void* context, WKWebsiteDataStoreIsStatisticsRegisteredAsRedirectingToFunction callback)
> {
>-    auto* store = WebKit::toImpl(dataStoreRef)->websiteDataStore().resourceLoadStatistics();
>-    if (!store) {
>-        callback(false, context);
>-        return;
>-    }
>-
>-    store->isRegisteredAsRedirectingTo(URL(URL(), WebKit::toImpl(hostRedirectedFrom)->string()), URL(URL(), WebKit::toImpl(hostRedirectedTo)->string()), [context, callback](bool isRegisteredAsRedirectingTo) {
>+#if ENABLE(RESOURCE_LOAD_STATISTICS)
>+    WebKit::toImpl(dataStoreRef)->websiteDataStore().isRegisteredAsRedirectingTo(URL(URL(), WebKit::toImpl(hostRedirectedFrom)->string()), URL(URL(), WebKit::toImpl(hostRedirectedTo)->string()), [context, callback](bool isRegisteredAsRedirectingTo) {
>         callback(isRegisteredAsRedirectingTo, context);
>     });
>+#else
>+    callback(false, context);
>+#endif
> }
> 
> void WKWebsiteDataStoreSetStatisticsHasHadUserInteraction(WKWebsiteDataStoreRef dataStoreRef, WKStringRef host, bool value, void* context, WKWebsiteDataStoreStatisticsHasHadUserInteractionFunction completionHandler)
> {
>-    auto* store = WebKit::toImpl(dataStoreRef)->websiteDataStore().resourceLoadStatistics();
>-    if (!store) {
>-        completionHandler(context);
>-        return;
>-    }
>+#if ENABLE(RESOURCE_LOAD_STATISTICS)
>+    auto& dataStore = WebKit::toImpl(dataStoreRef)->websiteDataStore();
> 
>     if (value)
>-        store->logUserInteraction(URL(URL(), WebKit::toImpl(host)->string()), [context, completionHandler] {
>+        dataStore.logUserInteraction(URL(URL(), WebKit::toImpl(host)->string()), [context, completionHandler] {
>             completionHandler(context);
>         });
>     else
>-        store->clearUserInteraction(URL(URL(), WebKit::toImpl(host)->string()), [context, completionHandler] {
>+        dataStore.clearUserInteraction(URL(URL(), WebKit::toImpl(host)->string()), [context, completionHandler] {
>             completionHandler(context);
>         });
>+#else
>+    completionHandler(context);
>+#endif
> }
> 
> void WKWebsiteDataStoreIsStatisticsHasHadUserInteraction(WKWebsiteDataStoreRef dataStoreRef, WKStringRef host, void* context, WKWebsiteDataStoreIsStatisticsHasHadUserInteractionFunction callback)
> {
>-    auto* store = WebKit::toImpl(dataStoreRef)->websiteDataStore().resourceLoadStatistics();
>-    if (!store) {
>-        callback(false, context);
>-        return;
>-    }
>-
>-    store->hasHadUserInteraction(URL(URL(), WebKit::toImpl(host)->string()), [context, callback](bool hasHadUserInteraction) {
>+#if ENABLE(RESOURCE_LOAD_STATISTICS)
>+    WebKit::toImpl(dataStoreRef)->websiteDataStore().hasHadUserInteraction(URL(URL(), WebKit::toImpl(host)->string()), [context, callback](bool hasHadUserInteraction) {
>         callback(hasHadUserInteraction, context);
>     });
>+#else
>+    callback(false, context);
>+#endif
> }
> 
> void WKWebsiteDataStoreSetStatisticsGrandfathered(WKWebsiteDataStoreRef dataStoreRef, WKStringRef host, bool value)
> {
>-    auto* store = WebKit::toImpl(dataStoreRef)->websiteDataStore().resourceLoadStatistics();
>-    if (!store)
>-        return;
>-
>-    store->setGrandfathered(URL(URL(), WebKit::toImpl(host)->string()), value);
>+#if ENABLE(RESOURCE_LOAD_STATISTICS)
>+    WebKit::toImpl(dataStoreRef)->websiteDataStore().setGrandfathered(URL(URL(), WebKit::toImpl(host)->string()), value, [] { });
>+#endif
> }
> 
> void WKWebsiteDataStoreIsStatisticsGrandfathered(WKWebsiteDataStoreRef dataStoreRef, WKStringRef host, void* context, WKWebsiteDataStoreIsStatisticsGrandfatheredFunction callback)
> {
>-    auto* store = WebKit::toImpl(dataStoreRef)->websiteDataStore().resourceLoadStatistics();
>-    if (!store) {
>-        callback(false, context);
>-        return;
>-    }
>-
>-    store->hasHadUserInteraction(URL(URL(), WebKit::toImpl(host)->string()), [context, callback](bool isGrandfathered) {
>+#if ENABLE(RESOURCE_LOAD_STATISTICS)
>+    WebKit::toImpl(dataStoreRef)->websiteDataStore().hasHadUserInteraction(URL(URL(), WebKit::toImpl(host)->string()), [context, callback](bool isGrandfathered) {
>         callback(isGrandfathered, context);
>     });
>+#else
>+    callback(false, context);
>+#endif
> }
> 
> void WKWebsiteDataStoreSetStatisticsSubframeUnderTopFrameOrigin(WKWebsiteDataStoreRef dataStoreRef, WKStringRef host, WKStringRef topFrameHost)
> {
>-    auto* store = WebKit::toImpl(dataStoreRef)->websiteDataStore().resourceLoadStatistics();
>-    if (!store)
>-        return;
>-
>-    store->setSubframeUnderTopFrameOrigin(URL(URL(), WebKit::toImpl(host)->string()), URL(URL(), WebKit::toImpl(topFrameHost)->string()));
>+#if ENABLE(RESOURCE_LOAD_STATISTICS)
>+    WebKit::toImpl(dataStoreRef)->websiteDataStore().setSubframeUnderTopFrameOrigin(URL(URL(), WebKit::toImpl(host)->string()), URL(URL(), WebKit::toImpl(topFrameHost)->string()), [] { });
>+#endif
> }
> 
> void WKWebsiteDataStoreSetStatisticsSubresourceUnderTopFrameOrigin(WKWebsiteDataStoreRef dataStoreRef, WKStringRef host, WKStringRef topFrameHost)
> {
>-    auto* store = WebKit::toImpl(dataStoreRef)->websiteDataStore().resourceLoadStatistics();
>-    if (!store)
>-        return;
>-
>-    store->setSubresourceUnderTopFrameOrigin(URL(URL(), WebKit::toImpl(host)->string()), URL(URL(), WebKit::toImpl(topFrameHost)->string()));
>+#if ENABLE(RESOURCE_LOAD_STATISTICS)
>+    WebKit::toImpl(dataStoreRef)->websiteDataStore().setSubresourceUnderTopFrameOrigin(URL(URL(), WebKit::toImpl(host)->string()), URL(URL(), WebKit::toImpl(topFrameHost)->string()), [] { });
>+#endif
> }
> 
> void WKWebsiteDataStoreSetStatisticsSubresourceUniqueRedirectTo(WKWebsiteDataStoreRef dataStoreRef, WKStringRef host, WKStringRef hostRedirectedTo)
> {
>-    auto* store = WebKit::toImpl(dataStoreRef)->websiteDataStore().resourceLoadStatistics();
>-    if (!store)
>-        return;
>-
>-    store->setSubresourceUniqueRedirectTo(URL(URL(), WebKit::toImpl(host)->string()), URL(URL(), WebKit::toImpl(hostRedirectedTo)->string()));
>+#if ENABLE(RESOURCE_LOAD_STATISTICS)
>+    WebKit::toImpl(dataStoreRef)->websiteDataStore().setSubresourceUniqueRedirectTo(URL(URL(), WebKit::toImpl(host)->string()), URL(URL(), WebKit::toImpl(hostRedirectedTo)->string()), [] { });
>+#endif
> }
> 
> void WKWebsiteDataStoreSetStatisticsSubresourceUniqueRedirectFrom(WKWebsiteDataStoreRef dataStoreRef, WKStringRef host, WKStringRef hostRedirectedFrom)
> {
>-    auto* store = WebKit::toImpl(dataStoreRef)->websiteDataStore().resourceLoadStatistics();
>-    if (!store)
>-        return;
>-    
>-    store->setSubresourceUniqueRedirectFrom(URL(URL(), WebKit::toImpl(host)->string()), URL(URL(), WebKit::toImpl(hostRedirectedFrom)->string()));
>+#if ENABLE(RESOURCE_LOAD_STATISTICS)
>+    WebKit::toImpl(dataStoreRef)->websiteDataStore().setSubresourceUniqueRedirectFrom(URL(URL(), WebKit::toImpl(host)->string()), URL(URL(), WebKit::toImpl(hostRedirectedFrom)->string()), [] { });
>+#endif
> }
> 
> void WKWebsiteDataStoreSetStatisticsTopFrameUniqueRedirectTo(WKWebsiteDataStoreRef dataStoreRef, WKStringRef host, WKStringRef hostRedirectedTo)
> {
>-    auto* store = WebKit::toImpl(dataStoreRef)->websiteDataStore().resourceLoadStatistics();
>-    if (!store)
>-        return;
>-    
>-    store->setTopFrameUniqueRedirectTo(URL(URL(), WebKit::toImpl(host)->string()), URL(URL(), WebKit::toImpl(hostRedirectedTo)->string()));
>+#if ENABLE(RESOURCE_LOAD_STATISTICS)
>+    WebKit::toImpl(dataStoreRef)->websiteDataStore().setTopFrameUniqueRedirectTo(URL(URL(), WebKit::toImpl(host)->string()), URL(URL(), WebKit::toImpl(hostRedirectedTo)->string()), [] { });
>+#endif
> }
> 
> void WKWebsiteDataStoreSetStatisticsTopFrameUniqueRedirectFrom(WKWebsiteDataStoreRef dataStoreRef, WKStringRef host, WKStringRef hostRedirectedFrom)
> {
>-    auto* store = WebKit::toImpl(dataStoreRef)->websiteDataStore().resourceLoadStatistics();
>-    if (!store)
>-        return;
>-    
>-    store->setTopFrameUniqueRedirectFrom(URL(URL(), WebKit::toImpl(host)->string()), URL(URL(), WebKit::toImpl(hostRedirectedFrom)->string()));
>+#if ENABLE(RESOURCE_LOAD_STATISTICS)
>+    WebKit::toImpl(dataStoreRef)->websiteDataStore().setTopFrameUniqueRedirectFrom(URL(URL(), WebKit::toImpl(host)->string()), URL(URL(), WebKit::toImpl(hostRedirectedFrom)->string()), [] { });
>+#endif
> }
> 
> void WKWebsiteDataStoreSetStatisticsTimeToLiveUserInteraction(WKWebsiteDataStoreRef dataStoreRef, double seconds)
> {
>-    auto* store = WebKit::toImpl(dataStoreRef)->websiteDataStore().resourceLoadStatistics();
>-    if (!store)
>-        return;
>-
>-    store->setTimeToLiveUserInteraction(Seconds { seconds });
>+#if ENABLE(RESOURCE_LOAD_STATISTICS)
>+    WebKit::toImpl(dataStoreRef)->websiteDataStore().setTimeToLiveUserInteraction(Seconds { seconds }, [] { });
>+#endif
> }
> 
> void WKWebsiteDataStoreStatisticsProcessStatisticsAndDataRecords(WKWebsiteDataStoreRef dataStoreRef)
> {
>-    auto* store = WebKit::toImpl(dataStoreRef)->websiteDataStore().resourceLoadStatistics();
>-    if (!store)
>-        return;
>-
>-    store->scheduleStatisticsAndDataRecordsProcessing();
>+#if ENABLE(RESOURCE_LOAD_STATISTICS)
>+    WebKit::toImpl(dataStoreRef)->websiteDataStore().scheduleStatisticsAndDataRecordsProcessing([] { });
>+#endif
> }
> 
> void WKWebsiteDataStoreStatisticsUpdateCookieBlocking(WKWebsiteDataStoreRef dataStoreRef, void* context, WKWebsiteDataStoreStatisticsUpdateCookieBlockingFunction completionHandler)
> {
>-    auto* store = WebKit::toImpl(dataStoreRef)->websiteDataStore().resourceLoadStatistics();
>-    if (!store) {
>-        completionHandler(context);
>-        return;
>-    }
>-
>-    store->scheduleCookieBlockingUpdate([context, completionHandler]() {
>+#if ENABLE(RESOURCE_LOAD_STATISTICS)
>+    WebKit::toImpl(dataStoreRef)->websiteDataStore().scheduleCookieBlockingUpdate([context, completionHandler]() {
>         completionHandler(context);
>     });
>+#endif
> }
> 
> void WKWebsiteDataStoreStatisticsSubmitTelemetry(WKWebsiteDataStoreRef dataStoreRef)
> {
>-    auto* store = WebKit::toImpl(dataStoreRef)->websiteDataStore().resourceLoadStatistics();
>-    if (!store)
>-        return;
>-
>-    store->submitTelemetry();
>+#if ENABLE(RESOURCE_LOAD_STATISTICS)
>+    WebKit::toImpl(dataStoreRef)->websiteDataStore().submitTelemetry();
>+#endif
> }
> 
> void WKWebsiteDataStoreSetStatisticsNotifyPagesWhenDataRecordsWereScanned(WKWebsiteDataStoreRef dataStoreRef, bool value)
> {
>-    auto* store = WebKit::toImpl(dataStoreRef)->websiteDataStore().resourceLoadStatistics();
>-    if (!store)
>-        return;
>-
>-    store->setNotifyPagesWhenDataRecordsWereScanned(value);
>+#if ENABLE(RESOURCE_LOAD_STATISTICS)
>+    WebKit::toImpl(dataStoreRef)->websiteDataStore().setNotifyPagesWhenDataRecordsWereScanned(value, [] { });
>+#endif
> }
> 
> void WKWebsiteDataStoreSetStatisticsShouldClassifyResourcesBeforeDataRecordsRemoval(WKWebsiteDataStoreRef dataStoreRef, bool value)
> {
>-    auto* store = WebKit::toImpl(dataStoreRef)->websiteDataStore().resourceLoadStatistics();
>-    if (!store)
>-        return;
>-
>-    store->setShouldClassifyResourcesBeforeDataRecordsRemoval(value);
>+#if ENABLE(RESOURCE_LOAD_STATISTICS)
>+    WebKit::toImpl(dataStoreRef)->websiteDataStore().setShouldClassifyResourcesBeforeDataRecordsRemoval(value, []() { });
>+#endif
> }
> 
>-void WKWebsiteDataStoreSetStatisticsNotifyPagesWhenTelemetryWasCaptured(WKWebsiteDataStoreRef, bool value)
>+void WKWebsiteDataStoreSetStatisticsNotifyPagesWhenTelemetryWasCaptured(WKWebsiteDataStoreRef dataStoreRef, bool value)
> {
>-    WebKit::WebResourceLoadStatisticsTelemetry::setNotifyPagesWhenTelemetryWasCaptured(value);
>+#if ENABLE(RESOURCE_LOAD_STATISTICS)
>+    WebKit::toImpl(dataStoreRef)->websiteDataStore().setNotifyPagesWhenTelemetryWasCaptured(value, []() { });
>+#endif
> }
> 
> void WKWebsiteDataStoreSetStatisticsMinimumTimeBetweenDataRecordsRemoval(WKWebsiteDataStoreRef dataStoreRef, double seconds)
> {
>-    auto* store = WebKit::toImpl(dataStoreRef)->websiteDataStore().resourceLoadStatistics();
>-    if (!store)
>-        return;
>-
>-    store->setMinimumTimeBetweenDataRecordsRemoval(Seconds { seconds });
>+#if ENABLE(RESOURCE_LOAD_STATISTICS)
>+    WebKit::toImpl(dataStoreRef)->websiteDataStore().setMinimumTimeBetweenDataRecordsRemoval(Seconds { seconds }, []() { });
>+#endif
> }
> 
> void WKWebsiteDataStoreSetStatisticsGrandfatheringTime(WKWebsiteDataStoreRef dataStoreRef, double seconds)
> {
>-    auto* store = WebKit::toImpl(dataStoreRef)->websiteDataStore().resourceLoadStatistics();
>-    if (!store)
>-        return;
>-
>-    store->setGrandfatheringTime(Seconds {seconds });
>+#if ENABLE(RESOURCE_LOAD_STATISTICS)
>+    WebKit::toImpl(dataStoreRef)->websiteDataStore().setGrandfatheringTime(Seconds { seconds }, []() { });
>+#endif
> }
> 
> void WKWebsiteDataStoreSetStatisticsMaxStatisticsEntries(WKWebsiteDataStoreRef dataStoreRef, unsigned entries)
> {
>-    auto* store = WebKit::toImpl(dataStoreRef)->websiteDataStore().resourceLoadStatistics();
>-    if (!store)
>-        return;
>-
>-    store->setMaxStatisticsEntries(entries);
>+#if ENABLE(RESOURCE_LOAD_STATISTICS)
>+    WebKit::toImpl(dataStoreRef)->websiteDataStore().setMaxStatisticsEntries(entries, []() { });
>+#endif
> }
> 
> void WKWebsiteDataStoreSetStatisticsPruneEntriesDownTo(WKWebsiteDataStoreRef dataStoreRef, unsigned entries)
> {
>-    auto* store = WebKit::toImpl(dataStoreRef)->websiteDataStore().resourceLoadStatistics();
>-    if (!store)
>-        return;
>-
>-    store->setPruneEntriesDownTo(entries);
>+#if ENABLE(RESOURCE_LOAD_STATISTICS)
>+    WebKit::toImpl(dataStoreRef)->websiteDataStore().setPruneEntriesDownTo(entries, []() { });
>+#endif
> }
> 
> void WKWebsiteDataStoreStatisticsClearInMemoryAndPersistentStore(WKWebsiteDataStoreRef dataStoreRef, void* context, WKWebsiteDataStoreStatisticsClearInMemoryAndPersistentStoreFunction callback)
> {
>-    auto* store = WebKit::toImpl(dataStoreRef)->websiteDataStore().resourceLoadStatistics();
>-    if (!store) {
>-        callback(context);
>-        return;
>-    }
>-
>-    store->scheduleClearInMemoryAndPersistent(WebKit::WebResourceLoadStatisticsStore::ShouldGrandfather::Yes, [context, callback]() {
>+#if ENABLE(RESOURCE_LOAD_STATISTICS)
>+    WebKit::toImpl(dataStoreRef)->websiteDataStore().scheduleClearInMemoryAndPersistent(ShouldGrandfather::Yes, [context, callback]() {
>         callback(context);
>     });
>+#else
>+    callback(context);
>+#endif
> }
> 
> void WKWebsiteDataStoreStatisticsClearInMemoryAndPersistentStoreModifiedSinceHours(WKWebsiteDataStoreRef dataStoreRef, unsigned hours, void* context, WKWebsiteDataStoreStatisticsClearInMemoryAndPersistentStoreModifiedSinceHoursFunction callback)
> {
>-    auto* store = WebKit::toImpl(dataStoreRef)->websiteDataStore().resourceLoadStatistics();
>-    if (!store) {
>-        callback(context);
>-        return;
>-    }
>-
>-    store->scheduleClearInMemoryAndPersistent(WallTime::now() - Seconds::fromHours(hours), WebKit::WebResourceLoadStatisticsStore::ShouldGrandfather::Yes, [context, callback]() {
>+#if ENABLE(RESOURCE_LOAD_STATISTICS)
>+    WebKit::toImpl(dataStoreRef)->websiteDataStore().scheduleClearInMemoryAndPersistent(WallTime::now() - Seconds::fromHours(hours), ShouldGrandfather::Yes, [context, callback]() {
>         callback(context);
>     });
>+#endif
> }
> 
> void WKWebsiteDataStoreStatisticsClearThroughWebsiteDataRemoval(WKWebsiteDataStoreRef dataStoreRef, void* context, WKWebsiteDataStoreStatisticsClearThroughWebsiteDataRemovalFunction callback)
>@@ -475,6 +412,7 @@ void WKWebsiteDataStoreSetStatisticsCacheMaxAgeCap(WKWebsiteDataStoreRef dataSto
> 
> void WKWebsiteDataStoreStatisticsResetToConsistentState(WKWebsiteDataStoreRef dataStoreRef, void* context, WKWebsiteDataStoreStatisticsResetToConsistentStateFunction completionHandler)
> {
>+#if ENABLE(RESOURCE_LOAD_STATISTICS)
>     auto callbackAggregator = CallbackAggregator::create([context, completionHandler]() {
>         completionHandler(context);
>     });
>@@ -482,13 +420,12 @@ void WKWebsiteDataStoreStatisticsResetToConsistentState(WKWebsiteDataStoreRef da
>     auto& store = WebKit::toImpl(dataStoreRef)->websiteDataStore();
>     store.clearResourceLoadStatisticsInWebProcesses([callbackAggregator = callbackAggregator.copyRef()] { });
>     store.resetCacheMaxAgeCapForPrevalentResources([callbackAggregator = callbackAggregator.copyRef()] { });
>-
>-    auto* statisticsStore = store.resourceLoadStatistics();
>-    if (!statisticsStore)
>-        return;
>-
>-    statisticsStore->resetParametersToDefaultValues([callbackAggregator = callbackAggregator.copyRef()] { });
>-    statisticsStore->scheduleClearInMemoryAndPersistent(WebKit::WebResourceLoadStatisticsStore::ShouldGrandfather::No, [callbackAggregator = callbackAggregator.copyRef()] { });
>+    store.resetParametersToDefaultValues([callbackAggregator = callbackAggregator.copyRef()] { });
>+    store.scheduleClearInMemoryAndPersistent(ShouldGrandfather::No, [callbackAggregator = callbackAggregator.copyRef()] { });
>+#else
>+    UNUSED_PARAM(dataStoreRef);
>+    completionHandler(context);
>+#endif
> }
> 
> void WKWebsiteDataStoreRemoveAllFetchCaches(WKWebsiteDataStoreRef dataStoreRef, void* context, WKWebsiteDataStoreRemoveFetchCacheRemovalFunction callback)
>diff --git a/Source/WebKit/UIProcess/API/Cocoa/WKWebsiteDataStore.mm b/Source/WebKit/UIProcess/API/Cocoa/WKWebsiteDataStore.mm
>index e1093e4de5ab63107e65488dc6266013ef725b0a..dd567de9388d0055c1349d9ac4b1dced13b6fc79 100644
>--- a/Source/WebKit/UIProcess/API/Cocoa/WKWebsiteDataStore.mm
>+++ b/Source/WebKit/UIProcess/API/Cocoa/WKWebsiteDataStore.mm
>@@ -292,12 +292,20 @@ - (void)_setResourceLoadStatisticsEnabled:(BOOL)enabled
> 
> - (BOOL)_resourceLoadStatisticsDebugMode
> {
>+#if ENABLE(RESOURCE_LOAD_STATISTICS)
>     return _websiteDataStore->websiteDataStore().resourceLoadStatisticsDebugMode();
>+#else
>+    return NO;
>+#endif
> }
> 
> - (void)_setResourceLoadStatisticsDebugMode:(BOOL)enabled
> {
>+#if ENABLE(RESOURCE_LOAD_STATISTICS)
>     _websiteDataStore->websiteDataStore().setResourceLoadStatisticsDebugMode(enabled);
>+#else
>+    UNUSED_PARAM(enabled);
>+#endif
> }
> 
> - (NSUInteger)_cacheStoragePerOriginQuota
>@@ -362,15 +370,18 @@ - (NSDictionary *)_proxyConfiguration
> 
> - (void)_resourceLoadStatisticsSetShouldSubmitTelemetry:(BOOL)value
> {
>+#if ENABLE(RESOURCE_LOAD_STATISTICS)
>     auto* store = _websiteDataStore->websiteDataStore().resourceLoadStatistics();
>     if (!store)
>         return;
> 
>     store->setShouldSubmitTelemetry(value);
>+#endif
> }
> 
> - (void)_setResourceLoadStatisticsTestingCallback:(void (^)(WKWebsiteDataStore *, NSString *))callback
> {
>+#if ENABLE(RESOURCE_LOAD_STATISTICS)
>     if (!_websiteDataStore->isPersistent())
>         return;
> 
>@@ -381,11 +392,8 @@ - (void)_setResourceLoadStatisticsTestingCallback:(void (^)(WKWebsiteDataStore *
>         return;
>     }
> 
>-    auto* store = _websiteDataStore->websiteDataStore().resourceLoadStatistics();
>-    if (!store)
>-        return;
>-
>-    store->setStatisticsTestingCallback(nullptr);
>+    _websiteDataStore->websiteDataStore().setStatisticsTestingCallback(nullptr);
>+#endif
> }
> 
> + (void)_allowWebsiteDataRecordsForAllOrigins
>@@ -406,6 +414,7 @@ - (void)_getAllStorageAccessEntriesFor:(WKWebView *)webView completionHandler:(v
>         return;
>     }
> 
>+#if ENABLE(RESOURCE_LOAD_STATISTICS)
>     _websiteDataStore->websiteDataStore().getAllStorageAccessEntries(webPageProxy->pageID(), [completionHandler = makeBlockPtr(completionHandler)](auto domains) {
>         Vector<RefPtr<API::Object>> apiDomains;
>         apiDomains.reserveInitialCapacity(domains.size());
>@@ -413,6 +422,7 @@ - (void)_getAllStorageAccessEntriesFor:(WKWebView *)webView completionHandler:(v
>             apiDomains.uncheckedAppend(API::String::create(domain));
>         completionHandler(wrapper(API::Array::create(WTFMove(apiDomains))));
>     });
>+#endif
> }
> 
> - (bool)_hasRegisteredServiceWorker
>diff --git a/Source/WebKit/UIProcess/Cocoa/ResourceLoadStatisticsMemoryStoreCocoa.mm b/Source/WebKit/UIProcess/Cocoa/ResourceLoadStatisticsMemoryStoreCocoa.mm
>index 2e868d19a8cbf39c60ebe0d3844209f99b5d58a2..18ba8336efa5d17ad50df96703709f53d8a6b1ba 100644
>--- a/Source/WebKit/UIProcess/Cocoa/ResourceLoadStatisticsMemoryStoreCocoa.mm
>+++ b/Source/WebKit/UIProcess/Cocoa/ResourceLoadStatisticsMemoryStoreCocoa.mm
>@@ -25,6 +25,9 @@
> 
> #import "config.h"
> #import "ResourceLoadStatisticsMemoryStore.h"
>+
>+#if ENABLE(RESOURCE_LOAD_STATISTICS)
>+
> #import <wtf/text/WTFString.h>
> 
> namespace WebKit {
>@@ -62,3 +65,5 @@ void ResourceLoadStatisticsMemoryStore::registerUserDefaultsIfNeeded()
> }
> 
> }
>+
>+#endif
>diff --git a/Source/WebKit/UIProcess/Network/NetworkProcessProxy.cpp b/Source/WebKit/UIProcess/Network/NetworkProcessProxy.cpp
>index 560d6ee08448e3bd6d94d04970541760cd4e49e7..cb062f5c81c396ef75b1dd610d44946a010a14b6 100644
>--- a/Source/WebKit/UIProcess/Network/NetworkProcessProxy.cpp
>+++ b/Source/WebKit/UIProcess/Network/NetworkProcessProxy.cpp
>@@ -1,5 +1,5 @@
> /*
>- * Copyright (C) 2012-2018 Apple Inc. All rights reserved.
>+ * Copyright (C) 2012-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
>@@ -41,6 +41,8 @@
> #include "WebPageProxy.h"
> #include "WebProcessMessages.h"
> #include "WebProcessPool.h"
>+#include "WebProcessProxy.h"
>+#include "WebResourceLoadStatisticsStore.h"
> #include "WebUserContentControllerProxy.h"
> #include "WebsiteData.h"
> #include "WebsiteDataStoreClient.h"
>@@ -233,11 +235,25 @@ void NetworkProcessProxy::clearCallbackStates()
>     while (!m_pendingDeleteWebsiteDataForOriginsCallbacks.isEmpty())
>         m_pendingDeleteWebsiteDataForOriginsCallbacks.take(m_pendingDeleteWebsiteDataForOriginsCallbacks.begin()->key)();
> 
>-    while (!m_updateBlockCookiesCallbackMap.isEmpty())
>-        m_updateBlockCookiesCallbackMap.take(m_updateBlockCookiesCallbackMap.begin()->key)();
>-    
>+#if ENABLE(RESOURCE_LOAD_STATISTICS)
>+    while (!m_scheduleStatisticsProcessingCallbackMap.isEmpty())
>+        m_scheduleStatisticsProcessingCallbackMap.take(m_scheduleStatisticsProcessingCallbackMap.begin()->key)();
>+
>     while (!m_storageAccessResponseCallbackMap.isEmpty())
>         m_storageAccessResponseCallbackMap.take(m_storageAccessResponseCallbackMap.begin()->key)(false);
>+    
>+    while (!m_storageAccessRequestResponseCallbackMap.isEmpty())
>+        m_storageAccessRequestResponseCallbackMap.take(m_storageAccessRequestResponseCallbackMap.begin()->key)(StorageAccessStatus::CannotRequestAccess);
>+
>+    while (!m_removeAllStorageAccessCallbackMap.isEmpty())
>+        m_removeAllStorageAccessCallbackMap.take(m_removeAllStorageAccessCallbackMap.begin()->key)();
>+
>+    while (!m_allStorageAccessEntriesCallbackMap.isEmpty())
>+        m_allStorageAccessEntriesCallbackMap.take(m_allStorageAccessEntriesCallbackMap.begin()->key)({ });
>+
>+    while (!m_dumpStatisticsCallbackMap.isEmpty())
>+        m_dumpStatisticsCallbackMap.take(m_dumpStatisticsCallbackMap.begin()->key)({ });
>+#endif
> }
> 
> void NetworkProcessProxy::didReceiveMessage(IPC::Connection& connection, IPC::Decoder& decoder)
>@@ -274,14 +290,16 @@ void NetworkProcessProxy::didClose(IPC::Connection&)
>     m_syncAllCookiesToken = nullptr;
>     m_syncAllCookiesCounter = 0;
> 
>+#if ENABLE(RESOURCE_LOAD_STATISTICS)
>     for (auto& callback : m_removeAllStorageAccessCallbackMap.values())
>         callback();
>     m_removeAllStorageAccessCallbackMap.clear();
> 
>-    for (auto& callback : m_updateBlockCookiesCallbackMap.values())
>+    for (auto& callback : m_scheduleStatisticsProcessingCallbackMap.values())
>         callback();
>-    m_updateBlockCookiesCallbackMap.clear();
>-    
>+    m_scheduleStatisticsProcessingCallbackMap.clear();
>+#endif
>+
>     // This will cause us to be deleted.
>     networkProcessCrashed();
> }
>@@ -400,7 +418,33 @@ void NetworkProcessProxy::logDiagnosticMessageWithValue(uint64_t pageID, const S
>     page->logDiagnosticMessageWithValue(message, description, value, significantFigures, shouldSample);
> }
> 
>+void NetworkProcessProxy::logGlobalDiagnosticMessageWithValue(const String& message, const String& description, double value, unsigned significantFigures, WebCore::ShouldSample shouldSample)
>+{
>+    if (auto* page = WebPageProxy::nonEphemeralWebPageProxy())
>+        page->logDiagnosticMessageWithValue(message, description, value, significantFigures, shouldSample);
>+}
>+
> #if ENABLE(RESOURCE_LOAD_STATISTICS)
>+void NetworkProcessProxy::dumpResourceLoadStatistics(PAL::SessionID sessionID, CompletionHandler<void(const String&)>&& completionHandler)
>+{
>+    if (!canSendMessage()) {
>+        completionHandler({ });
>+        return;
>+    }
>+    
>+    auto callbackId = generateCallbackID();
>+    auto addResult = m_dumpStatisticsCallbackMap.add(callbackId, [protectedProcessPool = makeRef(m_processPool), token = throttler().backgroundActivityToken(), completionHandler = WTFMove(completionHandler)](const String& dumpedStatistics) mutable {
>+        completionHandler(dumpedStatistics);
>+    });
>+    ASSERT_UNUSED(addResult, addResult.isNewEntry);
>+    send(Messages::NetworkProcess::DumpResourceLoadStatistics(sessionID, callbackId), 0);
>+}
>+
>+void NetworkProcessProxy::didDumpResourceLoadStatistics(String dumpedStatistics, uint64_t callbackId)
>+{
>+    m_dumpStatisticsCallbackMap.take(callbackId)(dumpedStatistics);
>+}
>+
> void NetworkProcessProxy::updatePrevalentDomainsToBlockCookiesFor(PAL::SessionID sessionID, const Vector<String>& domainsToBlock, CompletionHandler<void()>&& completionHandler)
> {
>     if (!canSendMessage()) {
>@@ -409,7 +453,7 @@ void NetworkProcessProxy::updatePrevalentDomainsToBlockCookiesFor(PAL::SessionID
>     }
>     
>     auto callbackId = generateCallbackID();
>-    auto addResult = m_updateBlockCookiesCallbackMap.add(callbackId, [protectedProcessPool = makeRef(m_processPool), token = throttler().backgroundActivityToken(), completionHandler = WTFMove(completionHandler)]() mutable {
>+    auto addResult = m_scheduleStatisticsProcessingCallbackMap.add(callbackId, [protectedProcessPool = makeRef(m_processPool), token = throttler().backgroundActivityToken(), completionHandler = WTFMove(completionHandler)]() mutable {
>         completionHandler();
>     });
>     ASSERT_UNUSED(addResult, addResult.isNewEntry);
>@@ -418,13 +462,138 @@ void NetworkProcessProxy::updatePrevalentDomainsToBlockCookiesFor(PAL::SessionID
> 
> void NetworkProcessProxy::didUpdateBlockCookies(uint64_t callbackId)
> {
>-    m_updateBlockCookiesCallbackMap.take(callbackId)();
>+    m_scheduleStatisticsProcessingCallbackMap.take(callbackId)();
>+}
>+
>+void NetworkProcessProxy::isPrevalentResource(PAL::SessionID sessionID, const String& resourceDomain, CompletionHandler<void(bool)>&& completionHandler)
>+{
>+    if (!canSendMessage()) {
>+        completionHandler(false);
>+        return;
>+    }
>+
>+    sendWithAsyncReply(Messages::NetworkProcess::IsPrevalentResource(sessionID, resourceDomain), WTFMove(completionHandler));
>+}
>+
>+void NetworkProcessProxy::isVeryPrevalentResource(PAL::SessionID sessionID, const String& resourceDomain, CompletionHandler<void(bool)>&& completionHandler)
>+{
>+    if (!canSendMessage()) {
>+        completionHandler(false);
>+        return;
>+    }
>+
>+    sendWithAsyncReply(Messages::NetworkProcess::IsVeryPrevalentResource(sessionID, resourceDomain), WTFMove(completionHandler));
>+}
>+
>+void NetworkProcessProxy::setPrevalentResource(PAL::SessionID sessionID, const String& resourceDomain, CompletionHandler<void()>&& completionHandler)
>+{
>+    if (!canSendMessage()) {
>+        completionHandler();
>+        return;
>+    }
>+
>+    sendWithAsyncReply(Messages::NetworkProcess::SetPrevalentResource(sessionID, resourceDomain), WTFMove(completionHandler));
>+}
>+
>+void NetworkProcessProxy::setPrevalentResourceForDebugMode(PAL::SessionID sessionID, const String& resourceDomain, CompletionHandler<void()>&& completionHandler)
>+{
>+    if (!canSendMessage()) {
>+        completionHandler();
>+        return;
>+    }
>+
>+    sendWithAsyncReply(Messages::NetworkProcess::SetPrevalentResourceForDebugMode(sessionID, resourceDomain), WTFMove(completionHandler));
> }
> 
>-void NetworkProcessProxy::didLogUserInteraction(uint64_t contextId)
>+void NetworkProcessProxy::setVeryPrevalentResource(PAL::SessionID sessionID, const String& resourceDomain, CompletionHandler<void()>&& completionHandler)
> {
>-    // FIXME(193297): Implement when activating automated test cases.
>-    UNUSED_PARAM(contextId);
>+    if (!canSendMessage()) {
>+        completionHandler();
>+        return;
>+    }
>+
>+    sendWithAsyncReply(Messages::NetworkProcess::SetVeryPrevalentResource(sessionID, resourceDomain), WTFMove(completionHandler));
>+}
>+
>+void NetworkProcessProxy::setLastSeen(PAL::SessionID sessionID, const String& resourceDomain, Seconds lastSeen, CompletionHandler<void()>&& completionHandler)
>+{
>+    if (!canSendMessage()) {
>+        completionHandler();
>+        return;
>+    }
>+    
>+    sendWithAsyncReply(Messages::NetworkProcess::SetLastSeen(sessionID, resourceDomain, lastSeen), WTFMove(completionHandler));
>+}
>+
>+void NetworkProcessProxy::clearPrevalentResource(PAL::SessionID sessionID, const String& resourceDomain, CompletionHandler<void()>&& completionHandler)
>+{
>+    if (!canSendMessage()) {
>+        completionHandler();
>+        return;
>+    }
>+    
>+    sendWithAsyncReply(Messages::NetworkProcess::ClearPrevalentResource(sessionID, resourceDomain), WTFMove(completionHandler));
>+}
>+    
>+void NetworkProcessProxy::scheduleCookieBlockingUpdate(PAL::SessionID sessionID, CompletionHandler<void()>&& completionHandler)
>+{
>+    if (!canSendMessage()) {
>+        completionHandler();
>+        return;
>+    }
>+    
>+    sendWithAsyncReply(Messages::NetworkProcess::ScheduleCookieBlockingUpdate(sessionID), WTFMove(completionHandler));
>+}
>+
>+void NetworkProcessProxy::scheduleClearInMemoryAndPersistent(PAL::SessionID sessionID, Optional<WallTime> modifiedSince, ShouldGrandfather shouldGrandfather, CompletionHandler<void()>&& completionHandler)
>+{
>+    if (!canSendMessage()) {
>+        completionHandler();
>+        return;
>+    }
>+
>+    bool shouldGrandfatherBool = shouldGrandfather == ShouldGrandfather::Yes;
>+    sendWithAsyncReply(Messages::NetworkProcess::ScheduleClearInMemoryAndPersistent(sessionID, modifiedSince, shouldGrandfatherBool), WTFMove(completionHandler));
>+}
>+
>+void NetworkProcessProxy::scheduleStatisticsAndDataRecordsProcessing(PAL::SessionID sessionID, CompletionHandler<void()>&& completionHandler)
>+{
>+    if (!canSendMessage()) {
>+        completionHandler();
>+        return;
>+    }
>+    
>+    sendWithAsyncReply(Messages::NetworkProcess::ScheduleStatisticsAndDataRecordsProcessing(sessionID), WTFMove(completionHandler));
>+}
>+
>+void NetworkProcessProxy::logUserInteraction(PAL::SessionID sessionID, const String& resourceDomain, CompletionHandler<void()>&& completionHandler)
>+{
>+    if (!canSendMessage()) {
>+        completionHandler();
>+        return;
>+    }
>+
>+    sendWithAsyncReply(Messages::NetworkProcess::LogUserInteraction(sessionID, resourceDomain), WTFMove(completionHandler));
>+}
>+
>+void NetworkProcessProxy::hasHadUserInteraction(PAL::SessionID sessionID, const String& resourceDomain, CompletionHandler<void(bool)>&& completionHandler)
>+{
>+    if (!canSendMessage()) {
>+        completionHandler(false);
>+        return;
>+    }
>+    
>+    sendWithAsyncReply(Messages::NetworkProcess::HadUserInteraction(sessionID, resourceDomain), WTFMove(completionHandler));
>+}
>+
>+void NetworkProcessProxy::clearUserInteraction(PAL::SessionID sessionID, const String& resourceDomain, CompletionHandler<void()>&& completionHandler)
>+{
>+    if (!canSendMessage()) {
>+        completionHandler();
>+        return;
>+    }
>+    
>+    sendWithAsyncReply(Messages::NetworkProcess::ClearUserInteraction(sessionID, resourceDomain), WTFMove(completionHandler));
> }
> 
> void NetworkProcessProxy::setAgeCapForClientSideCookies(PAL::SessionID sessionID, Optional<Seconds> seconds, CompletionHandler<void()>&& completionHandler)
>@@ -435,7 +604,7 @@ void NetworkProcessProxy::setAgeCapForClientSideCookies(PAL::SessionID sessionID
>     }
>     
>     auto callbackId = generateCallbackID();
>-    auto addResult = m_updateBlockCookiesCallbackMap.add(callbackId, [protectedProcessPool = makeRef(m_processPool), token = throttler().backgroundActivityToken(), completionHandler = WTFMove(completionHandler)]() mutable {
>+    auto addResult = m_scheduleStatisticsProcessingCallbackMap.add(callbackId, [protectedProcessPool = makeRef(m_processPool), token = throttler().backgroundActivityToken(), completionHandler = WTFMove(completionHandler)]() mutable {
>         completionHandler();
>     });
>     ASSERT_UNUSED(addResult, addResult.isNewEntry);
>@@ -444,29 +613,211 @@ void NetworkProcessProxy::setAgeCapForClientSideCookies(PAL::SessionID sessionID
> 
> void NetworkProcessProxy::didSetAgeCapForClientSideCookies(uint64_t callbackId)
> {
>-    m_updateBlockCookiesCallbackMap.take(callbackId)();
>+    m_scheduleStatisticsProcessingCallbackMap.take(callbackId)();
>+}
>+
>+void NetworkProcessProxy::setTimeToLiveUserInteraction(PAL::SessionID sessionID, Seconds seconds, CompletionHandler<void()>&& completionHandler)
>+{
>+    if (!canSendMessage()) {
>+        completionHandler();
>+        return;
>+    }
>+    
>+    sendWithAsyncReply(Messages::NetworkProcess::SetTimeToLiveUserInteraction(sessionID, seconds), WTFMove(completionHandler));
>+}
>+
>+void NetworkProcessProxy::didUpdateRuntimeSettings(uint64_t callbackId)
>+{
>+    m_updateRuntimeSettingsCallbackMap.take(callbackId)();
>+}
>+
>+void NetworkProcessProxy::setNotifyPagesWhenTelemetryWasCaptured(PAL::SessionID sessionID, bool value, CompletionHandler<void()>&& completionHandler)
>+{
>+    if (!canSendMessage()) {
>+        completionHandler();
>+        return;
>+    }
>+    
>+    sendWithAsyncReply(Messages::NetworkProcess::SetNotifyPagesWhenTelemetryWasCaptured(sessionID, value), WTFMove(completionHandler));
>+}
>+
>+void NetworkProcessProxy::setNotifyPagesWhenDataRecordsWereScanned(PAL::SessionID sessionID, bool value, CompletionHandler<void()>&& completionHandler)
>+{
>+    if (!canSendMessage()) {
>+        completionHandler();
>+        return;
>+    }
>+    
>+    sendWithAsyncReply(Messages::NetworkProcess::SetNotifyPagesWhenDataRecordsWereScanned(sessionID, value), WTFMove(completionHandler));
>+}
>+
>+void NetworkProcessProxy::setSubframeUnderTopFrameOrigin(PAL::SessionID sessionID, const String& subframe, const String& topFrame, CompletionHandler<void()>&& completionHandler)
>+{
>+    if (!canSendMessage()) {
>+        completionHandler();
>+        return;
>+    }
>+    
>+    sendWithAsyncReply(Messages::NetworkProcess::SetSubframeUnderTopFrameOrigin(sessionID, subframe, topFrame), WTFMove(completionHandler));
>+}
>+
>+void NetworkProcessProxy::isRegisteredAsRedirectingTo(PAL::SessionID sessionID, const String& redirectedFrom, const String& redirectedTo, CompletionHandler<void(bool)>&& completionHandler)
>+{
>+    if (!canSendMessage()) {
>+        completionHandler(false);
>+        return;
>+    }
>+    
>+    sendWithAsyncReply(Messages::NetworkProcess::IsRegisteredAsRedirectingTo(sessionID, redirectedFrom, redirectedTo), WTFMove(completionHandler));
>+}
>+
>+void NetworkProcessProxy::isRegisteredAsSubFrameUnder(PAL::SessionID sessionID, const String& subFrame, const String& topFrame, CompletionHandler<void(bool)>&& completionHandler)
>+{
>+    if (!canSendMessage()) {
>+        completionHandler(false);
>+        return;
>+    }
>+    
>+    sendWithAsyncReply(Messages::NetworkProcess::IsRegisteredAsSubFrameUnder(sessionID, subFrame, topFrame), WTFMove(completionHandler));
>+}
>+
>+void NetworkProcessProxy::setSubresourceUnderTopFrameOrigin(PAL::SessionID sessionID, const String& subresource, const String& topFrame, CompletionHandler<void()>&& completionHandler)
>+{
>+    if (!canSendMessage()) {
>+        completionHandler();
>+        return;
>+    }
>+    
>+    sendWithAsyncReply(Messages::NetworkProcess::SetSubresourceUnderTopFrameOrigin(sessionID, subresource, topFrame), WTFMove(completionHandler));
>+}
>+
>+void NetworkProcessProxy::isRegisteredAsSubresourceUnder(PAL::SessionID sessionID, const String& subresource, const String& topFrame, CompletionHandler<void(bool)>&& completionHandler)
>+{
>+    if (!canSendMessage()) {
>+        completionHandler(false);
>+        return;
>+    }
>+    
>+    sendWithAsyncReply(Messages::NetworkProcess::IsRegisteredAsSubresourceUnder(sessionID, subresource, topFrame), WTFMove(completionHandler));
>+}
>+
>+void NetworkProcessProxy::setSubresourceUniqueRedirectTo(PAL::SessionID sessionID, const String& subresource, const String& hostNameRedirectedTo, CompletionHandler<void()>&& completionHandler)
>+{
>+    if (!canSendMessage()) {
>+        completionHandler();
>+        return;
>+    }
>+    
>+    sendWithAsyncReply(Messages::NetworkProcess::SetSubresourceUniqueRedirectTo(sessionID, subresource, hostNameRedirectedTo), WTFMove(completionHandler));
>+}
>+
>+void NetworkProcessProxy::setSubresourceUniqueRedirectFrom(PAL::SessionID sessionID, const String& subresource, const String& hostNameRedirectedFrom, CompletionHandler<void()>&& completionHandler)
>+{
>+    if (!canSendMessage()) {
>+        completionHandler();
>+        return;
>+    }
>+    
>+    sendWithAsyncReply(Messages::NetworkProcess::SetSubresourceUniqueRedirectFrom(sessionID, subresource, hostNameRedirectedFrom), WTFMove(completionHandler));
>+}
>+
>+void NetworkProcessProxy::setTopFrameUniqueRedirectTo(PAL::SessionID sessionID, const String& topFrameHostName, const String& hostNameRedirectedTo, CompletionHandler<void()>&& completionHandler)
>+{
>+    if (!canSendMessage()) {
>+        completionHandler();
>+        return;
>+    }
>+    
>+    sendWithAsyncReply(Messages::NetworkProcess::SetTopFrameUniqueRedirectTo(sessionID, topFrameHostName, hostNameRedirectedTo), WTFMove(completionHandler));
>+}
>+
>+void NetworkProcessProxy::setTopFrameUniqueRedirectFrom(PAL::SessionID sessionID, const String& topFrameHostName, const String& hostNameRedirectedFrom, CompletionHandler<void()>&& completionHandler)
>+{
>+    if (!canSendMessage()) {
>+        completionHandler();
>+        return;
>+    }
>+    
>+    sendWithAsyncReply(Messages::NetworkProcess::SetTopFrameUniqueRedirectFrom(sessionID, topFrameHostName, hostNameRedirectedFrom), WTFMove(completionHandler));
>+}
>+
>+void NetworkProcessProxy::isGrandfathered(PAL::SessionID sessionID, const String& resourceDomain, CompletionHandler<void(bool)>&& completionHandler)
>+{
>+    if (!canSendMessage()) {
>+        completionHandler(false);
>+        return;
>+    }
>+    
>+    sendWithAsyncReply(Messages::NetworkProcess::IsGrandfathered(sessionID, resourceDomain), WTFMove(completionHandler));
>+}
>+
>+void NetworkProcessProxy::setGrandfathered(PAL::SessionID sessionID, const String& resourceDomain, bool isGrandfathered, CompletionHandler<void()>&& completionHandler)
>+{
>+    if (!canSendMessage()) {
>+        completionHandler();
>+        return;
>+    }
>+    
>+    sendWithAsyncReply(Messages::NetworkProcess::SetGrandfathered(sessionID, resourceDomain, isGrandfathered), WTFMove(completionHandler));
> }
> 
> void NetworkProcessProxy::hasStorageAccessForFrame(PAL::SessionID sessionID, const String& resourceDomain, const String& firstPartyDomain, uint64_t frameID, uint64_t pageID, WTF::CompletionHandler<void(bool)>&& callback)
> {
>+    if (!canSendMessage()) {
>+        callback(false);
>+        return;
>+    }
>+
>     auto contextId = generateCallbackID();
>     auto addResult = m_storageAccessResponseCallbackMap.add(contextId, WTFMove(callback));
>     ASSERT_UNUSED(addResult, addResult.isNewEntry);
>     send(Messages::NetworkProcess::HasStorageAccessForFrame(sessionID, resourceDomain, firstPartyDomain, frameID, pageID, contextId), 0);
> }
> 
>-void NetworkProcessProxy::grantStorageAccess(PAL::SessionID sessionID, const String& resourceDomain, const String& firstPartyDomain, Optional<uint64_t> frameID, uint64_t pageID, WTF::CompletionHandler<void(bool)>&& callback)
>+void NetworkProcessProxy::hasStorageAccess(PAL::SessionID sessionID, const String& resourceDomain, const String& firstPartyDomain, Optional<uint64_t> frameID, uint64_t pageID, CompletionHandler<void(bool)>&& completionHandler)
>+{
>+    if (!canSendMessage()) {
>+        completionHandler(false);
>+        return;
>+    }
>+    
>+    sendWithAsyncReply(Messages::NetworkProcess::HasStorageAccess(sessionID, resourceDomain, firstPartyDomain, frameID, pageID), WTFMove(completionHandler));
>+}
>+
>+void NetworkProcessProxy::requestStorageAccess(PAL::SessionID sessionID, const String& resourceDomain, const String& firstPartyDomain, Optional<uint64_t> frameID, uint64_t pageID, bool promptEnabled, CompletionHandler<void(StorageAccessStatus)>&& completionHandler)
> {
>+    if (!canSendMessage()) {
>+        completionHandler(StorageAccessStatus::CannotRequestAccess);
>+        return;
>+    }
>+
>     auto contextId = generateCallbackID();
>-    auto addResult = m_storageAccessResponseCallbackMap.add(contextId, WTFMove(callback));
>+    auto addResult = m_storageAccessRequestResponseCallbackMap.add(contextId, WTFMove(completionHandler));
>     ASSERT_UNUSED(addResult, addResult.isNewEntry);
>-    send(Messages::NetworkProcess::GrantStorageAccess(sessionID, resourceDomain, firstPartyDomain, frameID, pageID, contextId), 0);
>+    send(Messages::NetworkProcess::RequestStorageAccess(sessionID, resourceDomain, firstPartyDomain, frameID, pageID, promptEnabled, contextId), 0);
> }
> 
>-void NetworkProcessProxy::storageAccessRequestResult(bool wasGranted, uint64_t contextId)
>+void NetworkProcessProxy::grantStorageAccess(PAL::SessionID sessionID, const String& resourceDomain, const String& firstPartyDomain, Optional<uint64_t> frameID, uint64_t pageID, bool userWasPrompted, WTF::CompletionHandler<void(bool)>&& completionHandler)
> {
>-    auto callback = m_storageAccessResponseCallbackMap.take(contextId);
>-    callback(wasGranted);
>+    if (!canSendMessage()) {
>+        completionHandler(false);
>+        return;
>+    }
>+
>+    auto contextId = generateCallbackID();
>+    auto addResult = m_storageAccessResponseCallbackMap.add(contextId, WTFMove(completionHandler));
>+    ASSERT_UNUSED(addResult, addResult.isNewEntry);
>+    send(Messages::NetworkProcess::GrantStorageAccess(sessionID, resourceDomain, firstPartyDomain, frameID.value(), pageID, userWasPrompted, contextId), 0);
>+}
>+
>+void NetworkProcessProxy::storageAccessRequestResult(unsigned status, uint64_t contextId)
>+{
>+    m_storageAccessRequestResponseCallbackMap.take(contextId)(static_cast<StorageAccessStatus>(status));
>+}
>+
>+void NetworkProcessProxy::storageAccessOperationResult(bool wasGranted, uint64_t contextId)
>+{
>+    m_storageAccessResponseCallbackMap.take(contextId)(wasGranted);
> }
> 
> void NetworkProcessProxy::removeAllStorageAccess(PAL::SessionID sessionID, CompletionHandler<void()>&& completionHandler)
>@@ -484,12 +835,16 @@ void NetworkProcessProxy::removeAllStorageAccess(PAL::SessionID sessionID, Compl
> 
> void NetworkProcessProxy::didRemoveAllStorageAccess(uint64_t contextId)
> {
>-    auto completionHandler = m_removeAllStorageAccessCallbackMap.take(contextId);
>-    completionHandler();
>+    m_removeAllStorageAccessCallbackMap.take(contextId)();
> }
> 
> void NetworkProcessProxy::getAllStorageAccessEntries(PAL::SessionID sessionID, CompletionHandler<void(Vector<String>&& domains)>&& callback)
> {
>+    if (!canSendMessage()) {
>+        callback({ });
>+        return;
>+    }
>+
>     auto contextId = generateCallbackID();
>     auto addResult = m_allStorageAccessEntriesCallbackMap.add(contextId, WTFMove(callback));
>     ASSERT_UNUSED(addResult, addResult.isNewEntry);
>@@ -517,8 +872,80 @@ void NetworkProcessProxy::setCacheMaxAgeCapForPrevalentResources(PAL::SessionID
> 
> void NetworkProcessProxy::didSetCacheMaxAgeCapForPrevalentResources(uint64_t contextId)
> {
>-    auto completionHandler = m_updateRuntimeSettingsCallbackMap.take(contextId);
>-    completionHandler();
>+    m_updateRuntimeSettingsCallbackMap.take(contextId)();
>+}
>+
>+void NetworkProcessProxy::setCacheMaxAgeCap(PAL::SessionID sessionID, Seconds seconds, CompletionHandler<void()>&& completionHandler)
>+{
>+    if (!canSendMessage()) {
>+        completionHandler();
>+        return;
>+    }
>+    
>+    auto contextId = generateCallbackID();
>+    auto addResult = m_updateRuntimeSettingsCallbackMap.add(contextId, WTFMove(completionHandler));
>+    ASSERT_UNUSED(addResult, addResult.isNewEntry);
>+    send(Messages::NetworkProcess::SetCacheMaxAgeCapForPrevalentResources(sessionID, seconds, contextId), 0);
>+}
>+
>+void NetworkProcessProxy::setGrandfatheringTime(PAL::SessionID sessionID, Seconds seconds, CompletionHandler<void()>&& completionHandler)
>+{
>+    if (!canSendMessage()) {
>+        completionHandler();
>+        return;
>+    }
>+    
>+    sendWithAsyncReply(Messages::NetworkProcess::SetGrandfatheringTime(sessionID, seconds), WTFMove(completionHandler));
>+}
>+
>+void NetworkProcessProxy::setMaxStatisticsEntries(PAL::SessionID sessionID, size_t maximumEntryCount, CompletionHandler<void()>&& completionHandler)
>+{
>+    if (!canSendMessage()) {
>+        completionHandler();
>+        return;
>+    }
>+
>+    sendWithAsyncReply(Messages::NetworkProcess::SetMaxStatisticsEntries(sessionID, maximumEntryCount), WTFMove(completionHandler));
>+}
>+
>+void NetworkProcessProxy::setMinimumTimeBetweenDataRecordsRemoval(PAL::SessionID sessionID, Seconds seconds, CompletionHandler<void()>&& completionHandler)
>+{
>+    if (!canSendMessage()) {
>+        completionHandler();
>+        return;
>+    }
>+    
>+    sendWithAsyncReply(Messages::NetworkProcess::SetMinimumTimeBetweenDataRecordsRemoval(sessionID, seconds), WTFMove(completionHandler));
>+}
>+
>+void NetworkProcessProxy::setPruneEntriesDownTo(PAL::SessionID sessionID, size_t pruneTargetCount, CompletionHandler<void()>&& completionHandler)
>+{
>+    if (!canSendMessage()) {
>+        completionHandler();
>+        return;
>+    }
>+
>+    sendWithAsyncReply(Messages::NetworkProcess::SetPruneEntriesDownTo(sessionID, pruneTargetCount), WTFMove(completionHandler));
>+}
>+
>+void NetworkProcessProxy::setShouldClassifyResourcesBeforeDataRecordsRemoval(PAL::SessionID sessionID, bool value, CompletionHandler<void()>&& completionHandler)
>+{
>+    if (!canSendMessage()) {
>+        completionHandler();
>+        return;
>+    }
>+    
>+    sendWithAsyncReply(Messages::NetworkProcess::SetShouldClassifyResourcesBeforeDataRecordsRemoval(sessionID, value), WTFMove(completionHandler));
>+}
>+
>+void NetworkProcessProxy::setResourceLoadStatisticsDebugMode(PAL::SessionID sessionID, bool debugMode, CompletionHandler<void()>&& completionHandler)
>+{
>+    if (!canSendMessage()) {
>+        completionHandler();
>+        return;
>+    }
>+    
>+    sendWithAsyncReply(Messages::NetworkProcess::SetResourceLoadStatisticsDebugMode(sessionID, debugMode), WTFMove(completionHandler));
> }
> 
> void NetworkProcessProxy::resetCacheMaxAgeCapForPrevalentResources(PAL::SessionID sessionID, CompletionHandler<void()>&& completionHandler)
>@@ -534,10 +961,60 @@ void NetworkProcessProxy::resetCacheMaxAgeCapForPrevalentResources(PAL::SessionI
>     send(Messages::NetworkProcess::ResetCacheMaxAgeCapForPrevalentResources(sessionID, contextId), 0);
> }
> 
>-void NetworkProcessProxy::didResetCacheMaxAgeCapForPrevalentResources(uint64_t contextId)
>+void NetworkProcessProxy::resetParametersToDefaultValues(PAL::SessionID sessionID, CompletionHandler<void()>&& completionHandler)
>+{
>+    if (!canSendMessage()) {
>+        completionHandler();
>+        return;
>+    }
>+    
>+    sendWithAsyncReply(Messages::NetworkProcess::ResetParametersToDefaultValues(sessionID), WTFMove(completionHandler));
>+}
>+
>+void NetworkProcessProxy::submitTelemetry(PAL::SessionID sessionID, CompletionHandler<void()>&& completionHandler)
>+{
>+    if (!canSendMessage()) {
>+        completionHandler();
>+        return;
>+    }
>+    
>+    sendWithAsyncReply(Messages::NetworkProcess::SubmitTelemetry(sessionID), WTFMove(completionHandler));
>+}
>+
>+void NetworkProcessProxy::scheduleClearInMemoryAndPersistent(PAL::SessionID sessionID, bool shouldGrandfather, CompletionHandler<void()>&& completionHandler)
> {
>-    auto completionHandler = m_updateRuntimeSettingsCallbackMap.take(contextId);
>-    completionHandler();
>+    if (!canSendMessage()) {
>+        completionHandler();
>+        return;
>+    }
>+    
>+
>+    sendWithAsyncReply(Messages::NetworkProcess::ScheduleClearInMemoryAndPersistent(sessionID, { }, shouldGrandfather), WTFMove(completionHandler));
>+}
>+
>+void NetworkProcessProxy::notifyResourceLoadStatisticsProcessed()
>+{
>+    WebProcessProxy::notifyPageStatisticsAndDataRecordsProcessed();
>+}
>+
>+void NetworkProcessProxy::notifyWebsiteDataDeletionForTopPrivatelyOwnedDomainsFinished()
>+{
>+    WebProcessProxy::notifyWebsiteDataDeletionForTopPrivatelyOwnedDomainsFinished();
>+}
>+
>+void NetworkProcessProxy::notifyWebsiteDataScanForTopPrivatelyControlledDomainsFinished()
>+{
>+    WebProcessProxy::notifyWebsiteDataScanForTopPrivatelyControlledDomainsFinished();
>+}
>+
>+void NetworkProcessProxy::notifyResourceLoadStatisticsTelemetryFinished(unsigned totalPrevalentResources, unsigned totalPrevalentResourcesWithUserInteraction, unsigned top3SubframeUnderTopFrameOrigins)
>+{
>+    API::Dictionary::MapType messageBody;
>+    messageBody.set("TotalPrevalentResources"_s, API::UInt64::create(totalPrevalentResources));
>+    messageBody.set("TotalPrevalentResourcesWithUserInteraction"_s, API::UInt64::create(totalPrevalentResourcesWithUserInteraction));
>+    messageBody.set("Top3SubframeUnderTopFrameOrigins"_s, API::UInt64::create(top3SubframeUnderTopFrameOrigins));
>+
>+    WebProcessProxy::notifyPageStatisticsTelemetryFinished(API::Dictionary::create(messageBody).ptr());
> }
> #endif // ENABLE(RESOURCE_LOAD_STATISTICS)
> 
>diff --git a/Source/WebKit/UIProcess/Network/NetworkProcessProxy.h b/Source/WebKit/UIProcess/Network/NetworkProcessProxy.h
>index bfa8b8c57a0bf16cfe04b37388453be0ed978cd2..e351a06b75ad78e50995fa1f8fd8bba38ebb0a9e 100644
>--- a/Source/WebKit/UIProcess/Network/NetworkProcessProxy.h
>+++ b/Source/WebKit/UIProcess/Network/NetworkProcessProxy.h
>@@ -57,6 +57,7 @@ namespace WebKit {
> class DownloadProxy;
> class DownloadProxyMap;
> class WebProcessPool;
>+enum class StorageAccessStatus : unsigned;
> enum class WebsiteDataFetchOption;
> enum class WebsiteDataType;
> struct NetworkProcessCreationParameters;
>@@ -77,13 +78,53 @@ public:
>     void deleteWebsiteDataForOrigins(PAL::SessionID, OptionSet<WebKit::WebsiteDataType>, const Vector<WebCore::SecurityOriginData>& origins, const Vector<String>& cookieHostNames, const Vector<String>& HSTSCacheHostNames, CompletionHandler<void()>&&);
> 
> #if ENABLE(RESOURCE_LOAD_STATISTICS)
>+    void clearPrevalentResource(PAL::SessionID, const String& resourceDomain, CompletionHandler<void()>&&);
>+    void clearUserInteraction(PAL::SessionID, const String& resourceDomain, CompletionHandler<void()>&&);
>+    void dumpResourceLoadStatistics(PAL::SessionID, CompletionHandler<void(const String&)>&&);
>     void updatePrevalentDomainsToBlockCookiesFor(PAL::SessionID, const Vector<String>& domainsToBlock, CompletionHandler<void()>&&);
>+    void hasHadUserInteraction(PAL::SessionID, const String& resourceDomain, CompletionHandler<void(bool)>&&);
>+    void isGrandfathered(PAL::SessionID, const String& resourceDomain, CompletionHandler<void(bool)>&&);
>+    void isPrevalentResource(PAL::SessionID, const String& resourceDomain, CompletionHandler<void(bool)>&&);
>+    void isRegisteredAsRedirectingTo(PAL::SessionID, const String& redirectedFrom, const String& redirectedTo, CompletionHandler<void(bool)>&&);
>+    void isRegisteredAsSubFrameUnder(PAL::SessionID, const String& subFrame, const String& topFrame, CompletionHandler<void(bool)>&&);
>+    void isRegisteredAsSubresourceUnder(PAL::SessionID, const String& subresource, const String& topFrame, CompletionHandler<void(bool)>&&);
>+    void isVeryPrevalentResource(PAL::SessionID, const String& resourceDomain, CompletionHandler<void(bool)>&&);
>+    void logUserInteraction(PAL::SessionID, const String& resourceDomain, CompletionHandler<void()>&&);
>+    void scheduleStatisticsAndDataRecordsProcessing(PAL::SessionID, CompletionHandler<void()>&&);
>+    void setLastSeen(PAL::SessionID, const String& resourceDomain, Seconds, CompletionHandler<void()>&&);
>     void setAgeCapForClientSideCookies(PAL::SessionID, Optional<Seconds>, CompletionHandler<void()>&&);
>+    void setCacheMaxAgeCap(PAL::SessionID, Seconds, CompletionHandler<void()>&&);
>+    void setGrandfathered(PAL::SessionID, const String& resourceDomain, bool isGrandfathered, CompletionHandler<void()>&&);
>+    void setNotifyPagesWhenDataRecordsWereScanned(PAL::SessionID, bool, CompletionHandler<void()>&&);
>+    void setNotifyPagesWhenTelemetryWasCaptured(PAL::SessionID, bool, CompletionHandler<void()>&&);
>+    void setSubframeUnderTopFrameOrigin(PAL::SessionID, const String& subframe, const String& topFrame, CompletionHandler<void()>&&);
>+    void setSubresourceUnderTopFrameOrigin(PAL::SessionID, const String& subresource, const String& topFrame, CompletionHandler<void()>&&);
>+    void setSubresourceUniqueRedirectTo(PAL::SessionID, const String& subresource, const String& hostNameRedirectedTo, CompletionHandler<void()>&&);
>+    void setSubresourceUniqueRedirectFrom(PAL::SessionID, const String& subresource, const String& hostNameRedirectedFrom, CompletionHandler<void()>&&);
>+    void setTimeToLiveUserInteraction(PAL::SessionID, Seconds, CompletionHandler<void()>&&);
>+    void setTopFrameUniqueRedirectTo(PAL::SessionID, const String& topFrameHostName, const String& hostNameRedirectedTo, CompletionHandler<void()>&&);
>+    void setTopFrameUniqueRedirectFrom(PAL::SessionID, const String& topFrameHostName, const String& hostNameRedirectedFrom, CompletionHandler<void()>&&);
>+    void setPrevalentResource(PAL::SessionID, const String& resourceDomain, CompletionHandler<void()>&&);
>+    void setPrevalentResourceForDebugMode(PAL::SessionID, const String& resourceDomain, CompletionHandler<void()>&&);
>+    void setVeryPrevalentResource(PAL::SessionID, const String& resourceDomain, CompletionHandler<void()>&&);
>     void hasStorageAccessForFrame(PAL::SessionID, const String& resourceDomain, const String& firstPartyDomain, uint64_t frameID, uint64_t pageID, CompletionHandler<void(bool)>&& callback);
>     void getAllStorageAccessEntries(PAL::SessionID, CompletionHandler<void(Vector<String>&& domains)>&&);
>-    void grantStorageAccess(PAL::SessionID, const String& resourceDomain, const String& firstPartyDomain, Optional<uint64_t> frameID, uint64_t pageID, CompletionHandler<void(bool)>&& callback);
>+    void grantStorageAccess(PAL::SessionID, const String& resourceDomain, const String& firstPartyDomain, Optional<uint64_t> frameID, uint64_t pageID, bool userWasPrompted, WTF::CompletionHandler<void(bool)>&&);
>+    void hasStorageAccess(PAL::SessionID, const String& subFrameHost, const String& topFrameHost, Optional<uint64_t> frameID, uint64_t pageID, CompletionHandler<void(bool)>&&);
>+    void requestStorageAccess(PAL::SessionID, const String& resourceDomain, const String& firstPartyDomain, Optional<uint64_t> frameID, uint64_t pageID, bool promptEnabled, CompletionHandler<void(StorageAccessStatus)>&&);
>+    void resetParametersToDefaultValues(PAL::SessionID, CompletionHandler<void()>&&);
>     void removeAllStorageAccess(PAL::SessionID, CompletionHandler<void()>&&);
>+    void scheduleClearInMemoryAndPersistent(PAL::SessionID, bool shouldGrandfather, CompletionHandler<void()>&&);
>+    void scheduleClearInMemoryAndPersistent(PAL::SessionID, Optional<WallTime> modifiedSince, ShouldGrandfather, CompletionHandler<void()>&&);
>+    void scheduleCookieBlockingUpdate(PAL::SessionID, CompletionHandler<void()>&&);
>+    void submitTelemetry(PAL::SessionID, CompletionHandler<void()>&&);
>     void setCacheMaxAgeCapForPrevalentResources(PAL::SessionID, Seconds, CompletionHandler<void()>&&);
>+    void setGrandfatheringTime(PAL::SessionID, Seconds, CompletionHandler<void()>&&);
>+    void setMaxStatisticsEntries(PAL::SessionID, size_t maximumEntryCount, CompletionHandler<void()>&&);
>+    void setMinimumTimeBetweenDataRecordsRemoval(PAL::SessionID, Seconds, CompletionHandler<void()>&&);
>+    void setPruneEntriesDownTo(PAL::SessionID, size_t pruneTargetCount, CompletionHandler<void()>&&);
>+    void setResourceLoadStatisticsDebugMode(PAL::SessionID, bool debugMode, CompletionHandler<void()>&&);
>+    void setShouldClassifyResourcesBeforeDataRecordsRemoval(PAL::SessionID, bool, CompletionHandler<void()>&&);
>     void resetCacheMaxAgeCapForPrevalentResources(PAL::SessionID, CompletionHandler<void()>&&);
> #endif
> 
>@@ -141,15 +182,21 @@ private:
>     void logDiagnosticMessage(uint64_t pageID, const String& message, const String& description, WebCore::ShouldSample);
>     void logDiagnosticMessageWithResult(uint64_t pageID, const String& message, const String& description, uint32_t result, WebCore::ShouldSample);
>     void logDiagnosticMessageWithValue(uint64_t pageID, const String& message, const String& description, double value, unsigned significantFigures, WebCore::ShouldSample);
>+    void logGlobalDiagnosticMessageWithValue(const String& message, const String& description, double value, unsigned significantFigures, WebCore::ShouldSample);
> #if ENABLE(RESOURCE_LOAD_STATISTICS)
>-    void didLogUserInteraction(uint64_t contextId);
>+    void didDumpResourceLoadStatistics(String dumpedStatistics, uint64_t callbackId);
>     void didUpdateBlockCookies(uint64_t contextId);
>     void didSetAgeCapForClientSideCookies(uint64_t contextId);
>-    void storageAccessRequestResult(bool wasGranted, uint64_t contextId);
>+    void storageAccessOperationResult(bool wasGranted, uint64_t contextId);
>+    void storageAccessRequestResult(unsigned wasGranted, uint64_t contextId);
>     void allStorageAccessEntriesResult(Vector<String>&& domains, uint64_t contextId);
>     void didRemoveAllStorageAccess(uint64_t contextId);
>     void didSetCacheMaxAgeCapForPrevalentResources(uint64_t contextId);
>-    void didResetCacheMaxAgeCapForPrevalentResources(uint64_t contextId);
>+    void didUpdateRuntimeSettings(uint64_t contextId);
>+    void notifyResourceLoadStatisticsProcessed();
>+    void notifyWebsiteDataDeletionForTopPrivatelyOwnedDomainsFinished();
>+    void notifyWebsiteDataScanForTopPrivatelyControlledDomainsFinished();
>+    void notifyResourceLoadStatisticsTelemetryFinished(unsigned totalPrevalentResources, unsigned totalPrevalentResourcesWithUserInteraction, unsigned top3SubframeUnderTopFrameOrigins);
> #endif
>     void retrieveCacheStorageParameters(PAL::SessionID);
> 
>@@ -192,10 +239,14 @@ private:
>     
>     unsigned m_syncAllCookiesCounter { 0 };
> 
>-    HashMap<uint64_t, CompletionHandler<void()>> m_updateBlockCookiesCallbackMap;
>+#if ENABLE(RESOURCE_LOAD_STATISTICS)
>+    HashMap<uint64_t, CompletionHandler<void()>> m_scheduleStatisticsProcessingCallbackMap;
>     HashMap<uint64_t, CompletionHandler<void(bool wasGranted)>> m_storageAccessResponseCallbackMap;
>+    HashMap<uint64_t, CompletionHandler<void(StorageAccessStatus wasGranted)>> m_storageAccessRequestResponseCallbackMap;
>     HashMap<uint64_t, CompletionHandler<void()>> m_removeAllStorageAccessCallbackMap;
>     HashMap<uint64_t, CompletionHandler<void(Vector<String>&& domains)>> m_allStorageAccessEntriesCallbackMap;
>+    HashMap<uint64_t, CompletionHandler<void(const String&)>> m_dumpStatisticsCallbackMap;
>+#endif
> 
>     HashMap<uint64_t, CompletionHandler<void()>> m_updateRuntimeSettingsCallbackMap;
> 
>diff --git a/Source/WebKit/UIProcess/Network/NetworkProcessProxy.messages.in b/Source/WebKit/UIProcess/Network/NetworkProcessProxy.messages.in
>index 959267cc4fbc2815eec06d7ad5b7216ddb4ce837..84e0e8f644118ec47374e2dcb38e43ea13c88e35 100644
>--- a/Source/WebKit/UIProcess/Network/NetworkProcessProxy.messages.in
>+++ b/Source/WebKit/UIProcess/Network/NetworkProcessProxy.messages.in
>@@ -38,16 +38,22 @@ messages -> NetworkProcessProxy LegacyReceiver {
>     LogDiagnosticMessage(uint64_t pageID, String message, String description, enum:bool WebCore::ShouldSample shouldSample)
>     LogDiagnosticMessageWithResult(uint64_t pageID, String message, String description, uint32_t result, enum:bool WebCore::ShouldSample shouldSample)
>     LogDiagnosticMessageWithValue(uint64_t pageID, String message, String description, double value, unsigned significantFigures, enum:bool WebCore::ShouldSample shouldSample)
>+    LogGlobalDiagnosticMessageWithValue(String message, String description, double value, unsigned significantFigures, enum:bool WebCore::ShouldSample shouldSample)
> 
> #if ENABLE(RESOURCE_LOAD_STATISTICS)
>-    DidLogUserInteraction(uint64_t callbackId)
>+    DidDumpResourceLoadStatistics(String dumpedStatistics, uint64_t callbackId)
>     DidUpdateBlockCookies(uint64_t callbackId)
>     DidSetAgeCapForClientSideCookies(uint64_t callbackId)
>-    StorageAccessRequestResult(bool wasGranted, uint64_t contextId)
>+    StorageAccessOperationResult(bool wasGranted, uint64_t contextId)
>+    StorageAccessRequestResult(unsigned wasGranted, uint64_t contextId)
>     AllStorageAccessEntriesResult(Vector<String> domains, uint64_t contextId)
>     DidRemoveAllStorageAccess(uint64_t contextId)
>     DidSetCacheMaxAgeCapForPrevalentResources(uint64_t contextId)
>-    DidResetCacheMaxAgeCapForPrevalentResources(uint64_t contextId)
>+    DidUpdateRuntimeSettings(uint64_t contextId)
>+    NotifyResourceLoadStatisticsProcessed()
>+    NotifyWebsiteDataDeletionForTopPrivatelyOwnedDomainsFinished()
>+    NotifyWebsiteDataScanForTopPrivatelyControlledDomainsFinished()
>+    NotifyResourceLoadStatisticsTelemetryFinished(unsigned totalPrevalentResources, unsigned totalPrevalentResourcesWithUserInteraction, unsigned top3SubframeUnderTopFrameOrigins)
> #endif
> #if ENABLE(CONTENT_EXTENSIONS)
>     ContentExtensionRules(WebKit::UserContentControllerIdentifier identifier)
>diff --git a/Source/WebKit/UIProcess/WebPageProxy.cpp b/Source/WebKit/UIProcess/WebPageProxy.cpp
>index b91faaf74493bc9859f4c1d6b437f150e5328f5a..e74f38dc59b400d4026e2cad3c659e0525b43c9a 100644
>--- a/Source/WebKit/UIProcess/WebPageProxy.cpp
>+++ b/Source/WebKit/UIProcess/WebPageProxy.cpp
>@@ -4480,6 +4480,26 @@ void WebPageProxy::decidePolicyForNavigationAction(Ref<WebProcessProxy>&& proces
>     m_shouldSuppressAppLinksInNextNavigationPolicyDecision = false;
> }
> 
>+WebPageProxy* WebPageProxy::nonEphemeralWebPageProxy()
>+{
>+    auto processPools = WebProcessPool::allProcessPools();
>+    if (processPools.isEmpty())
>+        return nullptr;
>+    
>+    auto processPool = processPools[0];
>+    if (!processPool)
>+        return nullptr;
>+    
>+    for (auto& webProcess : processPool->processes()) {
>+        for (auto& page : webProcess->pages()) {
>+            if (page->sessionID().isEphemeral())
>+                continue;
>+            return page;
>+        }
>+    }
>+    return nullptr;
>+}
>+
> #if ENABLE(RESOURCE_LOAD_STATISTICS)
> void WebPageProxy::logFrameNavigation(const WebFrameProxy& frame, const URL& pageURL, const WebCore::ResourceRequest& request, const URL& redirectURL)
> {
>diff --git a/Source/WebKit/UIProcess/WebPageProxy.h b/Source/WebKit/UIProcess/WebPageProxy.h
>index 773eb8da2640925de0746f7520e0863056a9a572..ac5600f62acc6a36ed30e02a9fd724301be0bf4c 100644
>--- a/Source/WebKit/UIProcess/WebPageProxy.h
>+++ b/Source/WebKit/UIProcess/WebPageProxy.h
>@@ -1,5 +1,5 @@
> /*
>- * Copyright (C) 2010-2018 Apple Inc. All rights reserved.
>+ * Copyright (C) 2010-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
>@@ -1383,6 +1383,8 @@ public:
>     void requestStorageAccess(String&& subFrameHost, String&& topFrameHost, uint64_t frameID, uint64_t webProcessContextId, bool prompt);
> #endif
> 
>+    static WebPageProxy* nonEphemeralWebPageProxy();
>+
> #if ENABLE(ATTACHMENT_ELEMENT)
>     RefPtr<API::Attachment> attachmentForIdentifier(const String& identifier) const;
>     void insertAttachment(Ref<API::Attachment>&&, Function<void(CallbackBase::Error)>&&);
>diff --git a/Source/WebKit/UIProcess/WebProcessPool.cpp b/Source/WebKit/UIProcess/WebProcessPool.cpp
>index a628aff568e876097d1b9756c03f366a60abaf0a..23c58fa9d1058dc0e0c5af3b31c678fe4cfb27fd 100644
>--- a/Source/WebKit/UIProcess/WebProcessPool.cpp
>+++ b/Source/WebKit/UIProcess/WebProcessPool.cpp
>@@ -560,7 +560,7 @@ NetworkProcessProxy& WebProcessPool::ensureNetworkProcess(WebsiteDataStore* with
> 
>     SandboxExtension::createHandleForReadWriteDirectory(parameters.defaultDataStoreParameters.networkSessionParameters.resourceLoadStatisticsDirectory, parameters.defaultDataStoreParameters.networkSessionParameters.resourceLoadStatisticsDirectoryExtensionHandle);
> 
>-    parameters.defaultDataStoreParameters.networkSessionParameters.enableResourceLoadStatistics = false; // FIXME(193297): Turn on when the feature is on.
>+    parameters.defaultDataStoreParameters.networkSessionParameters.enableResourceLoadStatistics = false; // FIXME(193297): Turn on when the feature is on. (m_configuration->resourceLoadStatisticsEnabled()?)
> 
>     // Add any platform specific parameters
>     platformInitializeNetworkProcess(parameters);
>diff --git a/Source/WebKit/UIProcess/WebProcessProxy.cpp b/Source/WebKit/UIProcess/WebProcessProxy.cpp
>index 1b3f80c1783d474072c2732dc239ab17f32de200..d93f60532266e60b402375324516635a52ea50fd 100644
>--- a/Source/WebKit/UIProcess/WebProcessProxy.cpp
>+++ b/Source/WebKit/UIProcess/WebProcessProxy.cpp
>@@ -284,6 +284,7 @@ WebPageProxy* WebProcessProxy::webPage(uint64_t pageID)
>     return globalPageMap().get(pageID);
> }
> 
>+#if ENABLE(RESOURCE_LOAD_STATISTICS)
> void WebProcessProxy::deleteWebsiteDataForTopPrivatelyControlledDomainsInAllPersistentDataStores(OptionSet<WebsiteDataType> dataTypes, Vector<String>&& topPrivatelyControlledDomains, bool shouldNotifyPage, CompletionHandler<void (const HashSet<String>&)>&& completionHandler)
> {
>     // We expect this to be called on the main thread so we get the default website data store.
>@@ -417,13 +418,26 @@ void WebProcessProxy::notifyPageStatisticsAndDataRecordsProcessed()
>     for (auto& page : globalPageMap())
>         page.value->postMessageToInjectedBundle("WebsiteDataScanForTopPrivatelyControlledDomainsFinished", nullptr);
> }
>-    
>+
>+void WebProcessProxy::notifyWebsiteDataScanForTopPrivatelyControlledDomainsFinished()
>+{
>+    for (auto& page : globalPageMap())
>+        page.value->postMessageToInjectedBundle("WebsiteDataScanForTopPrivatelyControlledDomainsFinished", nullptr);
>+}
>+
>+void WebProcessProxy::notifyWebsiteDataDeletionForTopPrivatelyOwnedDomainsFinished()
>+{
>+    for (auto& page : globalPageMap())
>+        page.value->postMessageToInjectedBundle("WebsiteDataDeletionForTopPrivatelyOwnedDomainsFinished", nullptr);
>+}
>+
> void WebProcessProxy::notifyPageStatisticsTelemetryFinished(API::Object* messageBody)
> {
>     for (auto& page : globalPageMap())
>         page.value->postMessageToInjectedBundle("ResourceLoadStatisticsTelemetryFinished", messageBody);
> }
>-    
>+#endif
>+
> Ref<WebPageProxy> WebProcessProxy::createWebPage(PageClient& pageClient, Ref<API::PageConfiguration>&& pageConfiguration)
> {
>     uint64_t pageID = generatePageID();
>diff --git a/Source/WebKit/UIProcess/WebProcessProxy.h b/Source/WebKit/UIProcess/WebProcessProxy.h
>index ff9e52cc31f0f808a3f03d6c1cc9b0c783f21749..575ab4ddbf56836e037455f7d774fc28398adee2 100644
>--- a/Source/WebKit/UIProcess/WebProcessProxy.h
>+++ b/Source/WebKit/UIProcess/WebProcessProxy.h
>@@ -171,11 +171,18 @@ public:
>     void fetchWebsiteData(PAL::SessionID, OptionSet<WebsiteDataType>, CompletionHandler<void(WebsiteData)>&&);
>     void deleteWebsiteData(PAL::SessionID, OptionSet<WebsiteDataType>, WallTime modifiedSince, CompletionHandler<void()>&&);
>     void deleteWebsiteDataForOrigins(PAL::SessionID, OptionSet<WebsiteDataType>, const Vector<WebCore::SecurityOriginData>&, CompletionHandler<void()>&&);
>+
>+#if ENABLE(RESOURCE_LOAD_STATISTICS)
>     static void deleteWebsiteDataForTopPrivatelyControlledDomainsInAllPersistentDataStores(OptionSet<WebsiteDataType>, Vector<String>&& topPrivatelyControlledDomains, bool shouldNotifyPages, CompletionHandler<void (const HashSet<String>&)>&&);
>     static void topPrivatelyControlledDomainsWithWebsiteData(OptionSet<WebsiteDataType> dataTypes, bool shouldNotifyPage, CompletionHandler<void(HashSet<String>&&)>&&);
>+
>     static void notifyPageStatisticsAndDataRecordsProcessed();
>     static void notifyPageStatisticsTelemetryFinished(API::Object* messageBody);
> 
>+    static void notifyWebsiteDataDeletionForTopPrivatelyOwnedDomainsFinished();
>+    static void notifyWebsiteDataScanForTopPrivatelyControlledDomainsFinished();
>+#endif
>+
>     void enableSuddenTermination();
>     void disableSuddenTermination();
>     bool isSuddenTerminationEnabled() { return !m_numberOfTimesSuddenTerminationWasDisabled; }
>@@ -266,7 +273,7 @@ protected:
> #endif
> 
>     bool isJITEnabled() const final;
>-    
>+
> private:
>     // IPC message handlers.
>     void updateBackForwardItem(const BackForwardListItemState&);
>diff --git a/Source/WebKit/UIProcess/WebResourceLoadStatisticsStore.messages.in b/Source/WebKit/UIProcess/WebResourceLoadStatisticsStore.messages.in
>index 6e85c215c04c0d0c7d906cd740e4d44a5cacf231..aa7dc906c0a339eb629ecc8643205927b71357b3 100644
>--- a/Source/WebKit/UIProcess/WebResourceLoadStatisticsStore.messages.in
>+++ b/Source/WebKit/UIProcess/WebResourceLoadStatisticsStore.messages.in
>@@ -20,7 +20,11 @@
> # 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.
> 
>+#if ENABLE(RESOURCE_LOAD_STATISTICS)
>+
> messages -> WebResourceLoadStatisticsStore {
>     RequestStorageAccessUnderOpener(String domainReceivingUserInteraction, uint64_t openerPageID, String openerDomain)
>     ResourceLoadStatisticsUpdated(Vector<WebCore::ResourceLoadStatistics> origins)
> }
>+
>+#endif
>diff --git a/Source/WebKit/UIProcess/WebsiteData/Cocoa/WebsiteDataStoreCocoa.mm b/Source/WebKit/UIProcess/WebsiteData/Cocoa/WebsiteDataStoreCocoa.mm
>index 069d4b9b0ac366f2ad80083ad8ce518aaf569fac..427a9c85a3b9845ae4f754fb4c7a39263c8c17c9 100644
>--- a/Source/WebKit/UIProcess/WebsiteData/Cocoa/WebsiteDataStoreCocoa.mm
>+++ b/Source/WebKit/UIProcess/WebsiteData/Cocoa/WebsiteDataStoreCocoa.mm
>@@ -154,8 +154,10 @@ void WebsiteDataStore::platformInitialize()
>         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();
>+#endif
>             }
>         }];
>     }
>@@ -166,8 +168,10 @@ void WebsiteDataStore::platformInitialize()
> 
> void WebsiteDataStore::platformDestroy()
> {
>+#if ENABLE(RESOURCE_LOAD_STATISTICS)
>     if (m_resourceLoadStatistics)
>         m_resourceLoadStatistics->applicationWillTerminate();
>+#endif
> 
>     if (!m_storageManager)
>         return;
>diff --git a/Source/WebKit/UIProcess/WebsiteData/WebsiteDataStore.cpp b/Source/WebKit/UIProcess/WebsiteData/WebsiteDataStore.cpp
>index f75851b1c6ae82cec9a8c9530aeb2b94c2ba47fd..21c27b8318105fc61baaf6f00663b6e25e6690fa 100644
>--- a/Source/WebKit/UIProcess/WebsiteData/WebsiteDataStore.cpp
>+++ b/Source/WebKit/UIProcess/WebsiteData/WebsiteDataStore.cpp
>@@ -1,5 +1,5 @@
> /*
>- * Copyright (C) 2014-2017 Apple Inc. All rights reserved.
>+ * Copyright (C) 2014-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
>@@ -130,7 +130,9 @@ WebsiteDataStore::~WebsiteDataStore()
> 
>     platformDestroy();
> 
>+#if ENABLE(RESOURCE_LOAD_STATISTICS)
>     unregisterWebResourceLoadStatisticsStoreAsMessageReceiver();
>+#endif
> 
>     if (m_sessionID.isValid() && m_sessionID != PAL::SessionID::defaultSessionID()) {
>         ASSERT(nonDefaultDataStores().get(m_sessionID) == this);
>@@ -613,6 +615,7 @@ void WebsiteDataStore::fetchDataAndApply(OptionSet<WebsiteDataType> dataTypes, O
>     callbackAggregator->callIfNeeded();
> }
> 
>+#if ENABLE(RESOURCE_LOAD_STATISTICS)
> void WebsiteDataStore::fetchDataForTopPrivatelyControlledDomains(OptionSet<WebsiteDataType> dataTypes, OptionSet<WebsiteDataFetchOption> fetchOptions, const Vector<String>& topPrivatelyControlledDomains, Function<void(Vector<WebsiteDataRecord>&&, HashSet<String>&&)>&& completionHandler)
> {
>     fetchDataAndApply(dataTypes, fetchOptions, m_queue.copyRef(), [topPrivatelyControlledDomains = crossThreadCopy(topPrivatelyControlledDomains), completionHandler = WTFMove(completionHandler)] (auto&& existingDataRecords) mutable {
>@@ -648,6 +651,7 @@ void WebsiteDataStore::topPrivatelyControlledDomainsWithWebsiteData(OptionSet<We
>         completionHandler(WTFMove(domainsWithDataRecords));
>     });
> }
>+#endif
> 
> static ProcessAccessType computeNetworkProcessAccessTypeForDataRemoval(OptionSet<WebsiteDataType> dataTypes, bool isNonPersistentStore)
> {
>@@ -925,27 +929,37 @@ void WebsiteDataStore::removeData(OptionSet<WebsiteDataType> dataTypes, WallTime
>     }
> #endif
> 
>-    if (dataTypes.contains(WebsiteDataType::ResourceLoadStatistics) && m_resourceLoadStatistics) {
>+#if ENABLE(RESOURCE_LOAD_STATISTICS)
>+    if (dataTypes.contains(WebsiteDataType::ResourceLoadStatistics)) {
>         auto deletedTypesRaw = dataTypes.toRaw();
>         auto monitoredTypesRaw = WebResourceLoadStatisticsStore::monitoredDataTypes().toRaw();
>         
>         // If we are deleting all of the data types that the resource load statistics store monitors
>         // we do not need to re-grandfather old data.
>+        auto shouldGrandfather = ((monitoredTypesRaw & deletedTypesRaw) == monitoredTypesRaw) ? ShouldGrandfather::No : ShouldGrandfather::Yes;
>+        
>         callbackAggregator->addPendingCallback();
>-        if ((monitoredTypesRaw & deletedTypesRaw) == monitoredTypesRaw)
>-            m_resourceLoadStatistics->scheduleClearInMemoryAndPersistent(modifiedSince, WebResourceLoadStatisticsStore::ShouldGrandfather::No, [callbackAggregator] {
>-                callbackAggregator->removePendingCallback();
>-            });
>-        else
>-            m_resourceLoadStatistics->scheduleClearInMemoryAndPersistent(modifiedSince, WebResourceLoadStatisticsStore::ShouldGrandfather::Yes, [callbackAggregator] {
>+
>+        if (m_resourceLoadStatistics) {
>+            m_resourceLoadStatistics->scheduleClearInMemoryAndPersistent(modifiedSince, shouldGrandfather, [callbackAggregator] {
>                 callbackAggregator->removePendingCallback();
>             });
>+        } else {
>+            for (auto& processPool : processPools()) {
>+                if (auto* process = processPool->networkProcess()) {
>+                    process->deleteWebsiteData(m_sessionID, dataTypes, modifiedSince, [callbackAggregator] {
>+                        callbackAggregator->removePendingCallback();
>+                    });
>+                }
>+            }
>+        }
> 
>         callbackAggregator->addPendingCallback();
>         clearResourceLoadStatisticsInWebProcesses([callbackAggregator] {
>             callbackAggregator->removePendingCallback();
>         });
>     }
>+#endif
> 
>     // There's a chance that we don't have any pending callbacks. If so, we want to dispatch the completion handler right away.
>     callbackAggregator->callIfNeeded();
>@@ -1221,6 +1235,7 @@ void WebsiteDataStore::removeData(OptionSet<WebsiteDataType> dataTypes, const Ve
>     }
> #endif
> 
>+#if ENABLE(RESOURCE_LOAD_STATISTICS)
>     // FIXME <rdar://problem/33491222>; scheduleClearInMemoryAndPersistent does not have a completion handler,
>     // so the completion handler for this removeData() call can be called prematurely.
>     if (dataTypes.contains(WebsiteDataType::ResourceLoadStatistics) && m_resourceLoadStatistics) {
>@@ -1231,11 +1246,11 @@ void WebsiteDataStore::removeData(OptionSet<WebsiteDataType> dataTypes, const Ve
>         // we do not need to re-grandfather old data.
>         callbackAggregator->addPendingCallback();
>         if ((monitoredTypesRaw & deletedTypesRaw) == monitoredTypesRaw)
>-            m_resourceLoadStatistics->scheduleClearInMemoryAndPersistent(WebResourceLoadStatisticsStore::ShouldGrandfather::No, [callbackAggregator] {
>+            m_resourceLoadStatistics->scheduleClearInMemoryAndPersistent(ShouldGrandfather::No, [callbackAggregator] {
>                 callbackAggregator->removePendingCallback();
>             });
>         else
>-            m_resourceLoadStatistics->scheduleClearInMemoryAndPersistent(WebResourceLoadStatisticsStore::ShouldGrandfather::Yes, [callbackAggregator] {
>+            m_resourceLoadStatistics->scheduleClearInMemoryAndPersistent(ShouldGrandfather::Yes, [callbackAggregator] {
>                 callbackAggregator->removePendingCallback();
>             });
> 
>@@ -1244,11 +1259,13 @@ void WebsiteDataStore::removeData(OptionSet<WebsiteDataType> dataTypes, const Ve
>             callbackAggregator->removePendingCallback();
>         });
>     }
>+#endif
> 
>     // There's a chance that we don't have any pending callbacks. If so, we want to dispatch the completion handler right away.
>     callbackAggregator->callIfNeeded();
> }
> 
>+#if ENABLE(RESOURCE_LOAD_STATISTICS)
> void WebsiteDataStore::removeDataForTopPrivatelyControlledDomains(OptionSet<WebsiteDataType> dataTypes, OptionSet<WebsiteDataFetchOption> fetchOptions, const Vector<String>& topPrivatelyControlledDomains, Function<void(HashSet<String>&&)>&& completionHandler)
> {
>     fetchDataForTopPrivatelyControlledDomains(dataTypes, fetchOptions, topPrivatelyControlledDomains, [dataTypes, completionHandler = WTFMove(completionHandler), this, protectedThis = makeRef(*this)](Vector<WebsiteDataRecord>&& websiteDataRecords, HashSet<String>&& domainsWithDataRecords) mutable {
>@@ -1258,179 +1275,938 @@ void WebsiteDataStore::removeDataForTopPrivatelyControlledDomains(OptionSet<Webs
>     });
> }
> 
>-#if ENABLE(RESOURCE_LOAD_STATISTICS)
>-void WebsiteDataStore::updatePrevalentDomainsToBlockCookiesFor(const Vector<String>& domainsToBlock, CompletionHandler<void()>&& completionHandler)
>+void WebsiteDataStore::setMaxStatisticsEntries(size_t maximumEntryCount, CompletionHandler<void()>&& completionHandler)
> {
>+    ASSERT(RunLoop::isMain());
>+
>+    if (m_resourceLoadStatistics) {
>+        m_resourceLoadStatistics->setMaxStatisticsEntries(maximumEntryCount, WTFMove(completionHandler));
>+        return;
>+    }
>+    
>     auto callbackAggregator = CallbackAggregator::create(WTFMove(completionHandler));
> 
>     for (auto& processPool : processPools()) {
>         if (auto* process = processPool->networkProcess())
>-            process->updatePrevalentDomainsToBlockCookiesFor(m_sessionID, domainsToBlock, [processPool, callbackAggregator = callbackAggregator.copyRef()] { });
>+            process->setMaxStatisticsEntries(m_sessionID, maximumEntryCount, [processPool, callbackAggregator = callbackAggregator.copyRef()] { });
>     }
> }
> 
>-void WebsiteDataStore::setAgeCapForClientSideCookies(Optional<Seconds> seconds, CompletionHandler<void()>&& completionHandler)
>+void WebsiteDataStore::setPruneEntriesDownTo(size_t pruneTargetCount, CompletionHandler<void()>&& completionHandler)
> {
>-    auto callbackAggregator = CallbackAggregator::create(WTFMove(completionHandler));
>+    ASSERT(RunLoop::isMain());
>     
>+    if (m_resourceLoadStatistics) {
>+        m_resourceLoadStatistics->setPruneEntriesDownTo(pruneTargetCount, WTFMove(completionHandler));
>+        return;
>+    }
>+
>+    auto callbackAggregator = CallbackAggregator::create(WTFMove(completionHandler));
>+
>     for (auto& processPool : processPools()) {
>         if (auto* process = processPool->networkProcess())
>-            process->setAgeCapForClientSideCookies(m_sessionID, seconds, [processPool, callbackAggregator = callbackAggregator.copyRef()] { });
>+            process->setPruneEntriesDownTo(m_sessionID, pruneTargetCount, [processPool, callbackAggregator = callbackAggregator.copyRef()] { });
>     }
> }
> 
>-void WebsiteDataStore::hasStorageAccessForFrameHandler(const String& resourceDomain, const String& firstPartyDomain, uint64_t frameID, uint64_t pageID, CompletionHandler<void(bool hasAccess)>&& completionHandler)
>+void WebsiteDataStore::setGrandfatheringTime(Seconds seconds, CompletionHandler<void()>&& completionHandler)
> {
>-    auto* webPage = WebProcessProxy::webPage(pageID);
>-    if (!webPage) {
>-        completionHandler(false);
>+    ASSERT(RunLoop::isMain());
>+
>+    if (m_resourceLoadStatistics) {
>+        m_resourceLoadStatistics->setGrandfatheringTime(seconds, WTFMove(completionHandler));
>         return;
>     }
>+    
>+    auto callbackAggregator = CallbackAggregator::create(WTFMove(completionHandler));
> 
>-    auto& networkProcess = webPage->process().processPool().ensureNetworkProcess();
>-    networkProcess.hasStorageAccessForFrame(m_sessionID, resourceDomain, firstPartyDomain, frameID, pageID, WTFMove(completionHandler));
>+    for (auto& processPool : processPools()) {
>+        if (auto* process = processPool->networkProcess())
>+            process->setGrandfatheringTime(m_sessionID, seconds, [processPool, callbackAggregator = callbackAggregator.copyRef()] { });
>+    }
> }
> 
>-void WebsiteDataStore::getAllStorageAccessEntries(uint64_t pageID, CompletionHandler<void(Vector<String>&& domains)>&& completionHandler)
>+void WebsiteDataStore::setCacheMaxAgeCap(Seconds seconds, CompletionHandler<void()>&& completionHandler)
> {
>-    auto* webPage = WebProcessProxy::webPage(pageID);
>-    if (!webPage) {
>-        completionHandler({ });
>+    ASSERT(RunLoop::isMain());
>+    ASSERT(seconds >= 0_s);
>+    
>+    if (m_resourceLoadStatistics) {
>+        setCacheMaxAgeCap(seconds, WTFMove(completionHandler));
>         return;
>     }
>-    
>-    auto& networkProcess = webPage->process().processPool().ensureNetworkProcess();
>-    networkProcess.getAllStorageAccessEntries(m_sessionID, WTFMove(completionHandler));
>+
>+    auto callbackAggregator = CallbackAggregator::create(WTFMove(completionHandler));
>+
>+    for (auto& processPool : processPools()) {
>+        if (auto* process = processPool->networkProcess())
>+            process->setCacheMaxAgeCap(m_sessionID, seconds, [processPool, callbackAggregator = callbackAggregator.copyRef()] { });
>+    }
> }
> 
>-void WebsiteDataStore::grantStorageAccessHandler(const String& resourceDomain, const String& firstPartyDomain, Optional<uint64_t> frameID, uint64_t pageID, CompletionHandler<void(bool wasGranted)>&& completionHandler)
>+void WebsiteDataStore::setMinimumTimeBetweenDataRecordsRemoval(Seconds seconds, CompletionHandler<void()>&& completionHandler)
> {
>-    auto* webPage = WebProcessProxy::webPage(pageID);
>-    if (!webPage) {
>-        completionHandler(false);
>+    ASSERT(RunLoop::isMain());
>+
>+    if (m_resourceLoadStatistics) {
>+        m_resourceLoadStatistics->setMinimumTimeBetweenDataRecordsRemoval(seconds, WTFMove(completionHandler));
>         return;
>     }
>+    
>+    auto callbackAggregator = CallbackAggregator::create(WTFMove(completionHandler));
> 
>-    auto& networkProcess = webPage->process().processPool().ensureNetworkProcess();
>-    networkProcess.grantStorageAccess(m_sessionID, resourceDomain, firstPartyDomain, frameID, pageID, WTFMove(completionHandler));
>+    for (auto& processPool : processPools()) {
>+        if (auto* process = processPool->networkProcess())
>+            process->setMinimumTimeBetweenDataRecordsRemoval(m_sessionID, seconds, [processPool, callbackAggregator = callbackAggregator.copyRef()] { });
>+    }
> }
>-
>-void WebsiteDataStore::removeAllStorageAccessHandler(CompletionHandler<void()>&& completionHandler)
>+    
>+void WebsiteDataStore::dumpResourceLoadStatistics(CompletionHandler<void(const String&)>&& completionHandler)
> {
>-    auto callbackAggregator = CallbackAggregator::create(WTFMove(completionHandler));
>+    ASSERT(RunLoop::isMain());
>+
>+    if (m_resourceLoadStatistics) {
>+        m_resourceLoadStatistics->dumpResourceLoadStatistics(WTFMove(completionHandler));
>+        return;
>+    }
>     
>     for (auto& processPool : processPools()) {
>-        if (auto networkProcess = processPool->networkProcess())
>-            networkProcess->removeAllStorageAccess(m_sessionID, [processPool, callbackAggregator = callbackAggregator.copyRef()] { });
>+        if (auto* process = processPool->networkProcess()) {
>+            process->dumpResourceLoadStatistics(m_sessionID, WTFMove(completionHandler));
>+            RELEASE_ASSERT(processPools().size() == 1);
>+            break;
>+        }
>     }
> }
> 
>-void WebsiteDataStore::removePrevalentDomains(const Vector<String>& domains)
>+void WebsiteDataStore::isPrevalentResource(const URL& url, CompletionHandler<void(bool isPrevalent)>&& completionHandler)
> {
>-    for (auto& processPool : processPools())
>-        processPool->sendToNetworkingProcess(Messages::NetworkProcess::RemovePrevalentDomains(m_sessionID, domains));
>+    ASSERT(RunLoop::isMain());
>+    
>+    if (url.protocolIsAbout() || url.isEmpty()) {
>+        completionHandler(false);
>+        return;
>+    }
>+
>+    if (m_resourceLoadStatistics) {
>+        m_resourceLoadStatistics->isPrevalentResource(url, WTFMove(completionHandler));
>+        return;
>+    }
>+
>+    for (auto& processPool : processPools()) {
>+        if (auto* process = processPool->networkProcess()) {
>+            process->isPrevalentResource(m_sessionID, WebCore::ResourceLoadStatistics::primaryDomain(url), WTFMove(completionHandler));
>+            RELEASE_ASSERT(processPools().size() == 1);
>+            break;
>+        }
>+    }
> }
> 
>-void WebsiteDataStore::hasStorageAccess(String&& subFrameHost, String&& topFrameHost, uint64_t frameID, uint64_t pageID, CompletionHandler<void(bool)>&& completionHandler)
>+void WebsiteDataStore::setPrevalentResource(const URL& url, CompletionHandler<void()>&& completionHandler)
> {
>-    if (!resourceLoadStatisticsEnabled()) {
>-        completionHandler(false);
>+    ASSERT(RunLoop::isMain());
>+    
>+    if (url.protocolIsAbout() || url.isEmpty()) {
>+        completionHandler();
>         return;
>     }
>     
>-    m_resourceLoadStatistics->hasStorageAccess(WTFMove(subFrameHost), WTFMove(topFrameHost), frameID, pageID, WTFMove(completionHandler));
>+    if (m_resourceLoadStatistics) {
>+        m_resourceLoadStatistics->setPrevalentResource(url, WTFMove(completionHandler));
>+        return;
>+    }
>+
>+    auto callbackAggregator = CallbackAggregator::create(WTFMove(completionHandler));
>+
>+    for (auto& processPool : processPools()) {
>+        if (auto* process = processPool->networkProcess())
>+            process->setPrevalentResource(m_sessionID, WebCore::ResourceLoadStatistics::primaryDomain(url), [processPool, callbackAggregator = callbackAggregator.copyRef()] { });
>+    }
> }
> 
>-void WebsiteDataStore::requestStorageAccess(String&& subFrameHost, String&& topFrameHost, uint64_t frameID, uint64_t pageID, bool promptEnabled, CompletionHandler<void(StorageAccessStatus)>&& completionHandler)
>+void WebsiteDataStore::setPrevalentResourceForDebugMode(const URL& url, CompletionHandler<void()>&& completionHandler)
> {
>-    if (!resourceLoadStatisticsEnabled()) {
>-        completionHandler(StorageAccessStatus::CannotRequestAccess);
>+    ASSERT(RunLoop::isMain());
>+    
>+    if (url.protocolIsAbout() || url.isEmpty()) {
>+        completionHandler();
>+        return;
>+    }
>+    
>+    if (m_resourceLoadStatistics) {
>+        m_resourceLoadStatistics->setPrevalentResourceForDebugMode(url, WTFMove(completionHandler));
>         return;
>     }
>     
>-    m_resourceLoadStatistics->requestStorageAccess(WTFMove(subFrameHost), WTFMove(topFrameHost), frameID, pageID, promptEnabled, WTFMove(completionHandler));
>+    auto callbackAggregator = CallbackAggregator::create(WTFMove(completionHandler));
>+    
>+    for (auto& processPool : processPools()) {
>+        if (auto* process = processPool->networkProcess())
>+            process->setPrevalentResourceForDebugMode(m_sessionID, WebCore::ResourceLoadStatistics::primaryDomain(url), [processPool, callbackAggregator = callbackAggregator.copyRef()] { });
>+    }
> }
> 
>-void WebsiteDataStore::grantStorageAccess(String&& subFrameHost, String&& topFrameHost, uint64_t frameID, uint64_t pageID, bool userWasPrompted, CompletionHandler<void(bool)>&& completionHandler)
>+void WebsiteDataStore::isVeryPrevalentResource(const URL& url, CompletionHandler<void(bool isVeryPrevalent)>&& completionHandler)
> {
>-    if (!resourceLoadStatisticsEnabled()) {
>+    ASSERT(RunLoop::isMain());
>+    
>+    if (url.protocolIsAbout() || url.isEmpty()) {
>         completionHandler(false);
>         return;
>     }
>     
>-    m_resourceLoadStatistics->grantStorageAccess(WTFMove(subFrameHost), WTFMove(topFrameHost), frameID, pageID, userWasPrompted, WTFMove(completionHandler));
>+    if (m_resourceLoadStatistics) {
>+        m_resourceLoadStatistics->isVeryPrevalentResource(url, WTFMove(completionHandler));
>+        return;
>+    }
>+    
>+    for (auto& processPool : processPools()) {
>+        if (auto* process = processPool->networkProcess()) {
>+            process->isVeryPrevalentResource(m_sessionID, WebCore::ResourceLoadStatistics::primaryDomain(url), WTFMove(completionHandler));
>+            ASSERT(processPools().size() == 1);
>+            break;
>+        }
>+    }
> }
>-#endif // ENABLE(RESOURCE_LOAD_STATISTICS)
> 
>-void WebsiteDataStore::setCacheMaxAgeCapForPrevalentResources(Seconds seconds, CompletionHandler<void()>&& completionHandler)
>+void WebsiteDataStore::setVeryPrevalentResource(const URL& url, CompletionHandler<void()>&& completionHandler)
> {
>-#if ENABLE(RESOURCE_LOAD_STATISTICS)
>+    ASSERT(RunLoop::isMain());
>+    
>+    if (url.protocolIsAbout() || url.isEmpty()) {
>+        completionHandler();
>+        return;
>+    }
>+    
>+    if (m_resourceLoadStatistics) {
>+        m_resourceLoadStatistics->setVeryPrevalentResource(url, WTFMove(completionHandler));
>+        return;
>+    }
>+    
>     auto callbackAggregator = CallbackAggregator::create(WTFMove(completionHandler));
>     
>     for (auto& processPool : processPools()) {
>-        if (auto* networkProcess = processPool->networkProcess())
>-            networkProcess->setCacheMaxAgeCapForPrevalentResources(m_sessionID, seconds, [callbackAggregator = callbackAggregator.copyRef()] { });
>+        if (auto* process = processPool->networkProcess())
>+            process->setVeryPrevalentResource(m_sessionID, WebCore::ResourceLoadStatistics::primaryDomain(url), [processPool, callbackAggregator = callbackAggregator.copyRef()] { });
>     }
>-#else
>-    UNUSED_PARAM(seconds);
>-    completionHandler();
>-#endif
> }
> 
>-void WebsiteDataStore::resetCacheMaxAgeCapForPrevalentResources(CompletionHandler<void()>&& completionHandler)
>+void WebsiteDataStore::setShouldClassifyResourcesBeforeDataRecordsRemoval(bool value, CompletionHandler<void()>&& completionHandler)
> {
>-#if ENABLE(RESOURCE_LOAD_STATISTICS)
>-    auto callbackAggregator = CallbackAggregator::create(WTFMove(completionHandler));
>+    ASSERT(RunLoop::isMain());
>+    
>+    if (m_resourceLoadStatistics) {
>+        m_resourceLoadStatistics->setShouldClassifyResourcesBeforeDataRecordsRemoval(value, WTFMove(completionHandler));
>+        return;
>+    }
>     
>+    auto callbackAggregator = CallbackAggregator::create(WTFMove(completionHandler));
>+
>     for (auto& processPool : processPools()) {
>-        if (auto* networkProcess = processPool->networkProcess())
>-            networkProcess->resetCacheMaxAgeCapForPrevalentResources(m_sessionID, [callbackAggregator = callbackAggregator.copyRef()] { });
>+        if (auto* process = processPool->networkProcess())
>+            process->setShouldClassifyResourcesBeforeDataRecordsRemoval(m_sessionID, value, [processPool, callbackAggregator = callbackAggregator.copyRef()] { });
>     }
>-#else
>-    completionHandler();
>-#endif
> }
> 
>-void WebsiteDataStore::webPageWasAdded(WebPageProxy& webPageProxy)
>+void WebsiteDataStore::setSubframeUnderTopFrameOrigin(const URL& subframe, const URL& topFrame, CompletionHandler<void()>&& completionHandler)
> {
>-    if (m_storageManager)
>-        m_storageManager->createSessionStorageNamespace(webPageProxy.pageID(), std::numeric_limits<unsigned>::max());
>-}
>+    ASSERT(RunLoop::isMain());
>+    
>+    if (subframe.protocolIsAbout() || subframe.isEmpty() || topFrame.protocolIsAbout() || topFrame.isEmpty()) {
>+        completionHandler();
>+        return;
>+    }
> 
>-void WebsiteDataStore::webPageWasInvalidated(WebPageProxy& webPageProxy)
>-{
>-    if (m_storageManager)
>-        m_storageManager->destroySessionStorageNamespace(webPageProxy.pageID());
>+    if (m_resourceLoadStatistics) {
>+        m_resourceLoadStatistics->setSubframeUnderTopFrameOrigin(subframe, topFrame, WTFMove(completionHandler));
>+        return;
>+    }
>+    
>+    auto callbackAggregator = CallbackAggregator::create(WTFMove(completionHandler));
>+    
>+    for (auto& processPool : processPools()) {
>+        if (auto* process = processPool->networkProcess())
>+            process->setSubframeUnderTopFrameOrigin(m_sessionID, WebCore::ResourceLoadStatistics::primaryDomain(subframe), WebCore::ResourceLoadStatistics::primaryDomain(topFrame), [processPool, callbackAggregator = callbackAggregator.copyRef()] { });
>+    }
> }
> 
>-void WebsiteDataStore::webProcessWillOpenConnection(WebProcessProxy& webProcessProxy, IPC::Connection& connection)
>+void WebsiteDataStore::isRegisteredAsSubFrameUnder(const URL& subFrame, const URL& topFrame, CompletionHandler<void(bool)>&& completionHandler)
> {
>-    if (m_storageManager)
>-        m_storageManager->processWillOpenConnection(webProcessProxy, connection);
>+    ASSERT(RunLoop::isMain());
> 
>-    if (m_resourceLoadStatistics)
>-        webProcessProxy.addMessageReceiver(Messages::WebResourceLoadStatisticsStore::messageReceiverName(), *m_resourceLoadStatistics);
>+    if (m_resourceLoadStatistics) {
>+        m_resourceLoadStatistics->isRegisteredAsSubFrameUnder(subFrame, topFrame, WTFMove(completionHandler));
>+        return;
>+    }
>+    
>+    for (auto& processPool : processPools()) {
>+        if (auto* process = processPool->networkProcess()) {
>+            process->isRegisteredAsSubFrameUnder(m_sessionID, WebCore::ResourceLoadStatistics::primaryDomain(subFrame), WebCore::ResourceLoadStatistics::primaryDomain(topFrame), WTFMove(completionHandler));
>+            ASSERT(processPools().size() == 1);
>+            break;
>+        }
>+    }
> }
> 
>-void WebsiteDataStore::webPageWillOpenConnection(WebPageProxy& webPageProxy, IPC::Connection& connection)
>+void WebsiteDataStore::setSubresourceUnderTopFrameOrigin(const URL& subresource, const URL& topFrame, CompletionHandler<void()>&& completionHandler)
> {
>-    if (m_storageManager)
>-        m_storageManager->setAllowedSessionStorageNamespaceConnection(webPageProxy.pageID(), &connection);
>-}
>+    ASSERT(RunLoop::isMain());
>+    
>+    if (subresource.protocolIsAbout() || subresource.isEmpty() || topFrame.protocolIsAbout() || topFrame.isEmpty()) {
>+        completionHandler();
>+        return;
>+    }
> 
>-void WebsiteDataStore::webPageDidCloseConnection(WebPageProxy& webPageProxy, IPC::Connection&)
>-{
>-    if (m_storageManager)
>-        m_storageManager->setAllowedSessionStorageNamespaceConnection(webPageProxy.pageID(), nullptr);
>+    if (m_resourceLoadStatistics) {
>+        m_resourceLoadStatistics->setSubresourceUnderTopFrameOrigin(subresource, topFrame, WTFMove(completionHandler));
>+        return;
>+    }
>+
>+    auto callbackAggregator = CallbackAggregator::create(WTFMove(completionHandler));
>+    
>+    for (auto& processPool : processPools()) {
>+        if (auto* process = processPool->networkProcess())
>+            process->setSubresourceUnderTopFrameOrigin(m_sessionID, WebCore::ResourceLoadStatistics::primaryDomain(subresource), WebCore::ResourceLoadStatistics::primaryDomain(topFrame), [processPool, callbackAggregator = callbackAggregator.copyRef()] { });
>+    }
> }
> 
>-void WebsiteDataStore::webProcessDidCloseConnection(WebProcessProxy& webProcessProxy, IPC::Connection& connection)
>+void WebsiteDataStore::isRegisteredAsSubresourceUnder(const URL& subresource, const URL& topFrame, CompletionHandler<void(bool)>&& completionHandler)
> {
>-    if (m_resourceLoadStatistics)
>-        webProcessProxy.removeMessageReceiver(Messages::WebResourceLoadStatisticsStore::messageReceiverName());
>+    ASSERT(RunLoop::isMain());
>+    
>+    if (m_resourceLoadStatistics) {
>+        m_resourceLoadStatistics->isRegisteredAsSubresourceUnder(subresource, topFrame, WTFMove(completionHandler));
>+        return;
>+    }
> 
>-    if (m_storageManager)
>-        m_storageManager->processDidCloseConnection(webProcessProxy, connection);
>+    for (auto& processPool : processPools()) {
>+        if (auto* process = processPool->networkProcess()) {
>+            process->isRegisteredAsSubresourceUnder(m_sessionID, WebCore::ResourceLoadStatistics::primaryDomain(subresource), WebCore::ResourceLoadStatistics::primaryDomain(topFrame), WTFMove(completionHandler));
>+            ASSERT(processPools().size() == 1);
>+            break;
>+        }
>+    }
>+}
>+
>+void WebsiteDataStore::setSubresourceUniqueRedirectTo(const URL& subresource, const URL& hostNameRedirectedTo, CompletionHandler<void()>&& completionHandler)
>+{
>+    ASSERT(RunLoop::isMain());
>+    
>+    if (subresource.protocolIsAbout() || subresource.isEmpty() || hostNameRedirectedTo.protocolIsAbout() || hostNameRedirectedTo.isEmpty()) {
>+        completionHandler();
>+        return;
>+    }
>+
>+    if (m_resourceLoadStatistics) {
>+        m_resourceLoadStatistics->setSubresourceUniqueRedirectTo(subresource, hostNameRedirectedTo, WTFMove(completionHandler));
>+        return;
>+    }
>+    
>+    auto callbackAggregator = CallbackAggregator::create(WTFMove(completionHandler));
>+    
>+    for (auto& processPool : processPools()) {
>+        if (auto* process = processPool->networkProcess())
>+            process->setSubresourceUniqueRedirectTo(m_sessionID, WebCore::ResourceLoadStatistics::primaryDomain(subresource), WebCore::ResourceLoadStatistics::primaryDomain(hostNameRedirectedTo), [processPool, callbackAggregator = callbackAggregator.copyRef()] { });
>+    }
>+}
>+
>+void WebsiteDataStore::setSubresourceUniqueRedirectFrom(const URL& subresource, const URL& hostNameRedirectedFrom, CompletionHandler<void()>&& completionHandler)
>+{
>+    ASSERT(RunLoop::isMain());
>+    
>+    if (subresource.protocolIsAbout() || subresource.isEmpty() || hostNameRedirectedFrom.protocolIsAbout() || hostNameRedirectedFrom.isEmpty()) {
>+        completionHandler();
>+        return;
>+    }
>+
>+    if (m_resourceLoadStatistics) {
>+        m_resourceLoadStatistics->setSubresourceUniqueRedirectFrom(subresource, hostNameRedirectedFrom, WTFMove(completionHandler));
>+        return;
>+    }
>+    
>+    auto callbackAggregator = CallbackAggregator::create(WTFMove(completionHandler));
>+    
>+    for (auto& processPool : processPools()) {
>+        if (auto* process = processPool->networkProcess())
>+            process->setSubresourceUniqueRedirectFrom(m_sessionID, WebCore::ResourceLoadStatistics::primaryDomain(subresource), WebCore::ResourceLoadStatistics::primaryDomain(hostNameRedirectedFrom), [processPool, callbackAggregator = callbackAggregator.copyRef()] { });
>+    }
>+}
>+
>+void WebsiteDataStore::setTopFrameUniqueRedirectTo(const URL& topFrameHostName, const URL& hostNameRedirectedTo, CompletionHandler<void()>&& completionHandler)
>+{
>+    ASSERT(RunLoop::isMain());
>+    
>+    if (topFrameHostName.protocolIsAbout() || topFrameHostName.isEmpty() || hostNameRedirectedTo.protocolIsAbout() || hostNameRedirectedTo.isEmpty()) {
>+        completionHandler();
>+        return;
>+    }
>+
>+    if (m_resourceLoadStatistics) {
>+        m_resourceLoadStatistics->setTopFrameUniqueRedirectTo(topFrameHostName, hostNameRedirectedTo, WTFMove(completionHandler));
>+        return;
>+    }
>+    
>+    auto callbackAggregator = CallbackAggregator::create(WTFMove(completionHandler));
>+    
>+    for (auto& processPool : processPools()) {
>+        if (auto* process = processPool->networkProcess())
>+            process->setTopFrameUniqueRedirectTo(m_sessionID, WebCore::ResourceLoadStatistics::primaryDomain(topFrameHostName), WebCore::ResourceLoadStatistics::primaryDomain(hostNameRedirectedTo), [processPool, callbackAggregator = callbackAggregator.copyRef()] { });
>+    }
>+}
>+
>+void WebsiteDataStore::setTopFrameUniqueRedirectFrom(const URL& topFrameHostName, const URL& hostNameRedirectedFrom, CompletionHandler<void()>&& completionHandler)
>+{
>+    ASSERT(RunLoop::isMain());
>+    
>+    if (topFrameHostName.protocolIsAbout() || topFrameHostName.isEmpty() || hostNameRedirectedFrom.protocolIsAbout() || hostNameRedirectedFrom.isEmpty()) {
>+        completionHandler();
>+        return;
>+    }
>+
>+    if (m_resourceLoadStatistics) {
>+        m_resourceLoadStatistics->setTopFrameUniqueRedirectFrom(topFrameHostName, hostNameRedirectedFrom, WTFMove(completionHandler));
>+        return;
>+    }
>+    
>+    auto callbackAggregator = CallbackAggregator::create(WTFMove(completionHandler));
>+    
>+    for (auto& processPool : processPools()) {
>+        if (auto* process = processPool->networkProcess())
>+            process->setTopFrameUniqueRedirectFrom(m_sessionID, WebCore::ResourceLoadStatistics::primaryDomain(topFrameHostName), WebCore::ResourceLoadStatistics::primaryDomain(hostNameRedirectedFrom), [processPool, callbackAggregator = callbackAggregator.copyRef()] { });
>+    }
>+}
>+
>+void WebsiteDataStore::isRegisteredAsRedirectingTo(const URL& hostRedirectedFrom, const URL& hostRedirectedTo, CompletionHandler<void(bool)>&& completionHandler)
>+{
>+    ASSERT(RunLoop::isMain());
>+    
>+    if (m_resourceLoadStatistics) {
>+        m_resourceLoadStatistics->isRegisteredAsRedirectingTo(hostRedirectedFrom, hostRedirectedTo, WTFMove(completionHandler));
>+        return;
>+    }
>+
>+    for (auto& processPool : processPools()) {
>+        if (auto* process = processPool->networkProcess()) {
>+            process->isRegisteredAsRedirectingTo(m_sessionID, WebCore::ResourceLoadStatistics::primaryDomain(hostRedirectedFrom), WebCore::ResourceLoadStatistics::primaryDomain(hostRedirectedTo), WTFMove(completionHandler));
>+            ASSERT(processPools().size() == 1);
>+            break;
>+        }
>+    }
>+}
>+
>+void WebsiteDataStore::clearPrevalentResource(const URL& url, CompletionHandler<void()>&& completionHandler)
>+{
>+    ASSERT(RunLoop::isMain());
>+        
>+    if (url.protocolIsAbout() || url.isEmpty()) {
>+        completionHandler();
>+        return;
>+    }
>+
>+    if (m_resourceLoadStatistics) {
>+        m_resourceLoadStatistics->clearPrevalentResource(url, WTFMove(completionHandler));
>+        return;
>+    }
>+
>+    auto callbackAggregator = CallbackAggregator::create(WTFMove(completionHandler));
>+
>+    const auto& primaryDomain = WebCore::ResourceLoadStatistics::primaryDomain(url);
>+    for (auto& processPool : processPools()) {
>+        if (auto* process = processPool->networkProcess())
>+            process->clearPrevalentResource(m_sessionID, primaryDomain, [processPool, callbackAggregator = callbackAggregator.copyRef()] { });
>+    }
>+}
>+
>+void WebsiteDataStore::resetParametersToDefaultValues(CompletionHandler<void()>&& completionHandler)
>+{
>+    ASSERT(RunLoop::isMain());
>+
>+    if (m_resourceLoadStatistics) {
>+        m_resourceLoadStatistics->resetParametersToDefaultValues(WTFMove(completionHandler));
>+        return;
>+    }
>+
>+    auto callbackAggregator = CallbackAggregator::create(WTFMove(completionHandler));
>+    
>+    for (auto& processPool : processPools()) {
>+        if (auto* process = processPool->networkProcess())
>+            process->resetParametersToDefaultValues(m_sessionID, [processPool, callbackAggregator = callbackAggregator.copyRef()] { });
>+    }
>+}
>+
>+void WebsiteDataStore::submitTelemetry()
>+{
>+    ASSERT(RunLoop::isMain());
>+    
>+    if (m_resourceLoadStatistics) {
>+        m_resourceLoadStatistics->submitTelemetry([] { });
>+        return;
>+    }
>+    
>+    for (auto& processPool : processPools()) {
>+        if (auto* process = processPool->networkProcess())
>+            process->submitTelemetry(m_sessionID, [] { });
>+    }
>+}
>+
>+void WebsiteDataStore::scheduleClearInMemoryAndPersistent(WallTime modifiedSince, ShouldGrandfather shouldGrandfather, CompletionHandler<void()>&& completionHandler)
>+{
>+    ASSERT(RunLoop::isMain());
>+    
>+    if (m_resourceLoadStatistics) {
>+        m_resourceLoadStatistics->scheduleClearInMemoryAndPersistent(modifiedSince, shouldGrandfather, WTFMove(completionHandler));
>+        return;
>+    }
>+    
>+    auto callbackAggregator = CallbackAggregator::create(WTFMove(completionHandler));
>+
>+    for (auto& processPool : processPools()) {
>+        if (auto* process = processPool->networkProcess())
>+            process->scheduleClearInMemoryAndPersistent(m_sessionID, modifiedSince, shouldGrandfather, [processPool, callbackAggregator = callbackAggregator.copyRef()] { });
>+    }
>+}
>+
>+void WebsiteDataStore::scheduleClearInMemoryAndPersistent(ShouldGrandfather shouldGrandfather, CompletionHandler<void()>&& completionHandler)
>+{
>+    ASSERT(RunLoop::isMain());
>+    
>+    if (m_resourceLoadStatistics) {
>+        m_resourceLoadStatistics->scheduleClearInMemoryAndPersistent(shouldGrandfather, WTFMove(completionHandler));
>+        return;
>+    }
>+
>+    auto callbackAggregator = CallbackAggregator::create(WTFMove(completionHandler));
>+
>+    for (auto& processPool : processPools()) {
>+        if (auto* process = processPool->networkProcess())
>+            process->scheduleClearInMemoryAndPersistent(m_sessionID, { }, shouldGrandfather, [processPool, callbackAggregator = callbackAggregator.copyRef()] { });
>+    }
>+}
>+
>+void WebsiteDataStore::scheduleCookieBlockingUpdate(CompletionHandler<void()>&& completionHandler)
>+{
>+    if (m_resourceLoadStatistics) {
>+        m_resourceLoadStatistics->scheduleCookieBlockingUpdate(WTFMove(completionHandler));
>+        return;
>+    }
>+
>+    auto callbackAggregator = CallbackAggregator::create(WTFMove(completionHandler));
>+
>+    for (auto& processPool : processPools()) {
>+        if (auto* process = processPool->networkProcess())
>+            process->scheduleCookieBlockingUpdate(m_sessionID, [processPool, callbackAggregator = callbackAggregator.copyRef()] { });
>+    }
>+}
>+
>+void WebsiteDataStore::scheduleStatisticsAndDataRecordsProcessing(CompletionHandler<void()>&& completionHandler)
>+{
>+    ASSERT(RunLoop::isMain());
>+    
>+    if (m_resourceLoadStatistics) {
>+        m_resourceLoadStatistics->scheduleStatisticsAndDataRecordsProcessing(WTFMove(completionHandler));
>+        return;
>+    }
>+    
>+    auto callbackAggregator = CallbackAggregator::create(WTFMove(completionHandler));
>+    
>+    for (auto& processPool : processPools()) {
>+        if (auto* process = processPool->networkProcess())
>+            process->scheduleStatisticsAndDataRecordsProcessing(m_sessionID, [processPool, callbackAggregator = callbackAggregator.copyRef()] { });
>+    }
>+}
>+
>+#if ENABLE(RESOURCE_LOAD_STATISTICS)
>+void WebsiteDataStore::updatePrevalentDomainsToBlockCookiesFor(const Vector<String>& domainsToBlock, CompletionHandler<void()>&& completionHandler)
>+{
>+    auto callbackAggregator = CallbackAggregator::create(WTFMove(completionHandler));
>+
>+    for (auto& processPool : processPools()) {
>+        if (auto* process = processPool->networkProcess())
>+            process->updatePrevalentDomainsToBlockCookiesFor(m_sessionID, domainsToBlock, [processPool, callbackAggregator = callbackAggregator.copyRef()] { });
>+    }
>+}
>+#endif
>+
>+void WebsiteDataStore::setAgeCapForClientSideCookies(Optional<Seconds> seconds, CompletionHandler<void()>&& completionHandler)
>+{
>+    auto callbackAggregator = CallbackAggregator::create(WTFMove(completionHandler));
>+    
>+    for (auto& processPool : processPools()) {
>+        if (auto* process = processPool->networkProcess())
>+            process->setAgeCapForClientSideCookies(m_sessionID, seconds, [processPool, callbackAggregator = callbackAggregator.copyRef()] { });
>+    }
>+}
>+
>+void WebsiteDataStore::setLastSeen(const URL& url, Seconds seconds, CompletionHandler<void()>&& completionHandler)
>+{
>+    if (url.protocolIsAbout() || url.isEmpty()) {
>+        completionHandler();
>+        return;
>+    }
>+
>+    if (m_resourceLoadStatistics) {
>+        m_resourceLoadStatistics->setLastSeen(url, seconds, WTFMove(completionHandler));
>+        return;
>+    }
>+
>+    auto callbackAggregator = CallbackAggregator::create(WTFMove(completionHandler));
>+
>+    const auto& primaryDomain = WebCore::ResourceLoadStatistics::primaryDomain(url);
>+    for (auto& processPool : processPools()) {
>+        if (auto* process = processPool->networkProcess())
>+            process->setLastSeen(m_sessionID, primaryDomain, seconds, [processPool, callbackAggregator = callbackAggregator.copyRef()] { });
>+    }
>+}
>+
>+void WebsiteDataStore::setNotifyPagesWhenDataRecordsWereScanned(bool value, CompletionHandler<void()>&& completionHandler)
>+{
>+    if (m_resourceLoadStatistics) {
>+        m_resourceLoadStatistics->setNotifyPagesWhenDataRecordsWereScanned(value, WTFMove(completionHandler));
>+        return;
>+    }
>+
>+    auto callbackAggregator = CallbackAggregator::create(WTFMove(completionHandler));
>+
>+    for (auto& processPool : processPools()) {
>+        if (auto* process = processPool->networkProcess())
>+            process->setNotifyPagesWhenDataRecordsWereScanned(m_sessionID, value, [processPool, callbackAggregator = callbackAggregator.copyRef()] { });
>+    }
>+}
>+
>+void WebsiteDataStore::setNotifyPagesWhenTelemetryWasCaptured(bool value, CompletionHandler<void()>&& completionHandler)
>+{
>+    if (m_resourceLoadStatistics) {
>+        m_resourceLoadStatistics->setNotifyPagesWhenTelemetryWasCaptured(value, WTFMove(completionHandler));
>+        return;
>+    }
>+    
>+    auto callbackAggregator = CallbackAggregator::create(WTFMove(completionHandler));
>+    
>+    for (auto& processPool : processPools()) {
>+        if (auto* process = processPool->networkProcess())
>+            process->setNotifyPagesWhenTelemetryWasCaptured(m_sessionID, value, [processPool, callbackAggregator = callbackAggregator.copyRef()] { });
>+    }
>+}
>+
>+void WebsiteDataStore::hasStorageAccessForFrameHandler(const String& resourceDomain, const String& firstPartyDomain, uint64_t frameID, uint64_t pageID, CompletionHandler<void(bool hasAccess)>&& completionHandler)
>+{
>+    auto* webPage = WebProcessProxy::webPage(pageID);
>+    if (!webPage) {
>+        completionHandler(false);
>+        return;
>+    }
>+
>+    auto& networkProcess = webPage->process().processPool().ensureNetworkProcess();
>+    networkProcess.hasStorageAccessForFrame(m_sessionID, resourceDomain, firstPartyDomain, frameID, pageID, WTFMove(completionHandler));
>+}
>+
>+void WebsiteDataStore::getAllStorageAccessEntries(uint64_t pageID, CompletionHandler<void(Vector<String>&& domains)>&& completionHandler)
>+{
>+    auto* webPage = WebProcessProxy::webPage(pageID);
>+    if (!webPage) {
>+        completionHandler({ });
>+        return;
>+    }
>+    
>+    auto& networkProcess = webPage->process().processPool().ensureNetworkProcess();
>+    networkProcess.getAllStorageAccessEntries(m_sessionID, WTFMove(completionHandler));
>+}
>+
>+void WebsiteDataStore::grantStorageAccessHandler(const String& resourceDomain, const String& firstPartyDomain, Optional<uint64_t> frameID, uint64_t pageID, CompletionHandler<void(bool wasGranted)>&& completionHandler)
>+{
>+    auto* webPage = WebProcessProxy::webPage(pageID);
>+    if (!webPage) {
>+        completionHandler(false);
>+        return;
>+    }
>+
>+    auto& networkProcess = webPage->process().processPool().ensureNetworkProcess();
>+    networkProcess.grantStorageAccess(m_sessionID, resourceDomain, firstPartyDomain, frameID, pageID, false, WTFMove(completionHandler));
>+}
>+
>+void WebsiteDataStore::removeAllStorageAccessHandler(CompletionHandler<void()>&& completionHandler)
>+{
>+    auto callbackAggregator = CallbackAggregator::create(WTFMove(completionHandler));
>+    
>+    for (auto& processPool : processPools()) {
>+        if (auto networkProcess = processPool->networkProcess())
>+            networkProcess->removeAllStorageAccess(m_sessionID, [processPool, callbackAggregator = callbackAggregator.copyRef()] { });
>+    }
>+}
>+
>+void WebsiteDataStore::removePrevalentDomains(const Vector<String>& domains)
>+{
>+    for (auto& processPool : processPools())
>+        processPool->sendToNetworkingProcess(Messages::NetworkProcess::RemovePrevalentDomains(m_sessionID, domains));
>+}
>+
>+void WebsiteDataStore::hasStorageAccess(String&& subFrameHost, String&& topFrameHost, uint64_t frameID, uint64_t pageID, CompletionHandler<void(bool)>&& completionHandler)
>+{
>+    if (!resourceLoadStatisticsEnabled()) {
>+        completionHandler(false);
>+        return;
>+    }
>+
>+    if (m_resourceLoadStatistics) {
>+        m_resourceLoadStatistics->hasStorageAccess(WTFMove(subFrameHost), WTFMove(topFrameHost), frameID, pageID, WTFMove(completionHandler));
>+        return;
>+    }
>+
>+    auto* webPage = WebProcessProxy::webPage(pageID);
>+    if (!webPage) {
>+        completionHandler(false);
>+        return;
>+    }
>+
>+    if (auto networkProcess = webPage->process().processPool().networkProcess())
>+        networkProcess->hasStorageAccess(m_sessionID, WTFMove(subFrameHost), WTFMove(topFrameHost), frameID, pageID, WTFMove(completionHandler));
>+}
>+
>+void WebsiteDataStore::requestStorageAccess(String&& subFrameHost, String&& topFrameHost, uint64_t frameID, uint64_t pageID, bool promptEnabled, CompletionHandler<void(StorageAccessStatus)>&& completionHandler)
>+{
>+    if (!resourceLoadStatisticsEnabled()) {
>+        completionHandler(StorageAccessStatus::CannotRequestAccess);
>+        return;
>+    }
>+    
>+    if (m_resourceLoadStatistics) {
>+        m_resourceLoadStatistics->requestStorageAccess(WTFMove(subFrameHost), WTFMove(topFrameHost), frameID, pageID, promptEnabled, WTFMove(completionHandler));
>+        return;
>+    }
>+
>+    auto* webPage = WebProcessProxy::webPage(pageID);
>+    if (!webPage) {
>+        completionHandler(StorageAccessStatus::CannotRequestAccess);
>+        return;
>+    }
>+
>+    if (auto networkProcess = webPage->process().processPool().networkProcess())
>+        networkProcess->requestStorageAccess(m_sessionID, WTFMove(subFrameHost), WTFMove(topFrameHost), frameID, pageID, promptEnabled, WTFMove(completionHandler));
>+}
>+
>+void WebsiteDataStore::grantStorageAccess(String&& subFrameHost, String&& topFrameHost, uint64_t frameID, uint64_t pageID, bool userWasPrompted, CompletionHandler<void(bool)>&& completionHandler)
>+{
>+    if (!resourceLoadStatisticsEnabled()) {
>+        completionHandler(false);
>+        return;
>+    }
>+    
>+    if (m_resourceLoadStatistics) {
>+        m_resourceLoadStatistics->grantStorageAccess(WTFMove(subFrameHost), WTFMove(topFrameHost), frameID, pageID, userWasPrompted, WTFMove(completionHandler));
>+        return;
>+    }
>+
>+    auto* webPage = WebProcessProxy::webPage(pageID);
>+    if (!webPage) {
>+        completionHandler(false);
>+        return;
>+    }
>+
>+    if (auto networkProcess = webPage->process().processPool().networkProcess())
>+        networkProcess->grantStorageAccess(m_sessionID, WTFMove(subFrameHost), WTFMove(topFrameHost), frameID, pageID, userWasPrompted, WTFMove(completionHandler));
>+}
>+
>+void WebsiteDataStore::setTimeToLiveUserInteraction(Seconds seconds, CompletionHandler<void()>&& completionHandler)
>+{
>+    if (m_resourceLoadStatistics) {
>+        m_resourceLoadStatistics->setTimeToLiveUserInteraction(seconds, WTFMove(completionHandler));
>+        return;
>+    }
>+
>+    auto callbackAggregator = CallbackAggregator::create(WTFMove(completionHandler));
>+    
>+    for (auto& processPool : processPools()) {
>+        if (auto* networkProcess = processPool->networkProcess())
>+            networkProcess->setTimeToLiveUserInteraction(m_sessionID, seconds, [callbackAggregator = callbackAggregator.copyRef()] { });
>+    }
>+}
>+
>+void WebsiteDataStore::logUserInteraction(const URL& url, CompletionHandler<void()>&& completionHandler)
>+{
>+    ASSERT(RunLoop::isMain());
>+    
>+    if (url.protocolIsAbout() || url.isEmpty()) {
>+        completionHandler();
>+        return;
>+    }
>+    
>+    if (m_resourceLoadStatistics) {
>+        m_resourceLoadStatistics->logUserInteraction(url, WTFMove(completionHandler));
>+        return;
>+    }
>+
>+    auto callbackAggregator = CallbackAggregator::create(WTFMove(completionHandler));
>+
>+    for (auto& processPool : processPools()) {
>+        if (auto* process = processPool->networkProcess())
>+            process->logUserInteraction(m_sessionID, WebCore::ResourceLoadStatistics::primaryDomain(url), [callbackAggregator = callbackAggregator.copyRef()] { });
>+    }
>+}
>+
>+void WebsiteDataStore::hasHadUserInteraction(const URL& url, CompletionHandler<void(bool)>&& completionHandler)
>+{
>+    ASSERT(RunLoop::isMain());
>+    
>+    if (url.protocolIsAbout() || url.isEmpty()) {
>+        completionHandler(false);
>+        return;
>+    }
>+    
>+    if (m_resourceLoadStatistics) {
>+        m_resourceLoadStatistics->hasHadUserInteraction(url, WTFMove(completionHandler));
>+        return;
>+    }
>+    
>+    for (auto& processPool : processPools()) {
>+        if (auto* process = processPool->networkProcess()) {
>+            process->hasHadUserInteraction(m_sessionID, WebCore::ResourceLoadStatistics::primaryDomain(url), WTFMove(completionHandler));
>+            ASSERT(processPools().size() == 1);
>+            break;
>+        }
>+    }
>+}
>+
>+void WebsiteDataStore::clearUserInteraction(const URL& url, CompletionHandler<void()>&& completionHandler)
>+{
>+    ASSERT(RunLoop::isMain());
>+    
>+    if (url.protocolIsAbout() || url.isEmpty()) {
>+        completionHandler();
>+        return;
>+    }
>+    
>+    if (m_resourceLoadStatistics) {
>+        m_resourceLoadStatistics->clearUserInteraction(url, WTFMove(completionHandler));
>+        return;
>+    }
>+    
>+    auto callbackAggregator = CallbackAggregator::create(WTFMove(completionHandler));
>+
>+    for (auto& processPool : processPools()) {
>+        if (auto* process = processPool->networkProcess())
>+            process->clearUserInteraction(m_sessionID, WebCore::ResourceLoadStatistics::primaryDomain(url), [callbackAggregator = callbackAggregator.copyRef()] { });
>+    }
>+}
>+
>+void WebsiteDataStore::isGrandfathered(const URL& url, CompletionHandler<void(bool)>&& completionHandler)
>+{
>+    ASSERT(RunLoop::isMain());
>+    
>+    if (url.protocolIsAbout() || url.isEmpty()) {
>+        completionHandler(false);
>+        return;
>+    }
>+    
>+    if (m_resourceLoadStatistics) {
>+        m_resourceLoadStatistics->isGrandfathered(url, WTFMove(completionHandler));
>+        return;
>+    }
>+    
>+    for (auto& processPool : processPools()) {
>+        if (auto* process = processPool->networkProcess()) {
>+            process->isGrandfathered(m_sessionID, WebCore::ResourceLoadStatistics::primaryDomain(url), WTFMove(completionHandler));
>+            ASSERT(processPools().size() == 1);
>+            break;
>+        }
>+    }
>+}
>+
>+void WebsiteDataStore::setGrandfathered(const URL& url, bool isGrandfathered, CompletionHandler<void()>&& completionHandler)
>+{
>+    ASSERT(RunLoop::isMain());
>+    
>+    if (url.protocolIsAbout() || url.isEmpty()) {
>+        completionHandler();
>+        return;
>+    }
>+    
>+    if (m_resourceLoadStatistics) {
>+        m_resourceLoadStatistics->setGrandfathered(url, isGrandfathered, WTFMove(completionHandler));
>+        return;
>+    }
>+    
>+    auto callbackAggregator = CallbackAggregator::create(WTFMove(completionHandler));
>+    
>+    for (auto& processPool : processPools()) {
>+        if (auto* process = processPool->networkProcess())
>+            process->setGrandfathered(m_sessionID, WebCore::ResourceLoadStatistics::primaryDomain(url), isGrandfathered, [callbackAggregator = callbackAggregator.copyRef()] { });
>+    }
>+}
>+#endif // ENABLE(RESOURCE_LOAD_STATISTICS)
>+
>+void WebsiteDataStore::setCacheMaxAgeCapForPrevalentResources(Seconds seconds, CompletionHandler<void()>&& completionHandler)
>+{
>+#if ENABLE(RESOURCE_LOAD_STATISTICS)
>+    auto callbackAggregator = CallbackAggregator::create(WTFMove(completionHandler));
>+    
>+    for (auto& processPool : processPools()) {
>+        if (auto* networkProcess = processPool->networkProcess())
>+            networkProcess->setCacheMaxAgeCapForPrevalentResources(m_sessionID, seconds, [callbackAggregator = callbackAggregator.copyRef()] { });
>+    }
>+#else
>+    UNUSED_PARAM(seconds);
>+    completionHandler();
>+#endif
>+}
>+
>+void WebsiteDataStore::resetCacheMaxAgeCapForPrevalentResources(CompletionHandler<void()>&& completionHandler)
>+{
>+#if ENABLE(RESOURCE_LOAD_STATISTICS)
>+    auto callbackAggregator = CallbackAggregator::create(WTFMove(completionHandler));
>+    
>+    for (auto& processPool : processPools()) {
>+        if (auto* networkProcess = processPool->networkProcess())
>+            networkProcess->resetCacheMaxAgeCapForPrevalentResources(m_sessionID, [callbackAggregator = callbackAggregator.copyRef()] { });
>+    }
>+#else
>+    completionHandler();
>+#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);
>+
>+#if ENABLE(RESOURCE_LOAD_STATISTICS)
>+    if (m_resourceLoadStatistics)
>+        webProcessProxy.addMessageReceiver(Messages::WebResourceLoadStatisticsStore::messageReceiverName(), *m_resourceLoadStatistics);
>+#endif
>+}
>+
>+void WebsiteDataStore::webPageWillOpenConnection(WebPageProxy& webPageProxy, IPC::Connection& connection)
>+{
>+    if (m_storageManager)
>+        m_storageManager->setAllowedSessionStorageNamespaceConnection(webPageProxy.pageID(), &connection);
>+}
>+
>+void WebsiteDataStore::webPageDidCloseConnection(WebPageProxy& webPageProxy, IPC::Connection&)
>+{
>+    if (m_storageManager)
>+        m_storageManager->setAllowedSessionStorageNamespaceConnection(webPageProxy.pageID(), nullptr);
>+}
>+
>+void WebsiteDataStore::webProcessDidCloseConnection(WebProcessProxy& webProcessProxy, IPC::Connection& connection)
>+{
>+#if ENABLE(RESOURCE_LOAD_STATISTICS)
>+    if (m_resourceLoadStatistics)
>+        webProcessProxy.removeMessageReceiver(Messages::WebResourceLoadStatisticsStore::messageReceiverName());
>+#endif
>+
>+    if (m_storageManager)
>+        m_storageManager->processDidCloseConnection(webProcessProxy, connection);
> }
> 
> bool WebsiteDataStore::isAssociatedProcessPool(WebProcessPool& processPool) const
>@@ -1540,29 +2316,75 @@ void WebsiteDataStore::removeMediaKeys(const String& mediaKeysStorageDirectory,
> 
> bool WebsiteDataStore::resourceLoadStatisticsEnabled() const
> {
>-    return !!m_resourceLoadStatistics;
>+#if ENABLE(RESOURCE_LOAD_STATISTICS)
>+    return m_resourceLoadStatisticsEnabled;
>+#else
>+    return false;
>+#endif
>+}
>+
>+bool WebsiteDataStore::resourceLoadStatisticsDebugMode() const
>+{
>+#if ENABLE(RESOURCE_LOAD_STATISTICS)
>+    return m_resourceLoadStatisticsDebugMode;
>+#else
>+    return false;
>+#endif
> }
> 
> void WebsiteDataStore::setResourceLoadStatisticsEnabled(bool enabled)
> {
>+#if ENABLE(RESOURCE_LOAD_STATISTICS)
>     if (m_sessionID.isEphemeral() || enabled == resourceLoadStatisticsEnabled())
>         return;
> 
>     if (enabled) {
>+        // FIXME(193297): Remove this assert
>         ASSERT(!m_resourceLoadStatistics);
>         enableResourceLoadStatisticsAndSetTestingCallback(nullptr);
>         return;
>     }
> 
>-
>+    // FIXME(193297): Remove these two lines
>     unregisterWebResourceLoadStatisticsStoreAsMessageReceiver();
>     m_resourceLoadStatistics = nullptr;
> 
>-    auto existingProcessPools = processPools(std::numeric_limits<size_t>::max(), false);
>-    for (auto& processPool : existingProcessPools)
>+    for (auto& processPool : processPools(std::numeric_limits<size_t>::max(), false)) {
>         processPool->setResourceLoadStatisticsEnabled(false);
>+        processPool->sendToNetworkingProcess(Messages::NetworkProcess::SetResourceLoadStatisticsEnabled(false));
>+    }
>+#else
>+    UNUSED_PARAM(enabled);
>+#endif
>+}
>+
>+void WebsiteDataStore::setResourceLoadStatisticsDebugMode(bool enabled)
>+{
>+    setResourceLoadStatisticsDebugMode(enabled, []() { });
>+}
>+
>+void WebsiteDataStore::setResourceLoadStatisticsDebugMode(bool enabled, CompletionHandler<void()>&& completionHandler)
>+{
>+#if ENABLE(RESOURCE_LOAD_STATISTICS)
>+    m_resourceLoadStatisticsDebugMode = enabled;
>+    if (m_resourceLoadStatistics) {
>+        m_resourceLoadStatistics->setResourceLoadStatisticsDebugMode(enabled, WTFMove(completionHandler));
>+        return;
>+    }
>+    
>+    auto callbackAggregator = CallbackAggregator::create(WTFMove(completionHandler));
>+    
>+    for (auto& processPool : processPools()) {
>+        if (auto* process = processPool->networkProcess())
>+            process->setResourceLoadStatisticsDebugMode(m_sessionID, enabled, [callbackAggregator = callbackAggregator.copyRef()] { });
>+    }
>+#else
>+    UNUSED_PARAM(enabled);
>+    UNUSED_PARAM(completionHandler);
>+#endif
> }
> 
>+#if ENABLE(RESOURCE_LOAD_STATISTICS)
> void WebsiteDataStore::unregisterWebResourceLoadStatisticsStoreAsMessageReceiver()
> {
>     if (!m_resourceLoadStatistics)
>@@ -1582,42 +2404,35 @@ void WebsiteDataStore::registerWebResourceLoadStatisticsStoreAsMessageReceiver()
>         webProcessProxy->addMessageReceiver(Messages::WebResourceLoadStatisticsStore::messageReceiverName(), *m_resourceLoadStatistics);
> }
> 
>-bool WebsiteDataStore::resourceLoadStatisticsDebugMode() const
>-{
>-    return m_resourceLoadStatisticsDebugMode;
>-}
>-
>-void WebsiteDataStore::setResourceLoadStatisticsDebugMode(bool enabled)
>-{
>-    setResourceLoadStatisticsDebugMode(enabled, []() { });
>-}
>-
>-void WebsiteDataStore::setResourceLoadStatisticsDebugMode(bool enabled, CompletionHandler<void()>&& completionHandler)
>-{
>-    m_resourceLoadStatisticsDebugMode = enabled;
>-    if (m_resourceLoadStatistics)
>-        m_resourceLoadStatistics->setResourceLoadStatisticsDebugMode(enabled, WTFMove(completionHandler));
>-    else
>-        completionHandler();
>-}
>-
> void WebsiteDataStore::enableResourceLoadStatisticsAndSetTestingCallback(Function<void (const String&)>&& callback)
> {
>     ASSERT(!m_sessionID.isEphemeral());
> 
>-    if (m_resourceLoadStatistics) {
>-        m_resourceLoadStatistics->setStatisticsTestingCallback(WTFMove(callback));
>+    m_resourceLoadStatisticsEnabled = true;
>+    setStatisticsTestingCallback(WTFMove(callback));
>+
>+    // FIXME(193297): Remove this check
>+    if (m_resourceLoadStatistics)
>         return;
>-    }
> 
>     resolveDirectoriesIfNecessary();
>-    m_resourceLoadStatistics = WebResourceLoadStatisticsStore::create(*this);
>-    m_resourceLoadStatistics->setStatisticsTestingCallback(WTFMove(callback));
> 
>+    // FIXME(193297): Remove these two lines
>+    m_resourceLoadStatistics = WebResourceLoadStatisticsStore::create(*this);
>     registerWebResourceLoadStatisticsStoreAsMessageReceiver();
> 
>-    for (auto& processPool : processPools(std::numeric_limits<size_t>::max(), false))
>+    for (auto& processPool : processPools(std::numeric_limits<size_t>::max(), false)) {
>         processPool->setResourceLoadStatisticsEnabled(true);
>+        processPool->sendToNetworkingProcess(Messages::NetworkProcess::SetResourceLoadStatisticsEnabled(true));
>+    }
>+}
>+
>+void WebsiteDataStore::logTestingEvent(const String& event)
>+{
>+    ASSERT(RunLoop::isMain());
>+    
>+    if (m_statisticsTestingCallback)
>+        m_statisticsTestingCallback(event);
> }
> 
> void WebsiteDataStore::clearResourceLoadStatisticsInWebProcesses(CompletionHandler<void()>&& callback)
>@@ -1628,6 +2443,7 @@ void WebsiteDataStore::clearResourceLoadStatisticsInWebProcesses(CompletionHandl
>     }
>     callback();
> }
>+#endif
> 
> Vector<WebCore::Cookie> WebsiteDataStore::pendingCookies() const
> {
>@@ -1698,8 +2514,10 @@ void WebsiteDataStore::setMockWebAuthenticationConfiguration(MockWebAuthenticati
> 
> void WebsiteDataStore::didCreateNetworkProcess()
> {
>+#if ENABLE(RESOURCE_LOAD_STATISTICS)
>     if (m_resourceLoadStatistics)
>         m_resourceLoadStatistics->didCreateNetworkProcess();
>+#endif
> }
> 
> }
>diff --git a/Source/WebKit/UIProcess/WebsiteData/WebsiteDataStore.h b/Source/WebKit/UIProcess/WebsiteData/WebsiteDataStore.h
>index fa34013a63eddd735627b70dbc35ad2145a23b98..c650528a1abf0fcdb96d5b91610b2fab511614cc 100644
>--- a/Source/WebKit/UIProcess/WebsiteData/WebsiteDataStore.h
>+++ b/Source/WebKit/UIProcess/WebsiteData/WebsiteDataStore.h
>@@ -1,5 +1,5 @@
> /*
>- * Copyright (C) 2014-2017 Apple Inc. All rights reserved.
>+ * Copyright (C) 2014-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
>@@ -72,7 +72,8 @@ struct WebsiteDataRecord;
> struct WebsiteDataStoreParameters;
> 
> #if ENABLE(RESOURCE_LOAD_STATISTICS)
>-enum class StorageAccessStatus;
>+enum class ShouldGrandfather;
>+enum class StorageAccessStatus : unsigned;
> enum class StorageAccessPromptStatus;
> #endif
> 
>@@ -104,29 +105,73 @@ public:
>     const String& serviceWorkerRegistrationDirectory() const { return m_resolvedConfiguration->serviceWorkerRegistrationDirectory(); }
>     void setServiceWorkerRegistrationDirectory(String&& directory) { m_resolvedConfiguration->setServiceWorkerRegistrationDirectory(WTFMove(directory)); }
> 
>+#if ENABLE(RESOURCE_LOAD_STATISTICS)
>     WebResourceLoadStatisticsStore* resourceLoadStatistics() const { return m_resourceLoadStatistics.get(); }
>     void clearResourceLoadStatisticsInWebProcesses(CompletionHandler<void()>&&);
>+#endif
> 
>     static void cloneSessionData(WebPageProxy& sourcePage, WebPageProxy& newPage);
> 
>     void fetchData(OptionSet<WebsiteDataType>, OptionSet<WebsiteDataFetchOption>, Function<void(Vector<WebsiteDataRecord>)>&& completionHandler);
>-    void fetchDataForTopPrivatelyControlledDomains(OptionSet<WebsiteDataType>, OptionSet<WebsiteDataFetchOption>, const Vector<String>& topPrivatelyControlledDomains, Function<void(Vector<WebsiteDataRecord>&&, HashSet<String>&&)>&& completionHandler);
>-    void topPrivatelyControlledDomainsWithWebsiteData(OptionSet<WebsiteDataType> dataTypes, OptionSet<WebsiteDataFetchOption> fetchOptions, Function<void(HashSet<String>&&)>&& completionHandler);
>     void removeData(OptionSet<WebsiteDataType>, WallTime modifiedSince, Function<void()>&& completionHandler);
>     void removeData(OptionSet<WebsiteDataType>, const Vector<WebsiteDataRecord>&, Function<void()>&& completionHandler);
>-    void removeDataForTopPrivatelyControlledDomains(OptionSet<WebsiteDataType>, OptionSet<WebsiteDataFetchOption>, const Vector<String>& topPrivatelyControlledDomains, Function<void(HashSet<String>&&)>&& completionHandler);
> 
> #if ENABLE(RESOURCE_LOAD_STATISTICS)
>+    void fetchDataForTopPrivatelyControlledDomains(OptionSet<WebsiteDataType>, OptionSet<WebsiteDataFetchOption>, const Vector<String>& topPrivatelyControlledDomains, Function<void(Vector<WebsiteDataRecord>&&, HashSet<String>&&)>&& completionHandler);
>+    void topPrivatelyControlledDomainsWithWebsiteData(OptionSet<WebsiteDataType> dataTypes, OptionSet<WebsiteDataFetchOption> fetchOptions, Function<void(HashSet<String>&&)>&& completionHandler);
>+    void removeDataForTopPrivatelyControlledDomains(OptionSet<WebsiteDataType>, OptionSet<WebsiteDataFetchOption>, const Vector<String>& topPrivatelyControlledDomains, Function<void(HashSet<String>&&)>&& completionHandler);
>+
>+    void clearPrevalentResource(const URL&, CompletionHandler<void()>&&);
>+    void clearUserInteraction(const URL&, CompletionHandler<void()>&&);
>+    void deleteWebsiteDataForTopPrivatelyControlledDomainsInAllPersistentDataStores(OptionSet<WebsiteDataType>, Vector<String>&& topPrivatelyControlledDomains, bool shouldNotifyPages, CompletionHandler<void(const HashSet<String>&)>&&);
>+    void dumpResourceLoadStatistics(CompletionHandler<void(const String&)>&&);
>+    void logTestingEvent(const String&);
>+    void logUserInteraction(const URL&, CompletionHandler<void()>&&);
>     void updatePrevalentDomainsToBlockCookiesFor(const Vector<String>& domainsToBlock, CompletionHandler<void()>&&);
>     void setAgeCapForClientSideCookies(Optional<Seconds>, CompletionHandler<void()>&&);
>     void hasStorageAccessForFrameHandler(const String& resourceDomain, const String& firstPartyDomain, uint64_t frameID, uint64_t pageID, CompletionHandler<void(bool hasAccess)>&&);
>     void getAllStorageAccessEntries(uint64_t pageID, CompletionHandler<void(Vector<String>&& domains)>&&);
>     void grantStorageAccessHandler(const String& resourceDomain, const String& firstPartyDomain, Optional<uint64_t> frameID, uint64_t pageID, CompletionHandler<void(bool wasGranted)>&&);
>+    void hasHadUserInteraction(const URL&, CompletionHandler<void(bool)>&&);
>+    void isGrandfathered(const URL&, CompletionHandler<void(bool)>&&);
>+    void isPrevalentResource(const URL&, CompletionHandler<void(bool)>&&);
>+    void isRegisteredAsRedirectingTo(const URL& hostRedirectedFrom, const URL& hostRedirectedTo, CompletionHandler<void(bool)>&&);
>+    void isRegisteredAsSubresourceUnder(const URL& subresource, const URL& topFrame, CompletionHandler<void(bool)>&&);
>+    void isRegisteredAsSubFrameUnder(const URL& subFrame, const URL& topFrame, CompletionHandler<void(bool)>&&);
>+    void isVeryPrevalentResource(const URL&, CompletionHandler<void(bool)>&&);
>     void removeAllStorageAccessHandler(CompletionHandler<void()>&&);
>     void removePrevalentDomains(const Vector<String>& domains);
>+    void resetParametersToDefaultValues(CompletionHandler<void()>&&);
>+    void scheduleCookieBlockingUpdate(CompletionHandler<void()>&&);
>+    void scheduleClearInMemoryAndPersistent(WallTime modifiedSince, ShouldGrandfather, CompletionHandler<void()>&&);
>+    void scheduleClearInMemoryAndPersistent(ShouldGrandfather, CompletionHandler<void()>&&);
>+    void scheduleStatisticsAndDataRecordsProcessing(CompletionHandler<void()>&&);
>+    void submitTelemetry();
>+    void setCacheMaxAgeCap(Seconds, CompletionHandler<void()>&&);
>+    void setGrandfathered(const URL&, bool, CompletionHandler<void()>&&);
>+    void setGrandfatheringTime(Seconds, CompletionHandler<void()>&&);
>+    void setLastSeen(const URL&, Seconds, CompletionHandler<void()>&&);
>+    void setNotifyPagesWhenDataRecordsWereScanned(bool, CompletionHandler<void()>&&);
>+    void setPruneEntriesDownTo(size_t, CompletionHandler<void()>&&);
>+    void setSubframeUnderTopFrameOrigin(const URL& subframe, const URL& topFrame, CompletionHandler<void()>&&);
>+    void setSubresourceUnderTopFrameOrigin(const URL& subresource, const URL& topFrame, CompletionHandler<void()>&&);
>+    void setSubresourceUniqueRedirectTo(const URL& subresource, const URL& hostNameRedirectedTo, CompletionHandler<void()>&&);
>+    void setSubresourceUniqueRedirectFrom(const URL& subresource, const URL& hostNameRedirectedFrom, CompletionHandler<void()>&&);
>+    void setTimeToLiveUserInteraction(Seconds, CompletionHandler<void()>&&);
>+    void setTopFrameUniqueRedirectTo(const URL& topFrameHostName, const URL& hostNameRedirectedTo, CompletionHandler<void()>&&);
>+    void setTopFrameUniqueRedirectFrom(const URL& topFrameHostName, const URL& hostNameRedirectedFrom, CompletionHandler<void()>&&);
>+    void setMaxStatisticsEntries(size_t, CompletionHandler<void()>&&);
>+    void setMinimumTimeBetweenDataRecordsRemoval(Seconds, CompletionHandler<void()>&&);
>+    void setNotifyPagesWhenTelemetryWasCaptured(bool, CompletionHandler<void()>&&);
>+    void setPrevalentResource(const URL&, CompletionHandler<void()>&&);
>+    void setPrevalentResourceForDebugMode(const URL&, CompletionHandler<void()>&&);
>+    void setShouldClassifyResourcesBeforeDataRecordsRemoval(bool, CompletionHandler<void()>&&);
>+    void setStatisticsTestingCallback(WTF::Function<void(const String&)>&& callback) { m_statisticsTestingCallback = WTFMove(callback); }
>+    void setVeryPrevalentResource(const URL&, CompletionHandler<void()>&&);
>     void hasStorageAccess(String&& subFrameHost, String&& topFrameHost, uint64_t frameID, uint64_t pageID, CompletionHandler<void(bool)>&&);
>     void requestStorageAccess(String&& subFrameHost, String&& topFrameHost, uint64_t frameID, uint64_t pageID, bool promptEnabled, CompletionHandler<void(StorageAccessStatus)>&&);
>     void grantStorageAccess(String&& subFrameHost, String&& topFrameHost, uint64_t frameID, uint64_t pageID, bool userWasPrompted, CompletionHandler<void(bool)>&&);
>+    void setSubframeUnderTopFrameOrigin(const URL& subframe, const URL& topFrame);
> #endif
>     void setCacheMaxAgeCapForPrevalentResources(Seconds, CompletionHandler<void()>&&);
>     void resetCacheMaxAgeCapForPrevalentResources(CompletionHandler<void()>&&);
>@@ -210,8 +255,10 @@ private:
>     void platformDestroy();
>     static void platformRemoveRecentSearches(WallTime);
> 
>+#if ENABLE(RESOURCE_LOAD_STATISTICS)
>     void registerWebResourceLoadStatisticsStoreAsMessageReceiver();
>     void unregisterWebResourceLoadStatisticsStoreAsMessageReceiver();
>+#endif
> 
>     HashSet<RefPtr<WebProcessPool>> processPools(size_t count = std::numeric_limits<size_t>::max(), bool ensureAPoolExists = true) const;
> 
>@@ -233,8 +280,13 @@ private:
> 
>     const RefPtr<StorageManager> m_storageManager;
>     const Ref<DeviceIdHashSaltStorage> m_deviceIdHashSaltStorage;
>+
>+#if ENABLE(RESOURCE_LOAD_STATISTICS)
>     RefPtr<WebResourceLoadStatisticsStore> m_resourceLoadStatistics;
>     bool m_resourceLoadStatisticsDebugMode { false };
>+    bool m_resourceLoadStatisticsEnabled { false };
>+    WTF::Function<void(const String&)> m_statisticsTestingCallback;
>+#endif
> 
>     Ref<WorkQueue> m_queue;
> 
>diff --git a/Source/WebKit/WebProcess/WebProcess.cpp b/Source/WebKit/WebProcess/WebProcess.cpp
>index 023065cde8ef20533001b933681e701948b25f10..33bae574bffad22c2ab0a015deecae8f9e99a33e 100644
>--- a/Source/WebKit/WebProcess/WebProcess.cpp
>+++ b/Source/WebKit/WebProcess/WebProcess.cpp
>@@ -204,6 +204,7 @@ WebProcess::WebProcess()
> 
>     m_plugInAutoStartOriginHashes.add(PAL::SessionID::defaultSessionID(), HashMap<unsigned, WallTime>());
> 
>+#if ENABLE(RESOURCE_LOAD_STATISTICS)
>     ResourceLoadObserver::shared().setNotificationCallback([this] (Vector<ResourceLoadStatistics>&& statistics) {
>         parentProcessConnection()->send(Messages::WebResourceLoadStatisticsStore::ResourceLoadStatisticsUpdated(WTFMove(statistics)), 0);
>     });
>@@ -211,6 +212,7 @@ WebProcess::WebProcess()
>     ResourceLoadObserver::shared().setRequestStorageAccessUnderOpenerCallback([this] (const String& domainInNeedOfStorageAccess, uint64_t openerPageID, const String& openerDomain) {
>         parentProcessConnection()->send(Messages::WebResourceLoadStatisticsStore::RequestStorageAccessUnderOpener(domainInNeedOfStorageAccess, openerPageID, openerDomain), 0);
>     });
>+#endif
>     
>     Gigacage::disableDisablingPrimitiveGigacageIfShouldBeEnabled();
> }
>@@ -382,6 +384,12 @@ void WebProcess::initializeWebProcess(WebProcessCreationParameters&& parameters)
> 
>     ensureNetworkProcessConnection();
> 
>+#if ENABLE(RESOURCE_LOAD_STATISTICS)
>+    ResourceLoadObserver::shared().setLogUserInteractionNotificationCallback([this] (PAL::SessionID sessionID, const String& topLevelOrigin) {
>+        m_networkProcessConnection->connection().send(Messages::NetworkConnectionToWebProcess::LogUserInteraction(sessionID, topLevelOrigin), 0);
>+    });
>+#endif
>+
>     setTerminationTimeout(parameters.terminationTimeout);
> 
>     resetPlugInAutoStartOriginHashes(parameters.plugInAutoStartOriginHashes);

Actions: View | Formatted Diff | Diff

Attachments on bug 193556: 359429 | 359440 | 359443 | 359446 | 359450 | 359455 | 359493 | 359509 | 359512 | 359521 | 359543 | 359548 | 359565 | 359708