Attachment 362789 Details for Bug 194791 – Patch

[patch] Patch

bug-194791-20190222165407.patch (text/plain), 353.98 KB, created by John Wilander on 2019-02-22 16:54:08 PST

(hide)

Description:

Filename:

MIME Type:

Creator: John Wilander

Created: 2019-02-22 16:54:08 PST

Size: 353.98 KB

patch

obsolete

>Subversion Revision: 241967
>diff --git a/Source/WebCore/ChangeLog b/Source/WebCore/ChangeLog
>index 7c926a47355b38ebbdca566c8fad60c364c9d970..4594b1018de66825f0b8b57318a9549594302c7a 100644
>--- a/Source/WebCore/ChangeLog
>+++ b/Source/WebCore/ChangeLog
>@@ -1,3 +1,124 @@
>+2019-02-22  John Wilander  <wilander@apple.com>
>+
>+        Introduce and adopt new class RegistrableDomain for eTLD+1
>+        https://bugs.webkit.org/show_bug.cgi?id=194791
>+        <rdar://problem/48179240>
>+
>+        Reviewed by NOBODY (OOPS!).
>+
>+        A new API test was added. Plenty of existing layout tests under
>+        http/tests/resourceLoadStatistics/ and http/tests/storageAccess/ test the code.
>+
>+        This patch introduces and adopts a new class called WebCore::RegistrableDomain
>+        which represents a domain's eTLD+1 (effective top level domain plus one) and is
>+        the basis for the term "site," as in same-site. Other popular names include
>+        high-level domain, primary domain, and top privately controlled/owned domain.
>+        Effective top level domains are enumerated on the Public Suffix List
>+        (https://publicsuffix.org).
>+
>+        This class just uses the full domain for when the Public Suffix List cannot help
>+        finding the registrable domain and for WebKit ports that haven't enabled
>+        PUBLIC_SUFFIX_LIST. It also uses the string "nullOrigin" as a representation
>+        for the null or unique origin (this matches how these origins were handled
>+        before).
>+
>+        The implementation is a wrapper around a String and the functions and class
>+        members that now make use of this new class used to handle regular String
>+        objects which didn't help much in terms of type safety or guarantees that the
>+        string had already been converted to an eTLD+1.
>+
>+        We've at least two bad bugs in the Storage Access API because of confusion
>+        between a URL's eTLD+1 and its host. The usage of WebCore::RegistrableDomain
>+        will prohibit such bugs in the future.
>+
>+        Partitioning in WebKit also uses eTLD+1 to a large extent. I plan to adopt
>+        WebCore::RegistrableDomain for partitioning in a later patch.
>+
>+        This patch also enhances parameter naming by:
>+        - Removing parts that refer to "primary" as in primaryDomain.
>+        - Replacing references to "TopPrivatelyControlledDomain" with "RegistrableDomain."
>+        - Replacing references to "TopPrivatelyOwnedDomain" with "RegistrableDomain."
>+        - Using the term "domain" consistently instead of e.g. "host."
>+
>+        * WebCore.xcodeproj/project.pbxproj:
>+        * dom/Document.cpp:
>+        (WebCore::Document::hasRequestedPageSpecificStorageAccessWithUserInteraction):
>+        (WebCore::Document::setHasRequestedPageSpecificStorageAccessWithUserInteraction):
>+        * dom/Document.h:
>+        * html/HTMLAnchorElement.cpp:
>+        (WebCore::HTMLAnchorElement::parseAdClickAttribution const):
>+        * html/HTMLMediaElement.cpp:
>+        (WebCore::HTMLMediaElement::mediaSessionTitle const):
>+        * loader/AdClickAttribution.cpp:
>+        (WebCore::AdClickAttribution::url const):
>+        (WebCore::AdClickAttribution::referrer const):
>+        (WebCore::AdClickAttribution::toString const):
>+        * loader/AdClickAttribution.h:
>+        (WebCore::AdClickAttribution::Source::Source):
>+        (WebCore::AdClickAttribution::Source::matches const):
>+        (WebCore::AdClickAttribution::Source::deleteValue):
>+        (WebCore::AdClickAttribution::Destination::Destination):
>+        (WebCore::AdClickAttribution::Destination::matches const):
>+        (WebCore::AdClickAttribution::Destination::deleteValue):
>+        * loader/ResourceLoadObserver.cpp:
>+        (WebCore::ResourceLoadObserver::setRequestStorageAccessUnderOpenerCallback):
>+        (WebCore::ResourceLoadObserver::setLogUserInteractionNotificationCallback):
>+        (WebCore::ResourceLoadObserver::setLogWebSocketLoadingNotificationCallback):
>+        (WebCore::ResourceLoadObserver::setLogSubresourceLoadingNotificationCallback):
>+        (WebCore::ResourceLoadObserver::setLogSubresourceRedirectNotificationCallback):
>+        (WebCore::ResourceLoadObserver::logSubresourceLoading):
>+        (WebCore::ResourceLoadObserver::logWebSocketLoading):
>+        (WebCore::ResourceLoadObserver::logUserInteractionWithReducedTimeResolution):
>+        (WebCore::ResourceLoadObserver::requestStorageAccessUnderOpener):
>+        (WebCore::ResourceLoadObserver::logFontLoad):
>+        (WebCore::ResourceLoadObserver::logCanvasRead):
>+        (WebCore::ResourceLoadObserver::logCanvasWriteOrMeasure):
>+        (WebCore::ResourceLoadObserver::logNavigatorAPIAccessed):
>+        (WebCore::ResourceLoadObserver::logScreenAPIAccessed):
>+        (WebCore::ResourceLoadObserver::ensureResourceStatisticsForRegistrableDomain):
>+        (WebCore::ResourceLoadObserver::statisticsForOrigin):
>+        (WebCore::primaryDomain): Deleted.
>+        (WebCore::ResourceLoadObserver::ensureResourceStatisticsForPrimaryDomain): Deleted.
>+        * loader/ResourceLoadObserver.h:
>+        * loader/ResourceLoadStatistics.cpp:
>+        (WebCore::ResourceLoadStatistics::encode const):
>+        (WebCore::ResourceLoadStatistics::decode):
>+        (WebCore::ResourceLoadStatistics::toString const):
>+        (WebCore::ResourceLoadStatistics::merge):
>+        (WebCore::ResourceLoadStatistics::primaryDomain): Deleted.
>+        * loader/ResourceLoadStatistics.h:
>+        (WebCore::ResourceLoadStatistics::ResourceLoadStatistics):
>+        * page/Page.cpp:
>+        (WebCore::Page::logNavigation):
>+        (WebCore::Page::mainFrameLoadStarted):
>+        * page/Page.h:
>+        * page/PerformanceMonitor.cpp:
>+        (WebCore::reportPageOverPostLoadResourceThreshold):
>+        * platform/RegistrableDomain.h: Added.
>+        (WebCore::RegistrableDomain::RegistrableDomain):
>+        (WebCore::RegistrableDomain::isEmpty const):
>+        (WebCore::RegistrableDomain::string const):
>+        (WebCore::RegistrableDomain::operator!= const):
>+        (WebCore::RegistrableDomain::operator== const):
>+        (WebCore::RegistrableDomain::matches const):
>+        (WebCore::RegistrableDomain::isolatedCopy const):
>+        (WebCore::RegistrableDomain::isHashTableDeletedValue const):
>+        (WebCore::RegistrableDomain::hash const):
>+        (WebCore::RegistrableDomain::RegistrableDomainHash::hash):
>+        (WebCore::RegistrableDomain::RegistrableDomainHash::equal):
>+        (WebCore::RegistrableDomain::encode const):
>+        (WebCore::RegistrableDomain::decode):
>+        * platform/network/NetworkStorageSession.cpp:
>+        (WebCore::NetworkStorageSession::shouldBlockThirdPartyCookies const):
>+        (WebCore::NetworkStorageSession::shouldBlockCookies const):
>+        (WebCore::NetworkStorageSession::setPrevalentDomainsToBlockCookiesFor):
>+        (WebCore::NetworkStorageSession::removePrevalentDomains):
>+        (WebCore::NetworkStorageSession::hasStorageAccess const):
>+        (WebCore::NetworkStorageSession::getAllStorageAccessEntries const):
>+        (WebCore::NetworkStorageSession::grantStorageAccess):
>+        (WebCore::getPartitioningDomain): Deleted.
>+        * platform/network/NetworkStorageSession.h:
>+
> 2019-02-22  Sihui Liu  <sihui_liu@apple.com>
> 
>         Crash under IDBServer::IDBConnectionToClient::identifier() const
>diff --git a/Source/WebKit/ChangeLog b/Source/WebKit/ChangeLog
>index 3dd6e752e64b860bee844ad51599168deca597bd..5e9fe356ec849b49fe9c972e5dd83601f4ae96a5 100644
>--- a/Source/WebKit/ChangeLog
>+++ b/Source/WebKit/ChangeLog
>@@ -1,3 +1,281 @@
>+2019-02-22  John Wilander  <wilander@apple.com>
>+
>+        Introduce and adopt new class RegistrableDomain for eTLD+1
>+        https://bugs.webkit.org/show_bug.cgi?id=194791
>+        <rdar://problem/48179240>
>+
>+        Reviewed by NOBODY (OOPS!).
>+
>+        A new API test was added. Plenty of existing layout tests under
>+        http/tests/resourceLoadStatistics/ and http/tests/storageAccess/ test the code.
>+
>+        This patch introduces and adopts a new class called WebCore::RegistrableDomain
>+        which represents a domain's eTLD+1 (effective top level domain plus one) and is
>+        the basis for the term "site," as in same-site. Other popular names include
>+        high-level domain, primary domain, and top privately controlled/owned domain.
>+        Effective top level domains are enumerated on the Public Suffix List
>+        (https://publicsuffix.org).
>+
>+        This class just uses the full domain for when the Public Suffix List cannot help
>+        finding the registrable domain and for WebKit ports that haven't enabled
>+        PUBLIC_SUFFIX_LIST. It also uses the string "nullOrigin" as a representation
>+        for the null or unique origin (this matches how these origins were handled
>+        before).
>+
>+        The implementation is a wrapper around a String and the functions and class
>+        members that now make use of this new class used to handle regular String
>+        objects which didn't help much in terms of type safety or guarantees that the
>+        string had already been converted to an eTLD+1.
>+
>+        We've at least two bad bugs in the Storage Access API because of confusion
>+        between a URL's eTLD+1 and its host. The usage of WebCore::RegistrableDomain
>+        will prohibit such bugs in the future.
>+
>+        Partitioning in WebKit also uses eTLD+1 to a large extent. I plan to adopt
>+        WebCore::RegistrableDomain for partitioning in a later patch.
>+
>+        This patch also enhances parameter naming by:
>+        - Removing parts that refer to "primary" as in primaryDomain.
>+        - Replacing references to "TopPrivatelyControlledDomain" with "RegistrableDomain."
>+        - Replacing references to "TopPrivatelyOwnedDomain" with "RegistrableDomain."
>+        - Using the term "domain" consistently instead of e.g. "host."
>+
>+        A follow-up patch will continue backwards in call chains to create
>+        WebCore::RegistrableDomain objects as early as possible instead of using strings.
>+        I did not do that work here in the interest of patch size.
>+
>+        * NetworkProcess/Classifier/ResourceLoadStatisticsMemoryStore.cpp:
>+        (WebKit::domainsToString):
>+        (WebKit::pruneResources):
>+        (WebKit::ResourceLoadStatisticsMemoryStore::removeDataRecords):
>+        (WebKit::ResourceLoadStatisticsMemoryStore::recursivelyGetAllDomainsThatHaveRedirectedToThisDomain const):
>+        (WebKit::ResourceLoadStatisticsMemoryStore::markAsPrevalentIfHasRedirectedToPrevalent):
>+        (WebKit::ResourceLoadStatisticsMemoryStore::isPrevalentDueToDebugMode):
>+        (WebKit::ResourceLoadStatisticsMemoryStore::hasStorageAccess):
>+        (WebKit::ResourceLoadStatisticsMemoryStore::requestStorageAccess):
>+        (WebKit::ResourceLoadStatisticsMemoryStore::requestStorageAccessUnderOpener):
>+        (WebKit::ResourceLoadStatisticsMemoryStore::grantStorageAccess):
>+        (WebKit::ResourceLoadStatisticsMemoryStore::grantStorageAccessInternal):
>+        (WebKit::ResourceLoadStatisticsMemoryStore::grandfatherExistingWebsiteData):
>+        (WebKit::ResourceLoadStatisticsMemoryStore::ensurePrevalentResourcesForDebugMode):
>+        (WebKit::ResourceLoadStatisticsMemoryStore::setPrevalentResourceForDebugMode):
>+        (WebKit::ResourceLoadStatisticsMemoryStore::logFrameNavigation):
>+        (WebKit::ResourceLoadStatisticsMemoryStore::logSubresourceLoading):
>+        (WebKit::ResourceLoadStatisticsMemoryStore::logSubresourceRedirect):
>+        (WebKit::ResourceLoadStatisticsMemoryStore::logUserInteraction):
>+        (WebKit::ResourceLoadStatisticsMemoryStore::clearUserInteraction):
>+        (WebKit::ResourceLoadStatisticsMemoryStore::hasHadUserInteraction):
>+        (WebKit::ResourceLoadStatisticsMemoryStore::setPrevalentResource):
>+        (WebKit::ResourceLoadStatisticsMemoryStore::isPrevalentResource const):
>+        (WebKit::ResourceLoadStatisticsMemoryStore::isVeryPrevalentResource const):
>+        (WebKit::ResourceLoadStatisticsMemoryStore::isRegisteredAsSubresourceUnder const):
>+        (WebKit::ResourceLoadStatisticsMemoryStore::isRegisteredAsSubFrameUnder const):
>+        (WebKit::ResourceLoadStatisticsMemoryStore::isRegisteredAsRedirectingTo const):
>+        (WebKit::ResourceLoadStatisticsMemoryStore::clearPrevalentResource):
>+        (WebKit::ResourceLoadStatisticsMemoryStore::setGrandfathered):
>+        (WebKit::ResourceLoadStatisticsMemoryStore::isGrandfathered const):
>+        (WebKit::ResourceLoadStatisticsMemoryStore::setSubframeUnderTopFrameOrigin):
>+        (WebKit::ResourceLoadStatisticsMemoryStore::setSubresourceUnderTopFrameOrigin):
>+        (WebKit::ResourceLoadStatisticsMemoryStore::setSubresourceUniqueRedirectTo):
>+        (WebKit::ResourceLoadStatisticsMemoryStore::setSubresourceUniqueRedirectFrom):
>+        (WebKit::ResourceLoadStatisticsMemoryStore::setTopFrameUniqueRedirectTo):
>+        (WebKit::ResourceLoadStatisticsMemoryStore::setTopFrameUniqueRedirectFrom):
>+        (WebKit::ResourceLoadStatisticsMemoryStore::ensureResourceStatisticsForRegistrableDomain):
>+        (WebKit::ResourceLoadStatisticsMemoryStore::mergeStatistics):
>+        (WebKit::ResourceLoadStatisticsMemoryStore::hasUserGrantedStorageAccessThroughPrompt):
>+        (WebKit::debugLogDomainsInBatches):
>+        (WebKit::ResourceLoadStatisticsMemoryStore::updateCookieBlocking):
>+        (WebKit::ResourceLoadStatisticsMemoryStore::updateCookieBlockingForDomains):
>+        (WebKit::ResourceLoadStatisticsMemoryStore::clearBlockingStateForDomains):
>+        (WebKit::ResourceLoadStatisticsMemoryStore::registrableDomainsToRemoveWebsiteDataFor):
>+        (WebKit::ResourceLoadStatisticsMemoryStore::pruneStatisticsIfNeeded):
>+        (WebKit::ResourceLoadStatisticsMemoryStore::setLastSeen):
>+        (WebKit::ResourceLoadStatisticsMemoryStore::setVeryPrevalentResource):
>+        (WebKit::ResourceLoadStatisticsMemoryStore::ensureResourceStatisticsForPrimaryDomain): Deleted.
>+        (WebKit::ResourceLoadStatisticsMemoryStore::topPrivatelyControlledDomainsToRemoveWebsiteDataFor): Deleted.
>+        * NetworkProcess/Classifier/ResourceLoadStatisticsMemoryStore.h:
>+        * NetworkProcess/Classifier/WebResourceLoadStatisticsStore.cpp:
>+        (WebKit::WebResourceLoadStatisticsStore::setPrevalentResourceForDebugMode):
>+        (WebKit::WebResourceLoadStatisticsStore::hasStorageAccess):
>+        (WebKit::WebResourceLoadStatisticsStore::hasStorageAccessForFrame):
>+        (WebKit::WebResourceLoadStatisticsStore::callHasStorageAccessForFrameHandler):
>+        (WebKit::WebResourceLoadStatisticsStore::requestStorageAccessGranted):
>+        (WebKit::WebResourceLoadStatisticsStore::requestStorageAccess):
>+        (WebKit::WebResourceLoadStatisticsStore::requestStorageAccessUnderOpener):
>+        (WebKit::WebResourceLoadStatisticsStore::grantStorageAccess):
>+        (WebKit::WebResourceLoadStatisticsStore::callGrantStorageAccessHandler):
>+        (WebKit::WebResourceLoadStatisticsStore::logFrameNavigation):
>+        (WebKit::WebResourceLoadStatisticsStore::logWebSocketLoading):
>+        (WebKit::WebResourceLoadStatisticsStore::logSubresourceLoading):
>+        (WebKit::WebResourceLoadStatisticsStore::logSubresourceRedirect):
>+        (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::scheduleCookieBlockingUpdateForDomains):
>+        (WebKit::WebResourceLoadStatisticsStore::scheduleClearBlockingStateForDomains):
>+        (WebKit::WebResourceLoadStatisticsStore::callUpdatePrevalentDomainsToBlockCookiesForHandler):
>+        (WebKit::WebResourceLoadStatisticsStore::removePrevalentDomains):
>+        (WebKit::WebResourceLoadStatisticsStore::callRemoveDomainsHandler):
>+        (WebKit::WebResourceLoadStatisticsStore::deleteWebsiteDataForRegistrableDomainsInAllPersistentDataStores):
>+        (WebKit::WebResourceLoadStatisticsStore::registrableDomainsWithWebsiteData):
>+        (WebKit::isolatedPrimaryDomain): Deleted.
>+        (WebKit::WebResourceLoadStatisticsStore::deleteWebsiteDataForTopPrivatelyControlledDomainsInAllPersistentDataStores): Deleted.
>+        (WebKit::WebResourceLoadStatisticsStore::topPrivatelyControlledDomainsWithWebsiteData): Deleted.
>+        * NetworkProcess/Classifier/WebResourceLoadStatisticsStore.h:
>+        * NetworkProcess/NetworkConnectionToWebProcess.cpp:
>+        (WebKit::NetworkConnectionToWebProcess::logUserInteraction):
>+        (WebKit::NetworkConnectionToWebProcess::logWebSocketLoading):
>+        (WebKit::NetworkConnectionToWebProcess::logSubresourceLoading):
>+        (WebKit::NetworkConnectionToWebProcess::logSubresourceRedirect):
>+        (WebKit::NetworkConnectionToWebProcess::hasStorageAccess):
>+        (WebKit::NetworkConnectionToWebProcess::requestStorageAccess):
>+        * NetworkProcess/NetworkConnectionToWebProcess.h:
>+        * NetworkProcess/NetworkConnectionToWebProcess.messages.in:
>+        * NetworkProcess/NetworkProcess.cpp:
>+        (WebKit::NetworkProcess::updatePrevalentDomainsToBlockCookiesFor):
>+        (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::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::hasStorageAccessForFrame):
>+        (WebKit::NetworkProcess::hasStorageAccess):
>+        (WebKit::NetworkProcess::requestStorageAccess):
>+        (WebKit::NetworkProcess::requestStorageAccessGranted):
>+        (WebKit::NetworkProcess::grantStorageAccess):
>+        (WebKit::NetworkProcess::logFrameNavigation):
>+        (WebKit::NetworkProcess::logUserInteraction):
>+        (WebKit::NetworkProcess::hadUserInteraction):
>+        (WebKit::NetworkProcess::clearUserInteraction):
>+        (WebKit::NetworkProcess::removePrevalentDomains):
>+        (WebKit::filterForRegistrableDomains):
>+        (WebKit::NetworkProcess::deleteWebsiteDataForRegistrableDomainsInAllPersistentDataStores):
>+        (WebKit::NetworkProcess::registrableDomainsWithWebsiteData):
>+        (WebKit::filterForTopLevelDomains): Deleted.
>+        (WebKit::NetworkProcess::deleteWebsiteDataForTopPrivatelyControlledDomainsInAllPersistentDataStores): Deleted.
>+        (WebKit::NetworkProcess::topPrivatelyControlledDomainsWithWebsiteData): Deleted.
>+        * NetworkProcess/NetworkProcess.h:
>+        * NetworkProcess/NetworkProcess.messages.in:
>+        * NetworkProcess/NetworkResourceLoader.cpp:
>+        (WebKit::logCookieInformationInternal):
>+        * NetworkProcess/NetworkSession.cpp:
>+        (WebKit::NetworkSession::deleteWebsiteDataForRegistrableDomainsInAllPersistentDataStores):
>+        (WebKit::NetworkSession::registrableDomainsWithWebsiteData):
>+        (WebKit::NetworkSession::deleteWebsiteDataForTopPrivatelyControlledDomainsInAllPersistentDataStores): Deleted.
>+        (WebKit::NetworkSession::topPrivatelyControlledDomainsWithWebsiteData): Deleted.
>+        * NetworkProcess/NetworkSession.h:
>+        * Shared/WebCoreArgumentCoders.cpp:
>+        (IPC::ArgumentCoder<ResourceLoadStatistics>::encode):
>+        (IPC::ArgumentCoder<ResourceLoadStatistics>::decode):
>+        * UIProcess/Cocoa/ResourceLoadStatisticsMemoryStoreCocoa.mm:
>+        (WebKit::ResourceLoadStatisticsMemoryStore::registerUserDefaultsIfNeeded):
>+        * UIProcess/Network/NetworkProcessProxy.cpp:
>+        (WebKit::NetworkProcessProxy::updatePrevalentDomainsToBlockCookiesFor):
>+        (WebKit::NetworkProcessProxy::isPrevalentResource):
>+        (WebKit::NetworkProcessProxy::isVeryPrevalentResource):
>+        (WebKit::NetworkProcessProxy::setPrevalentResource):
>+        (WebKit::NetworkProcessProxy::setPrevalentResourceForDebugMode):
>+        (WebKit::NetworkProcessProxy::setVeryPrevalentResource):
>+        (WebKit::NetworkProcessProxy::setLastSeen):
>+        (WebKit::NetworkProcessProxy::clearPrevalentResource):
>+        (WebKit::NetworkProcessProxy::logUserInteraction):
>+        (WebKit::NetworkProcessProxy::hasHadUserInteraction):
>+        (WebKit::NetworkProcessProxy::clearUserInteraction):
>+        (WebKit::NetworkProcessProxy::setSubframeUnderTopFrameOrigin):
>+        (WebKit::NetworkProcessProxy::isRegisteredAsRedirectingTo):
>+        (WebKit::NetworkProcessProxy::isRegisteredAsSubFrameUnder):
>+        (WebKit::NetworkProcessProxy::setSubresourceUnderTopFrameOrigin):
>+        (WebKit::NetworkProcessProxy::isRegisteredAsSubresourceUnder):
>+        (WebKit::NetworkProcessProxy::setSubresourceUniqueRedirectTo):
>+        (WebKit::NetworkProcessProxy::setSubresourceUniqueRedirectFrom):
>+        (WebKit::NetworkProcessProxy::setTopFrameUniqueRedirectTo):
>+        (WebKit::NetworkProcessProxy::setTopFrameUniqueRedirectFrom):
>+        (WebKit::NetworkProcessProxy::isGrandfathered):
>+        (WebKit::NetworkProcessProxy::setGrandfathered):
>+        (WebKit::NetworkProcessProxy::hasStorageAccessForFrame):
>+        (WebKit::NetworkProcessProxy::hasStorageAccess):
>+        (WebKit::NetworkProcessProxy::requestStorageAccess):
>+        (WebKit::NetworkProcessProxy::grantStorageAccess):
>+        (WebKit::NetworkProcessProxy::notifyWebsiteDataDeletionForRegistrableDomainsFinished):
>+        (WebKit::NetworkProcessProxy::notifyWebsiteDataScanForRegistrableDomainsFinished):
>+        (WebKit::NetworkProcessProxy::notifyWebsiteDataDeletionForTopPrivatelyOwnedDomainsFinished): Deleted.
>+        (WebKit::NetworkProcessProxy::notifyWebsiteDataScanForTopPrivatelyControlledDomainsFinished): Deleted.
>+        * UIProcess/Network/NetworkProcessProxy.h:
>+        * UIProcess/Network/NetworkProcessProxy.messages.in:
>+        * UIProcess/WebPageProxy.cpp:
>+        (WebKit::WebPageProxy::logFrameNavigation):
>+        (WebKit::WebPageProxy::requestStorageAccessConfirm):
>+        * UIProcess/WebProcessProxy.cpp:
>+        (WebKit::WebProcessProxy::notifyPageStatisticsAndDataRecordsProcessed):
>+        (WebKit::WebProcessProxy::notifyWebsiteDataScanForRegistrableDomainsFinished):
>+        (WebKit::WebProcessProxy::notifyWebsiteDataDeletionForRegistrableDomainsFinished):
>+        (WebKit::WebProcessProxy::notifyWebsiteDataScanForTopPrivatelyControlledDomainsFinished): Deleted.
>+        (WebKit::WebProcessProxy::notifyWebsiteDataDeletionForTopPrivatelyOwnedDomainsFinished): Deleted.
>+        * UIProcess/WebProcessProxy.h:
>+        * UIProcess/WebResourceLoadStatisticsStore.messages.in:
>+        * UIProcess/WebsiteData/WebsiteDataStore.cpp:
>+        (WebKit::WebsiteDataStore::isPrevalentResource):
>+        (WebKit::WebsiteDataStore::setPrevalentResource):
>+        (WebKit::WebsiteDataStore::setPrevalentResourceForDebugMode):
>+        (WebKit::WebsiteDataStore::isVeryPrevalentResource):
>+        (WebKit::WebsiteDataStore::setVeryPrevalentResource):
>+        (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::setLastSeen):
>+        (WebKit::WebsiteDataStore::hasStorageAccess):
>+        (WebKit::WebsiteDataStore::requestStorageAccess):
>+        (WebKit::WebsiteDataStore::grantStorageAccess):
>+        (WebKit::WebsiteDataStore::logUserInteraction):
>+        (WebKit::WebsiteDataStore::hasHadUserInteraction):
>+        (WebKit::WebsiteDataStore::clearUserInteraction):
>+        (WebKit::WebsiteDataStore::setGrandfathered):
>+        (WebKit::WebsiteDataStore::fetchDataForTopPrivatelyControlledDomains): Deleted.
>+        * UIProcess/WebsiteData/WebsiteDataStore.h:
>+        * WebProcess/WebPage/WebPage.cpp:
>+        (WebKit::WebPage::hasStorageAccess):
>+        (WebKit::WebPage::requestStorageAccess):
>+        * WebProcess/WebProcess.cpp:
>+        (WebKit::m_nonVisibleProcessCleanupTimer):
>+        (WebKit::WebProcess::initializeWebProcess):
>+
> 2019-02-22  Chris Dumez  <cdumez@apple.com>
> 
>         Regression(PSON) Unable to preview password-protected documents on iCloud.com
>diff --git a/Source/WebCore/WebCore.xcodeproj/project.pbxproj b/Source/WebCore/WebCore.xcodeproj/project.pbxproj
>index 46a2d8ce7084e774b3f282772c6cee0b5017e6f3..50ecabf98a36d0537de8bc131b60c2d4b12d5a8c 100644
>--- a/Source/WebCore/WebCore.xcodeproj/project.pbxproj
>+++ b/Source/WebCore/WebCore.xcodeproj/project.pbxproj
>@@ -2014,6 +2014,7 @@
> 		6A72798B1F16C29C003F39B8 /* InspectorShaderProgram.h in Headers */ = {isa = PBXBuildFile; fileRef = 6A7279881F16C29B003F39B8 /* InspectorShaderProgram.h */; };
> 		6B0A07F221FA4B5C00D57391 /* AdClickAttribution.h in Headers */ = {isa = PBXBuildFile; fileRef = 6B0A07F021FA4B5C00D57391 /* AdClickAttribution.h */; settings = {ATTRIBUTES = (Private, ); }; };
> 		6B3480940EEF50D400AC1B41 /* NativeImage.h in Headers */ = {isa = PBXBuildFile; fileRef = 6B3480920EEF50D400AC1B41 /* NativeImage.h */; settings = {ATTRIBUTES = (Private, ); }; };
>+		6B4E8613221B713F0022F389 /* RegistrableDomain.h in Headers */ = {isa = PBXBuildFile; fileRef = 6B4E8612221B713F0022F389 /* RegistrableDomain.h */; settings = {ATTRIBUTES = (Private, ); }; };
> 		6B693A2E1C51A82E00B03BEF /* ResourceLoadObserver.h in Headers */ = {isa = PBXBuildFile; fileRef = 6B693A2D1C51A82E00B03BEF /* ResourceLoadObserver.h */; settings = {ATTRIBUTES = (Private, ); }; };
> 		6C4C96DF1AD4483500363F64 /* JSReadableByteStreamController.h in Headers */ = {isa = PBXBuildFile; fileRef = 6C4C96DB1AD4483500363F64 /* JSReadableByteStreamController.h */; };
> 		6C4C96DF1AD4483500365672 /* JSReadableStreamBYOBRequest.h in Headers */ = {isa = PBXBuildFile; fileRef = 6C4C96DB1AD4483500365672 /* JSReadableStreamBYOBRequest.h */; };
>@@ -9143,6 +9144,7 @@
> 		6B0A07F021FA4B5C00D57391 /* AdClickAttribution.h */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.c.h; path = AdClickAttribution.h; sourceTree = "<group>"; };
> 		6B0A07F121FA4B5C00D57391 /* AdClickAttribution.cpp */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.cpp.cpp; path = AdClickAttribution.cpp; sourceTree = "<group>"; };
> 		6B3480920EEF50D400AC1B41 /* NativeImage.h */ = {isa = PBXFileReference; fileEncoding = 30; lastKnownFileType = sourcecode.c.h; path = NativeImage.h; sourceTree = "<group>"; };
>+		6B4E8612221B713F0022F389 /* RegistrableDomain.h */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.c.h; path = RegistrableDomain.h; sourceTree = "<group>"; };
> 		6B693A2D1C51A82E00B03BEF /* ResourceLoadObserver.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = ResourceLoadObserver.h; sourceTree = "<group>"; };
> 		6B693A331C51A95D00B03BEF /* ResourceLoadObserver.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = ResourceLoadObserver.cpp; sourceTree = "<group>"; };
> 		6C4C96DA1AD4483500363F64 /* JSReadableByteStreamController.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = JSReadableByteStreamController.cpp; sourceTree = "<group>"; };
>@@ -25618,6 +25620,7 @@
> 				5C97A3361F5F7A6500105207 /* RectEdges.h */,
> 				CA1635DC2072E76900E7D2CE /* ReferrerPolicy.cpp */,
> 				9831AE49154225A200FE2644 /* ReferrerPolicy.h */,
>+				6B4E8612221B713F0022F389 /* RegistrableDomain.h */,
> 				CDFC360318CA61C20026E56F /* RemoteCommandListener.cpp */,
> 				CDFC360418CA61C20026E56F /* RemoteCommandListener.h */,
> 				A18F7A351ECA73640059E1E1 /* RuntimeApplicationChecks.cpp */,
>@@ -31208,6 +31211,7 @@
> 				BCAB418213E356E800D8AAF3 /* Region.h in Headers */,
> 				26B9998F1803AE7200D01121 /* RegisterAllocator.h in Headers */,
> 				85031B4C0A44EFC700F992E0 /* RegisteredEventListener.h in Headers */,
>+				6B4E8613221B713F0022F389 /* RegistrableDomain.h in Headers */,
> 				51B914101FD2782D00EE2859 /* RegistrationDatabase.h in Headers */,
> 				51B914111FD2782D00EE2859 /* RegistrationStore.h in Headers */,
> 				A578F43F1DE0B630003DFC6A /* RejectedPromiseTracker.h in Headers */,
>diff --git a/Source/WebCore/dom/Document.cpp b/Source/WebCore/dom/Document.cpp
>index 2ba962e5860aaf8a0a23c19749608a07369a85cf..baad10b7c9ec6cf6c4f4eea2cfc254002a00eb38 100644
>--- a/Source/WebCore/dom/Document.cpp
>+++ b/Source/WebCore/dom/Document.cpp
>@@ -8454,14 +8454,14 @@ void Document::setHasFrameSpecificStorageAccess(bool value)
>         m_frame->loader().client().setHasFrameSpecificStorageAccess(value);
> }
> 
>-bool Document::hasRequestedPageSpecificStorageAccessWithUserInteraction(const String& primaryDomain)
>+bool Document::hasRequestedPageSpecificStorageAccessWithUserInteraction(const RegistrableDomain& domain)
> {
>-    return m_primaryDomainRequestedPageSpecificStorageAccessWithUserInteraction == primaryDomain;
>+    return m_registrableDomainRequestedPageSpecificStorageAccessWithUserInteraction == domain;
> }
> 
>-void Document::setHasRequestedPageSpecificStorageAccessWithUserInteraction(const String& primaryDomain)
>+void Document::setHasRequestedPageSpecificStorageAccessWithUserInteraction(const RegistrableDomain& domain)
> {
>-    m_primaryDomainRequestedPageSpecificStorageAccessWithUserInteraction = primaryDomain;
>+    m_registrableDomainRequestedPageSpecificStorageAccessWithUserInteraction = domain;
> }
> #endif
> 
>diff --git a/Source/WebCore/dom/Document.h b/Source/WebCore/dom/Document.h
>index fb423677a9343e5229b1e47b2e8dfc0c197a2040..f65a5299ddcb8f5cffaeec9d00dec64f58c1ac2a 100644
>--- a/Source/WebCore/dom/Document.h
>+++ b/Source/WebCore/dom/Document.h
>@@ -44,6 +44,7 @@
> #include "PlatformEvent.h"
> #include "ReferrerPolicy.h"
> #include "Region.h"
>+#include "RegistrableDomain.h"
> #include "RenderPtr.h"
> #include "ScriptExecutionContext.h"
> #include "SecurityPolicyViolationEvent.h"
>@@ -1494,8 +1495,8 @@ public:
> #endif
> 
> #if ENABLE(RESOURCE_LOAD_STATISTICS)
>-    bool hasRequestedPageSpecificStorageAccessWithUserInteraction(const String& primaryDomain);
>-    void setHasRequestedPageSpecificStorageAccessWithUserInteraction(const String& primaryDomain);
>+    bool hasRequestedPageSpecificStorageAccessWithUserInteraction(const RegistrableDomain&);
>+    void setHasRequestedPageSpecificStorageAccessWithUserInteraction(const RegistrableDomain&);
> #endif
> 
>     String signedPublicKeyAndChallengeString(unsigned keySizeIndex, const String& challengeString, const URL&);
>@@ -2059,7 +2060,7 @@ private:
>     HashSet<ApplicationStateChangeListener*> m_applicationStateChangeListeners;
>     
> #if ENABLE(RESOURCE_LOAD_STATISTICS)
>-    String m_primaryDomainRequestedPageSpecificStorageAccessWithUserInteraction { };
>+    RegistrableDomain m_registrableDomainRequestedPageSpecificStorageAccessWithUserInteraction { };
> #endif
>     
>     std::unique_ptr<UserGestureIndicator> m_temporaryUserGesture;
>diff --git a/Source/WebCore/html/HTMLAnchorElement.cpp b/Source/WebCore/html/HTMLAnchorElement.cpp
>index b6353619fffea5a10ba9b91d6856f1f020d096b2..cfb2b519a8228559e66c323f7858e706b54869bf 100644
>--- a/Source/WebCore/html/HTMLAnchorElement.cpp
>+++ b/Source/WebCore/html/HTMLAnchorElement.cpp
>@@ -42,7 +42,7 @@
> #include "MouseEvent.h"
> #include "PingLoader.h"
> #include "PlatformMouseEvent.h"
>-#include "PublicSuffix.h"
>+#include "RegistrableDomain.h"
> #include "RenderImage.h"
> #include "ResourceRequest.h"
> #include "RuntimeEnabledFeatures.h"
>@@ -442,12 +442,7 @@ Optional<AdClickAttribution> HTMLAnchorElement::parseAdClickAttribution() const
>     }
> 
>     auto documentDomain = document().domain();
>-    auto adDestinationHost = adDestinationURL.host().toString();
>-#if ENABLE(PUBLIC_SUFFIX_LIST)
>-    if (topPrivatelyControlledDomain(documentDomain) == topPrivatelyControlledDomain(adDestinationHost)) {
>-#else
>-    if (documentDomain == adDestinationHost) {
>-#endif
>+    if (RegistrableDomain(documentDomain).matches(adDestinationURL)) {
>         document().addConsoleMessage(MessageSource::Other, MessageLevel::Warning, "addestination can not be the same site as the current website."_s);
>         return WTF::nullopt;
>     }
>diff --git a/Source/WebCore/html/HTMLMediaElement.cpp b/Source/WebCore/html/HTMLMediaElement.cpp
>index b3eb7bbc3217f434b5671838b2a3d80433426adf..b367c6add39e1c2b7476f8c8023f8d9d55048997 100644
>--- a/Source/WebCore/html/HTMLMediaElement.cpp
>+++ b/Source/WebCore/html/HTMLMediaElement.cpp
>@@ -73,8 +73,8 @@
> #include "PageGroup.h"
> #include "PlatformMediaSessionManager.h"
> #include "ProgressTracker.h"
>-#include "PublicSuffix.h"
> #include "Quirks.h"
>+#include "RegistrableDomain.h"
> #include "RenderLayerCompositor.h"
> #include "RenderTheme.h"
> #include "RenderVideo.h"
>@@ -7662,13 +7662,11 @@ String HTMLMediaElement::mediaSessionTitle() const
>     if (!title.isEmpty())
>         title = decodeHostName(title);
> #endif
>-#if ENABLE(PUBLIC_SUFFIX_LIST)
>     if (!title.isEmpty()) {
>-        auto domain = topPrivatelyControlledDomain(title);
>+        auto domain = RegistrableDomain { title };
>         if (!domain.isEmpty())
>-            title = domain;
>+            title = domain.string();
>     }
>-#endif
> 
>     return title;
> }
>diff --git a/Source/WebCore/loader/AdClickAttribution.cpp b/Source/WebCore/loader/AdClickAttribution.cpp
>index 460cc5ceac089430a61cf8f7d059e521e2b5916d..4e6a893e44b8c0b16623a9dd8aa31e899e320827 100644
>--- a/Source/WebCore/loader/AdClickAttribution.cpp
>+++ b/Source/WebCore/loader/AdClickAttribution.cpp
>@@ -60,7 +60,7 @@ URL AdClickAttribution::url() const
> 
>     StringBuilder builder;
>     builder.appendLiteral("https://");
>-    builder.append(m_source.registrableDomain);
>+    builder.append(m_source.registrableDomain.string());
>     builder.appendLiteral("/.well-known/ad-click-attribution/");
>     builder.appendNumber(m_conversion.value().data);
>     builder.append('/');
>@@ -80,7 +80,7 @@ URL AdClickAttribution::referrer() const
> 
>     StringBuilder builder;
>     builder.appendLiteral("https://");
>-    builder.append(m_destination.registrableDomain);
>+    builder.append(m_destination.registrableDomain.string());
>     builder.append('/');
> 
>     URL url { URL(), builder.toString() };
>@@ -94,9 +94,9 @@ String AdClickAttribution::toString() const
> {
>     StringBuilder builder;
>     builder.appendLiteral("Source: ");
>-    builder.append(m_source.registrableDomain);
>+    builder.append(m_source.registrableDomain.string());
>     builder.appendLiteral("\nDestination: ");
>-    builder.append(m_destination.registrableDomain);
>+    builder.append(m_destination.registrableDomain.string());
>     builder.appendLiteral("\nCampaign ID: ");
>     builder.appendNumber(m_campaign.id);
>     if (m_conversion) {
>diff --git a/Source/WebCore/loader/AdClickAttribution.h b/Source/WebCore/loader/AdClickAttribution.h
>index bec48e38309dd31d77e1a94482eb7d5df0cc207a..fc17b476566944df4ff0f1d66961a657b4d6972b 100644
>--- a/Source/WebCore/loader/AdClickAttribution.h
>+++ b/Source/WebCore/loader/AdClickAttribution.h
>@@ -25,7 +25,7 @@
> 
> #pragma once
> 
>-#include "PublicSuffix.h"
>+#include "RegistrableDomain.h"
> #include <wtf/Optional.h>
> #include <wtf/URL.h>
> #include <wtf/WallTime.h>
>@@ -60,11 +60,7 @@ public:
>     struct Source {
>         Source() = default;
>         explicit Source(const String& host)
>-#if ENABLE(PUBLIC_SUFFIX_LIST)
>-            : registrableDomain { topPrivatelyControlledDomain(host) }
>-#else
>-            : registrableDomain { emptyString() }
>-#endif
>+            : registrableDomain { RegistrableDomain { host } }
>         {
>         }
> 
>@@ -80,11 +76,7 @@ public:
> 
>         bool matches(const URL& url) const
>         {
>-#if ENABLE(PUBLIC_SUFFIX_LIST)
>-            return registrableDomain == topPrivatelyControlledDomain(url.host().toString());
>-#else
>-            return registrableDomain == url.host().toString();
>-#endif
>+            return registrableDomain.matches(url);
>         }
> 
>         bool isHashTableDeletedValue() const
>@@ -105,7 +97,7 @@ public:
> 
>         void deleteValue()
>         {
>-            registrableDomain = String { WTF::HashTableDeletedValue };
>+            registrableDomain = RegistrableDomain { WTF::HashTableDeletedValue };
>         }
> 
>         bool isDeletedValue() const
>@@ -113,7 +105,7 @@ public:
>             return isHashTableDeletedValue();
>         }
> 
>-        String registrableDomain;
>+        RegistrableDomain registrableDomain;
>     };
> 
>     struct SourceHash {
>@@ -133,11 +125,7 @@ public:
>     struct Destination {
>         Destination() = default;
>         explicit Destination(const String& host)
>-#if ENABLE(PUBLIC_SUFFIX_LIST)
>-            : registrableDomain { topPrivatelyControlledDomain(host) }
>-#else
>-            : registrableDomain { emptyString() }
>-#endif
>+            : registrableDomain { RegistrableDomain { host } }
>         {
>         }
> 
>@@ -148,11 +136,7 @@ public:
> 
>         bool matches(const URL& url) const
>         {
>-#if ENABLE(PUBLIC_SUFFIX_LIST)
>-            return registrableDomain == topPrivatelyControlledDomain(url.host().toString());
>-#else
>-            return registrableDomain == url.host().toString();
>-#endif
>+            return registrableDomain == RegistrableDomain { url };
>         }
>         
>         bool isHashTableDeletedValue() const
>@@ -173,7 +157,7 @@ public:
> 
>         void deleteValue()
>         {
>-            registrableDomain = String { WTF::HashTableDeletedValue };
>+            registrableDomain = RegistrableDomain { WTF::HashTableDeletedValue };
>         }
> 
>         bool isDeletedValue() const
>@@ -181,7 +165,7 @@ public:
>             return isHashTableDeletedValue();
>         }
> 
>-        String registrableDomain;
>+        RegistrableDomain registrableDomain;
>     };
> 
>     struct DestinationHash {
>diff --git a/Source/WebCore/loader/ResourceLoadObserver.cpp b/Source/WebCore/loader/ResourceLoadObserver.cpp
>index 30dfaa0a43ea16216ea6fe134679021561639735..f0084a4307926d8d98ae541a224526e1d725ed7e 100644
>--- a/Source/WebCore/loader/ResourceLoadObserver.cpp
>+++ b/Source/WebCore/loader/ResourceLoadObserver.cpp
>@@ -33,6 +33,7 @@
> #include "HTMLFrameOwnerElement.h"
> #include "Logging.h"
> #include "Page.h"
>+#include "RegistrableDomain.h"
> #include "ResourceLoadStatistics.h"
> #include "ResourceRequest.h"
> #include "ResourceResponse.h"
>@@ -44,11 +45,6 @@
> 
> namespace WebCore {
> 
>-template<typename T> static inline String primaryDomain(const T& value)
>-{
>-    return ResourceLoadStatistics::primaryDomain(value);
>-}
>-
> static const Seconds minimumNotificationInterval { 5_s };
> 
> ResourceLoadObserver& ResourceLoadObserver::shared()
>@@ -63,31 +59,31 @@ void ResourceLoadObserver::setNotificationCallback(WTF::Function<void (Vector<Re
>     m_notificationCallback = WTFMove(notificationCallback);
> }
> 
>-void ResourceLoadObserver::setRequestStorageAccessUnderOpenerCallback(WTF::Function<void(const String& domainInNeedOfStorageAccess, uint64_t openerPageID, const String& openerDomain)>&& callback)
>+void ResourceLoadObserver::setRequestStorageAccessUnderOpenerCallback(WTF::Function<void(const RegistrableDomain& domainInNeedOfStorageAccess, uint64_t openerPageID, const RegistrableDomain& openerDomain)>&& callback)
> {
>     ASSERT(!m_requestStorageAccessUnderOpenerCallback);
>     m_requestStorageAccessUnderOpenerCallback = WTFMove(callback);
> }
> 
>-void ResourceLoadObserver::setLogUserInteractionNotificationCallback(Function<void(PAL::SessionID, const String&)>&& callback)
>+void ResourceLoadObserver::setLogUserInteractionNotificationCallback(Function<void(PAL::SessionID, const RegistrableDomain&)>&& callback)
> {
>     ASSERT(!m_logUserInteractionNotificationCallback);
>     m_logUserInteractionNotificationCallback = WTFMove(callback);
> }
> 
>-void ResourceLoadObserver::setLogWebSocketLoadingNotificationCallback(Function<void(PAL::SessionID, const String&, const String&, WallTime)>&& callback)
>+void ResourceLoadObserver::setLogWebSocketLoadingNotificationCallback(Function<void(PAL::SessionID, const RegistrableDomain&, const RegistrableDomain&, WallTime)>&& callback)
> {
>     ASSERT(!m_logWebSocketLoadingNotificationCallback);
>     m_logWebSocketLoadingNotificationCallback = WTFMove(callback);
> }
> 
>-void ResourceLoadObserver::setLogSubresourceLoadingNotificationCallback(Function<void(PAL::SessionID, const String&, const String&, WallTime)>&& callback)
>+void ResourceLoadObserver::setLogSubresourceLoadingNotificationCallback(Function<void(PAL::SessionID, const RegistrableDomain&, const RegistrableDomain&, WallTime)>&& callback)
> {
>     ASSERT(!m_logSubresourceLoadingNotificationCallback);
>     m_logSubresourceLoadingNotificationCallback = WTFMove(callback);
> }
> 
>-void ResourceLoadObserver::setLogSubresourceRedirectNotificationCallback(Function<void(PAL::SessionID, const String&, const String&)>&& callback)
>+void ResourceLoadObserver::setLogSubresourceRedirectNotificationCallback(Function<void(PAL::SessionID, const RegistrableDomain&, const RegistrableDomain&)>&& callback)
> {
>     ASSERT(!m_logSubresourceRedirectNotificationCallback);
>     m_logSubresourceRedirectNotificationCallback = WTFMove(callback);
>@@ -130,34 +126,34 @@ void ResourceLoadObserver::logSubresourceLoading(const Frame* frame, const Resou
>     if (targetHost.isEmpty() || mainFrameHost.isEmpty() || targetHost == mainFrameHost || (isRedirect && targetHost == sourceURL.host()))
>         return;
> 
>-    auto targetPrimaryDomain = primaryDomain(targetURL);
>-    auto mainFramePrimaryDomain = primaryDomain(mainFrameURL);
>-    auto sourcePrimaryDomain = primaryDomain(sourceURL);
>+    RegistrableDomain targetDomain { targetURL };
>+    RegistrableDomain mainFrameDomain { mainFrameURL };
>+    RegistrableDomain sourceDomain { sourceURL };
> 
>-    if (targetPrimaryDomain == mainFramePrimaryDomain || (isRedirect && targetPrimaryDomain == sourcePrimaryDomain))
>+    if (targetDomain == mainFrameDomain || (isRedirect && targetDomain == sourceDomain))
>         return;
> 
>     bool shouldCallNotificationCallback = false;
>     {
>-        auto& targetStatistics = ensureResourceStatisticsForPrimaryDomain(targetPrimaryDomain);
>+        auto& targetStatistics = ensureResourceStatisticsForRegistrableDomain(targetDomain);
>         auto lastSeen = ResourceLoadStatistics::reduceTimeResolution(WallTime::now());
>         targetStatistics.lastSeen = lastSeen;
>-        if (targetStatistics.subresourceUnderTopFrameOrigins.add(mainFramePrimaryDomain).isNewEntry)
>+        if (targetStatistics.subresourceUnderTopFrameOrigins.add(mainFrameDomain.string()).isNewEntry)
>             shouldCallNotificationCallback = true;
> 
>-        m_logSubresourceLoadingNotificationCallback(page->sessionID(), targetPrimaryDomain, mainFramePrimaryDomain, lastSeen);
>+        m_logSubresourceLoadingNotificationCallback(page->sessionID(), targetDomain, mainFrameDomain, lastSeen);
>     }
> 
>     if (isRedirect) {
>-        auto& redirectingOriginStatistics = ensureResourceStatisticsForPrimaryDomain(sourcePrimaryDomain);
>-        bool isNewRedirectToEntry = redirectingOriginStatistics.subresourceUniqueRedirectsTo.add(targetPrimaryDomain).isNewEntry;
>-        auto& targetStatistics = ensureResourceStatisticsForPrimaryDomain(targetPrimaryDomain);
>-        bool isNewRedirectFromEntry = targetStatistics.subresourceUniqueRedirectsFrom.add(sourcePrimaryDomain).isNewEntry;
>+        auto& redirectingOriginStatistics = ensureResourceStatisticsForRegistrableDomain(sourceDomain);
>+        bool isNewRedirectToEntry = redirectingOriginStatistics.subresourceUniqueRedirectsTo.add(targetDomain.string()).isNewEntry;
>+        auto& targetStatistics = ensureResourceStatisticsForRegistrableDomain(targetDomain);
>+        bool isNewRedirectFromEntry = targetStatistics.subresourceUniqueRedirectsFrom.add(sourceDomain.string()).isNewEntry;
> 
>         if (isNewRedirectToEntry || isNewRedirectFromEntry)
>             shouldCallNotificationCallback = true;
> 
>-        m_logSubresourceRedirectNotificationCallback(page->sessionID(), sourcePrimaryDomain, targetPrimaryDomain);
>+        m_logSubresourceRedirectNotificationCallback(page->sessionID(), sourceDomain, targetDomain);
>     }
> 
>     if (shouldCallNotificationCallback)
>@@ -175,20 +171,20 @@ void ResourceLoadObserver::logWebSocketLoading(const URL& targetURL, const URL&
>     if (targetHost.isEmpty() || mainFrameHost.isEmpty() || targetHost == mainFrameHost)
>         return;
>     
>-    auto targetPrimaryDomain = primaryDomain(targetURL);
>-    auto mainFramePrimaryDomain = primaryDomain(mainFrameURL);
>+    RegistrableDomain targetDomain { targetURL };
>+    RegistrableDomain mainFrameDomain { mainFrameURL };
> 
>-    if (targetPrimaryDomain == mainFramePrimaryDomain)
>+    if (targetDomain == mainFrameDomain)
>         return;
> 
>     auto lastSeen = ResourceLoadStatistics::reduceTimeResolution(WallTime::now());
> 
>-    auto& targetStatistics = ensureResourceStatisticsForPrimaryDomain(targetPrimaryDomain);
>+    auto& targetStatistics = ensureResourceStatisticsForRegistrableDomain(targetDomain);
>     targetStatistics.lastSeen = lastSeen;
>-    if (targetStatistics.subresourceUnderTopFrameOrigins.add(mainFramePrimaryDomain).isNewEntry)
>+    if (targetStatistics.subresourceUnderTopFrameOrigins.add(mainFrameDomain.string()).isNewEntry)
>         scheduleNotificationIfNeeded();
> 
>-    m_logWebSocketLoadingNotificationCallback(sessionID, targetPrimaryDomain, mainFramePrimaryDomain, lastSeen);
>+    m_logWebSocketLoadingNotificationCallback(sessionID, targetDomain, mainFrameDomain, lastSeen);
> }
> 
> void ResourceLoadObserver::logUserInteractionWithReducedTimeResolution(const Document& document)
>@@ -197,10 +193,10 @@ void ResourceLoadObserver::logUserInteractionWithReducedTimeResolution(const Doc
>         return;
> 
>     auto& url = document.url();
>-    if (url.protocolIsAbout() || url.isEmpty())
>+    if (url.protocolIsAbout() || url.isLocalFile() || url.isEmpty())
>         return;
> 
>-    auto domain = primaryDomain(url);
>+    RegistrableDomain domain { url };
>     auto newTime = ResourceLoadStatistics::reduceTimeResolution(WallTime::now());
>     auto lastReportedUserInteraction = m_lastReportedUserInteractionMap.get(domain);
>     if (newTime == lastReportedUserInteraction)
>@@ -208,7 +204,7 @@ void ResourceLoadObserver::logUserInteractionWithReducedTimeResolution(const Doc
> 
>     m_lastReportedUserInteractionMap.set(domain, newTime);
> 
>-    auto& statistics = ensureResourceStatisticsForPrimaryDomain(domain);
>+    auto& statistics = ensureResourceStatisticsForRegistrableDomain(domain);
>     statistics.hadUserInteraction = true;
>     statistics.lastSeen = newTime;
>     statistics.mostRecentUserInteractionTime = newTime;
>@@ -242,7 +238,7 @@ void ResourceLoadObserver::logUserInteractionWithReducedTimeResolution(const Doc
>             return s;
>         };
>         auto escapedURL = escapeForJSON(url.string());
>-        auto escapedDomain = escapeForJSON(domain);
>+        auto escapedDomain = escapeForJSON(domain.string());
> 
>         LOCAL_LOG(R"({ "url": "%{public}s",)", escapedURL.utf8().data());
>         LOCAL_LOG(R"(  "domain" : "%{public}s",)", escapedDomain.utf8().data());
>@@ -254,14 +250,14 @@ void ResourceLoadObserver::logUserInteractionWithReducedTimeResolution(const Doc
> }
> 
> #if ENABLE(RESOURCE_LOAD_STATISTICS)
>-void ResourceLoadObserver::requestStorageAccessUnderOpener(const String& domainInNeedOfStorageAccess, uint64_t openerPageID, Document& openerDocument)
>+void ResourceLoadObserver::requestStorageAccessUnderOpener(const RegistrableDomain& domainInNeedOfStorageAccess, uint64_t openerPageID, Document& openerDocument)
> {
>     auto openerUrl = openerDocument.url();
>-    auto openerPrimaryDomain = primaryDomain(openerUrl);
>-    if (domainInNeedOfStorageAccess != openerPrimaryDomain
>+    RegistrableDomain openerDomain { openerUrl };
>+    if (domainInNeedOfStorageAccess != openerDomain
>         && !openerDocument.hasRequestedPageSpecificStorageAccessWithUserInteraction(domainInNeedOfStorageAccess)
>         && !equalIgnoringASCIICase(openerUrl.string(), WTF::blankURL())) {
>-        m_requestStorageAccessUnderOpenerCallback(domainInNeedOfStorageAccess, openerPageID, openerPrimaryDomain);
>+        m_requestStorageAccessUnderOpenerCallback(domainInNeedOfStorageAccess, openerPageID, openerDomain);
>         // Remember user interaction-based requests since they don't need to be repeated.
>         openerDocument.setHasRequestedPageSpecificStorageAccessWithUserInteraction(domainInNeedOfStorageAccess);
>     }
>@@ -273,8 +269,8 @@ void ResourceLoadObserver::logFontLoad(const Document& document, const String& f
> #if ENABLE(WEB_API_STATISTICS)
>     if (!shouldLog(document.sessionID().isEphemeral()))
>         return;
>-    auto registrableDomain = primaryDomain(document.url());
>-    auto& statistics = ensureResourceStatisticsForPrimaryDomain(registrableDomain);
>+    RegistrableDomain registrableDomain { document.url() };
>+    auto& statistics = ensureResourceStatisticsForRegistrableDomain(registrableDomain);
>     bool shouldCallNotificationCallback = false;
>     if (!loadStatus) {
>         if (statistics.fontsFailedToLoad.add(familyName).isNewEntry)
>@@ -283,8 +279,8 @@ void ResourceLoadObserver::logFontLoad(const Document& document, const String& f
>         if (statistics.fontsSuccessfullyLoaded.add(familyName).isNewEntry)
>             shouldCallNotificationCallback = true;
>     }
>-    auto mainFrameRegistrableDomain = primaryDomain(document.topDocument().url());
>-    if (statistics.topFrameRegistrableDomainsWhichAccessedWebAPIs.add(mainFrameRegistrableDomain).isNewEntry)
>+    RegistrableDomain mainFrameRegistrableDomain { document.topDocument().url() };
>+    if (statistics.topFrameRegistrableDomainsWhichAccessedWebAPIs.add(mainFrameRegistrableDomain.string()).isNewEntry)
>         shouldCallNotificationCallback = true;
>     if (shouldCallNotificationCallback)
>         scheduleNotificationIfNeeded();
>@@ -300,11 +296,11 @@ void ResourceLoadObserver::logCanvasRead(const Document& document)
> #if ENABLE(WEB_API_STATISTICS)
>     if (!shouldLog(document.sessionID().isEphemeral()))
>         return;
>-    auto registrableDomain = primaryDomain(document.url());
>-    auto& statistics = ensureResourceStatisticsForPrimaryDomain(registrableDomain);
>-    auto mainFrameRegistrableDomain = primaryDomain(document.topDocument().url());
>+    RegistrableDomain registrableDomain { document.url() };
>+    auto& statistics = ensureResourceStatisticsForRegistrableDomain(registrableDomain);
>+    RegistrableDomain mainFrameRegistrableDomain { document.topDocument().url() };
>     statistics.canvasActivityRecord.wasDataRead = true;
>-    if (statistics.topFrameRegistrableDomainsWhichAccessedWebAPIs.add(mainFrameRegistrableDomain).isNewEntry)
>+    if (statistics.topFrameRegistrableDomainsWhichAccessedWebAPIs.add(mainFrameRegistrableDomain.string()).isNewEntry)
>         scheduleNotificationIfNeeded();
> #else
>     UNUSED_PARAM(document);
>@@ -316,13 +312,13 @@ void ResourceLoadObserver::logCanvasWriteOrMeasure(const Document& document, con
> #if ENABLE(WEB_API_STATISTICS)
>     if (!shouldLog(document.sessionID().isEphemeral()))
>         return;
>-    auto registrableDomain = primaryDomain(document.url());
>-    auto& statistics = ensureResourceStatisticsForPrimaryDomain(registrableDomain);
>+    RegistrableDomain registrableDomain { document.url() };
>+    auto& statistics = ensureResourceStatisticsForRegistrableDomain(registrableDomain);
>     bool shouldCallNotificationCallback = false;
>-    auto mainFrameRegistrableDomain = primaryDomain(document.topDocument().url());
>+    RegistrableDomain mainFrameRegistrableDomain { document.topDocument().url() };
>     if (statistics.canvasActivityRecord.recordWrittenOrMeasuredText(textWritten))
>         shouldCallNotificationCallback = true;
>-    if (statistics.topFrameRegistrableDomainsWhichAccessedWebAPIs.add(mainFrameRegistrableDomain).isNewEntry)
>+    if (statistics.topFrameRegistrableDomainsWhichAccessedWebAPIs.add(mainFrameRegistrableDomain.string()).isNewEntry)
>         shouldCallNotificationCallback = true;
>     if (shouldCallNotificationCallback)
>         scheduleNotificationIfNeeded();
>@@ -337,15 +333,15 @@ void ResourceLoadObserver::logNavigatorAPIAccessed(const Document& document, con
> #if ENABLE(WEB_API_STATISTICS)
>     if (!shouldLog(document.sessionID().isEphemeral()))
>         return;
>-    auto registrableDomain = primaryDomain(document.url());
>-    auto& statistics = ensureResourceStatisticsForPrimaryDomain(registrableDomain);
>+    RegistrableDomain registrableDomain { document.url() };
>+    auto& statistics = ensureResourceStatisticsForRegistrableDomain(registrableDomain);
>     bool shouldCallNotificationCallback = false;
>     if (!statistics.navigatorFunctionsAccessed.contains(functionName)) {
>         statistics.navigatorFunctionsAccessed.add(functionName);
>         shouldCallNotificationCallback = true;
>     }
>-    auto mainFrameRegistrableDomain = primaryDomain(document.topDocument().url());
>-    if (statistics.topFrameRegistrableDomainsWhichAccessedWebAPIs.add(mainFrameRegistrableDomain).isNewEntry)
>+    RegistrableDomain mainFrameRegistrableDomain { document.topDocument().url() };
>+    if (statistics.topFrameRegistrableDomainsWhichAccessedWebAPIs.add(mainFrameRegistrableDomain.string()).isNewEntry)
>         shouldCallNotificationCallback = true;
>     if (shouldCallNotificationCallback)
>         scheduleNotificationIfNeeded();
>@@ -360,15 +356,15 @@ void ResourceLoadObserver::logScreenAPIAccessed(const Document& document, const
> #if ENABLE(WEB_API_STATISTICS)
>     if (!shouldLog(document.sessionID().isEphemeral()))
>         return;
>-    auto registrableDomain = primaryDomain(document.url());
>-    auto& statistics = ensureResourceStatisticsForPrimaryDomain(registrableDomain);
>+    RegistrableDomain registrableDomain { document.url() };
>+    auto& statistics = ensureResourceStatisticsForRegistrableDomain(registrableDomain);
>     bool shouldCallNotificationCallback = false;
>     if (!statistics.screenFunctionsAccessed.contains(functionName)) {
>         statistics.screenFunctionsAccessed.add(functionName);
>         shouldCallNotificationCallback = true;
>     }
>-    auto mainFrameRegistrableDomain = primaryDomain(document.topDocument().url());
>-    if (statistics.topFrameRegistrableDomainsWhichAccessedWebAPIs.add(mainFrameRegistrableDomain).isNewEntry)
>+    RegistrableDomain mainFrameRegistrableDomain { document.topDocument().url() };
>+    if (statistics.topFrameRegistrableDomainsWhichAccessedWebAPIs.add(mainFrameRegistrableDomain.string()).isNewEntry)
>         shouldCallNotificationCallback = true;
>     if (shouldCallNotificationCallback)
>         scheduleNotificationIfNeeded();
>@@ -378,10 +374,10 @@ void ResourceLoadObserver::logScreenAPIAccessed(const Document& document, const
> #endif
> }
>     
>-ResourceLoadStatistics& ResourceLoadObserver::ensureResourceStatisticsForPrimaryDomain(const String& primaryDomain)
>+ResourceLoadStatistics& ResourceLoadObserver::ensureResourceStatisticsForRegistrableDomain(const RegistrableDomain& domain)
> {
>-    auto addResult = m_resourceStatisticsMap.ensure(primaryDomain, [&primaryDomain] {
>-        return ResourceLoadStatistics(primaryDomain);
>+    auto addResult = m_resourceStatisticsMap.ensure(domain, [&domain] {
>+        return ResourceLoadStatistics(domain);
>     });
>     return addResult.iterator->value;
> }
>@@ -407,7 +403,7 @@ void ResourceLoadObserver::notifyObserver()
> 
> String ResourceLoadObserver::statisticsForOrigin(const String& origin)
> {
>-    auto iter = m_resourceStatisticsMap.find(origin);
>+    auto iter = m_resourceStatisticsMap.find(RegistrableDomain { origin });
>     if (iter == m_resourceStatisticsMap.end())
>         return emptyString();
> 
>diff --git a/Source/WebCore/loader/ResourceLoadObserver.h b/Source/WebCore/loader/ResourceLoadObserver.h
>index 1240782b8aa7e68ce1fc948150ab33ea95764ffd..94ed0db0e8d99c16b4d0b7b1733f7e1b29ee575c 100644
>--- a/Source/WebCore/loader/ResourceLoadObserver.h
>+++ b/Source/WebCore/loader/ResourceLoadObserver.h
>@@ -48,6 +48,7 @@ namespace WebCore {
> class Document;
> class Frame;
> class Page;
>+class RegistrableDomain;
> class ResourceRequest;
> class ResourceResponse;
> class ScriptExecutionContext;
>@@ -72,11 +73,11 @@ public:
>     WEBCORE_EXPORT String statisticsForOrigin(const String&);
> 
>     WEBCORE_EXPORT void setNotificationCallback(WTF::Function<void (Vector<ResourceLoadStatistics>&&)>&&);
>-    WEBCORE_EXPORT void setRequestStorageAccessUnderOpenerCallback(Function<void(const String&, uint64_t, const String&)>&&);
>-    WEBCORE_EXPORT void setLogUserInteractionNotificationCallback(Function<void(PAL::SessionID, const String&)>&&);
>-    WEBCORE_EXPORT void setLogWebSocketLoadingNotificationCallback(Function<void(PAL::SessionID, const String&, const String&, WallTime)>&&);
>-    WEBCORE_EXPORT void setLogSubresourceLoadingNotificationCallback(Function<void(PAL::SessionID, const String&, const String&, WallTime)>&&);
>-    WEBCORE_EXPORT void setLogSubresourceRedirectNotificationCallback(Function<void(PAL::SessionID, const String&, const String&)>&&);
>+    WEBCORE_EXPORT void setRequestStorageAccessUnderOpenerCallback(Function<void(const RegistrableDomain&, uint64_t, const RegistrableDomain&)>&&);
>+    WEBCORE_EXPORT void setLogUserInteractionNotificationCallback(Function<void(PAL::SessionID, const RegistrableDomain&)>&&);
>+    WEBCORE_EXPORT void setLogWebSocketLoadingNotificationCallback(Function<void(PAL::SessionID, const RegistrableDomain&, const RegistrableDomain&, WallTime)>&&);
>+    WEBCORE_EXPORT void setLogSubresourceLoadingNotificationCallback(Function<void(PAL::SessionID, const RegistrableDomain&, const RegistrableDomain&, WallTime)>&&);
>+    WEBCORE_EXPORT void setLogSubresourceRedirectNotificationCallback(Function<void(PAL::SessionID, const RegistrableDomain&, const RegistrableDomain&)>&&);
> 
>     WEBCORE_EXPORT void notifyObserver();
>     WEBCORE_EXPORT void clearState();
>@@ -90,23 +91,23 @@ private:
>     ResourceLoadObserver();
> 
>     bool shouldLog(bool usesEphemeralSession) const;
>-    ResourceLoadStatistics& ensureResourceStatisticsForPrimaryDomain(const String&);
>+    ResourceLoadStatistics& ensureResourceStatisticsForRegistrableDomain(const RegistrableDomain&);
> 
>     void scheduleNotificationIfNeeded();
>     Vector<ResourceLoadStatistics> takeStatistics();
> 
> #if ENABLE(RESOURCE_LOAD_STATISTICS)
>-    void requestStorageAccessUnderOpener(const String& domainInNeedOfStorageAccess, uint64_t openerPageID, Document& openerDocument);
>+    void requestStorageAccessUnderOpener(const RegistrableDomain& domainInNeedOfStorageAccess, uint64_t openerPageID, Document& openerDocument);
> #endif
> 
>-    HashMap<String, ResourceLoadStatistics> m_resourceStatisticsMap;
>-    HashMap<String, WTF::WallTime> m_lastReportedUserInteractionMap;
>+    HashMap<RegistrableDomain, ResourceLoadStatistics> m_resourceStatisticsMap;
>+    HashMap<RegistrableDomain, WTF::WallTime> m_lastReportedUserInteractionMap;
>     Function<void(Vector<ResourceLoadStatistics>&&)> m_notificationCallback;
>-    Function<void(const String&, uint64_t, const String&)> m_requestStorageAccessUnderOpenerCallback;
>-    Function<void(PAL::SessionID, const String&)> m_logUserInteractionNotificationCallback;
>-    Function<void(PAL::SessionID, const String&, const String&, WallTime)> m_logWebSocketLoadingNotificationCallback;
>-    Function<void(PAL::SessionID, const String&, const String&, WallTime)> m_logSubresourceLoadingNotificationCallback;
>-    Function<void(PAL::SessionID, const String&, const String&)> m_logSubresourceRedirectNotificationCallback;
>+    Function<void(const RegistrableDomain&, uint64_t, const RegistrableDomain&)> m_requestStorageAccessUnderOpenerCallback;
>+    Function<void(PAL::SessionID, const RegistrableDomain&)> m_logUserInteractionNotificationCallback;
>+    Function<void(PAL::SessionID, const RegistrableDomain&, const RegistrableDomain&, WallTime)> m_logWebSocketLoadingNotificationCallback;
>+    Function<void(PAL::SessionID, const RegistrableDomain&, const RegistrableDomain&, WallTime)> m_logSubresourceLoadingNotificationCallback;
>+    Function<void(PAL::SessionID, const RegistrableDomain&, const RegistrableDomain&)> m_logSubresourceRedirectNotificationCallback;
> 
>     Timer m_notificationTimer;
> #if ENABLE(RESOURCE_LOAD_STATISTICS) && !RELEASE_LOG_DISABLED
>diff --git a/Source/WebCore/loader/ResourceLoadStatistics.cpp b/Source/WebCore/loader/ResourceLoadStatistics.cpp
>index 7a544e88503b4ff90c5724ecc6c1d2193f2fed94..1abd2a3257c99723997938c87ea5cc5457524d3f 100644
>--- a/Source/WebCore/loader/ResourceLoadStatistics.cpp
>+++ b/Source/WebCore/loader/ResourceLoadStatistics.cpp
>@@ -94,7 +94,7 @@ static void encodeCanvasActivityRecord(KeyedEncoder& encoder, const String& labe
> 
> void ResourceLoadStatistics::encode(KeyedEncoder& encoder) const
> {
>-    encoder.encodeString("PrevalentResourceOrigin", highLevelDomain);
>+    encoder.encodeString("PrevalentResourceOrigin", registrableDomain.string());
>     
>     encoder.encodeDouble("lastSeen", lastSeen.secondsSinceEpoch().value());
>     
>@@ -202,9 +202,11 @@ static void decodeCanvasActivityRecord(KeyedDecoder& decoder, const String& labe
> 
> bool ResourceLoadStatistics::decode(KeyedDecoder& decoder, unsigned modelVersion)
> {
>-    if (!decoder.decodeString("PrevalentResourceOrigin", highLevelDomain))
>+    String registrableDomainAsString;
>+    if (!decoder.decodeString("PrevalentResourceOrigin", registrableDomainAsString))
>         return false;
>-    
>+    registrableDomain = RegistrableDomain(registrableDomainAsString);
>+
>     // User interaction
>     if (!decoder.decodeBool("hadUserInteraction", hadUserInteraction))
>         return false;
>@@ -396,7 +398,7 @@ String ResourceLoadStatistics::toString() const
> {
>     StringBuilder builder;
>     builder.appendLiteral("High level domain: ");
>-    builder.append(highLevelDomain);
>+    builder.append(registrableDomain.string());
>     builder.append('\n');
>     builder.appendLiteral("    lastSeen: ");
>     builder.appendNumber(lastSeen.secondsSinceEpoch().value());
>@@ -466,7 +468,7 @@ static void mergeHashSet(HashSet<T>& to, const HashSet<T>& from)
> 
> void ResourceLoadStatistics::merge(const ResourceLoadStatistics& other)
> {
>-    ASSERT(other.highLevelDomain == highLevelDomain);
>+    ASSERT(other.registrableDomain == registrableDomain);
> 
>     if (lastSeen < other.lastSeen)
>         lastSeen = other.lastSeen;
>@@ -515,27 +517,6 @@ void ResourceLoadStatistics::merge(const ResourceLoadStatistics& other)
> #endif
> }
> 
>-String ResourceLoadStatistics::primaryDomain(const URL& url)
>-{
>-    return primaryDomain(url.host());
>-}
>-
>-String ResourceLoadStatistics::primaryDomain(StringView host)
>-{
>-    if (host.isNull() || host.isEmpty())
>-        return "nullOrigin"_s;
>-
>-    String hostString = host.toString();
>-#if ENABLE(PUBLIC_SUFFIX_LIST)
>-    String primaryDomain = topPrivatelyControlledDomain(hostString);
>-    // We will have an empty string here if there is no TLD. Use the host as a fallback.
>-    if (!primaryDomain.isEmpty())
>-        return primaryDomain;
>-#endif
>-
>-    return hostString;
>-}
>-
> WallTime ResourceLoadStatistics::reduceTimeResolution(WallTime time)
> {
>     return WallTime::fromRawSeconds(std::floor(time.secondsSinceEpoch() / timestampResolution) * timestampResolution.seconds());
>diff --git a/Source/WebCore/loader/ResourceLoadStatistics.h b/Source/WebCore/loader/ResourceLoadStatistics.h
>index c2edf612ced5874cd93761ec623481dbdad7f233..8121fa519fa0eb697425d20ef63780f722af7f4b 100644
>--- a/Source/WebCore/loader/ResourceLoadStatistics.h
>+++ b/Source/WebCore/loader/ResourceLoadStatistics.h
>@@ -26,6 +26,7 @@
> #pragma once
> 
> #include "CanvasActivityRecord.h"
>+#include "RegistrableDomain.h"
> #include <wtf/HashCountedSet.h>
> #include <wtf/HashSet.h>
> #include <wtf/OptionSet.h>
>@@ -40,8 +41,8 @@ class KeyedDecoder;
> class KeyedEncoder;
> 
> struct ResourceLoadStatistics {
>-    explicit ResourceLoadStatistics(const String& primaryDomain)
>-        : highLevelDomain(primaryDomain)
>+    explicit ResourceLoadStatistics(const RegistrableDomain& domain)
>+        : registrableDomain { domain }
>     {
>     }
> 
>@@ -52,9 +53,6 @@ struct ResourceLoadStatistics {
>     ResourceLoadStatistics(ResourceLoadStatistics&&) = default;
>     ResourceLoadStatistics& operator=(ResourceLoadStatistics&&) = default;
> 
>-    WEBCORE_EXPORT static String primaryDomain(const URL&);
>-    WEBCORE_EXPORT static String primaryDomain(StringView host);
>-
>     WEBCORE_EXPORT static WallTime reduceTimeResolution(WallTime);
> 
>     WEBCORE_EXPORT void encode(KeyedEncoder&) const;
>@@ -64,7 +62,7 @@ struct ResourceLoadStatistics {
> 
>     WEBCORE_EXPORT void merge(const ResourceLoadStatistics&);
> 
>-    String highLevelDomain;
>+    RegistrableDomain registrableDomain;
> 
>     WallTime lastSeen;
>     
>diff --git a/Source/WebCore/page/Page.cpp b/Source/WebCore/page/Page.cpp
>index b02688a4a847d56e0074099177b4da503d754288..a347e5379e4b47bb139135533d4dafacfd9daf85 100644
>--- a/Source/WebCore/page/Page.cpp
>+++ b/Source/WebCore/page/Page.cpp
>@@ -89,7 +89,6 @@
> #include "PointerCaptureController.h"
> #include "PointerLockController.h"
> #include "ProgressTracker.h"
>-#include "PublicSuffix.h"
> #include "RenderLayerCompositor.h"
> #include "RenderTheme.h"
> #include "RenderView.h"
>@@ -2369,19 +2368,12 @@ void Page::logNavigation(const Navigation& navigation)
>     diagnosticLoggingClient().logDiagnosticMessage(DiagnosticLoggingKeys::navigationKey(), navigationDescription, ShouldSample::No);
> 
>     if (!navigation.domain.isEmpty())
>-        diagnosticLoggingClient().logDiagnosticMessageWithEnhancedPrivacy(DiagnosticLoggingKeys::domainVisitedKey(), navigation.domain, ShouldSample::Yes);
>+        diagnosticLoggingClient().logDiagnosticMessageWithEnhancedPrivacy(DiagnosticLoggingKeys::domainVisitedKey(), navigation.domain.string(), ShouldSample::Yes);
> }
> 
> void Page::mainFrameLoadStarted(const URL& destinationURL, FrameLoadType type)
> {
>-    String domain;
>-#if ENABLE(PUBLIC_SUFFIX_LIST)
>-    domain = topPrivatelyControlledDomain(destinationURL.host().toString());
>-#else
>-    UNUSED_PARAM(destinationURL);
>-#endif
>-
>-    Navigation navigation = { domain, type };
>+    Navigation navigation = { RegistrableDomain { destinationURL }, type };
> 
>     // To avoid being too verbose, we only log navigations if the page is or becomes visible. This avoids logging non-user observable loads.
>     if (!isVisible()) {
>diff --git a/Source/WebCore/page/Page.h b/Source/WebCore/page/Page.h
>index 9464a8ddaf07a543f0b868ab083649caff7204b7..9a5462d4f18eaaaf6384f2c6d1fc0b01e2c5c4b4 100644
>--- a/Source/WebCore/page/Page.h
>+++ b/Source/WebCore/page/Page.h
>@@ -32,6 +32,7 @@
> #include "Pagination.h"
> #include "RTCController.h"
> #include "Region.h"
>+#include "RegistrableDomain.h"
> #include "ScrollTypes.h"
> #include "Supplementable.h"
> #include "Timer.h"
>@@ -699,7 +700,7 @@ public:
> 
> private:
>     struct Navigation {
>-        String domain;
>+        RegistrableDomain domain;
>         FrameLoadType type;
>     };
>     void logNavigation(const Navigation&);
>diff --git a/Source/WebCore/page/PerformanceMonitor.cpp b/Source/WebCore/page/PerformanceMonitor.cpp
>index 5ec505f71899cbb43518403225d26f126dd5ed03..e645ab9235da4370022e7b830aa08087037c71f4 100644
>--- a/Source/WebCore/page/PerformanceMonitor.cpp
>+++ b/Source/WebCore/page/PerformanceMonitor.cpp
>@@ -35,7 +35,7 @@
> #include "Logging.h"
> #include "Page.h"
> #include "PerformanceLogging.h"
>-#include "PublicSuffix.h"
>+#include "RegistrableDomain.h"
> 
> namespace WebCore {
> 
>@@ -148,16 +148,16 @@ static void reportPageOverPostLoadResourceThreshold(Page& page, ReportingReason
>     if (!document)
>         return;
> 
>-    String domain = topPrivatelyControlledDomain(document->url().host().toString());
>-    if (domain.isEmpty())
>+    RegistrableDomain registrableDomain { document->url() };
>+    if (registrableDomain.isEmpty())
>         return;
> 
>     switch (reason) {
>     case ReportingReason::HighCPUUsage:
>-        page.diagnosticLoggingClient().logDiagnosticMessageWithEnhancedPrivacy(DiagnosticLoggingKeys::domainCausingEnergyDrainKey(), domain, ShouldSample::No);
>+        page.diagnosticLoggingClient().logDiagnosticMessageWithEnhancedPrivacy(DiagnosticLoggingKeys::domainCausingEnergyDrainKey(), registrableDomain.string(), ShouldSample::No);
>         break;
>     case ReportingReason::HighMemoryUsage:
>-        page.diagnosticLoggingClient().logDiagnosticMessageWithEnhancedPrivacy(DiagnosticLoggingKeys::domainCausingJetsamKey(), domain, ShouldSample::No);
>+        page.diagnosticLoggingClient().logDiagnosticMessageWithEnhancedPrivacy(DiagnosticLoggingKeys::domainCausingJetsamKey(), registrableDomain.string(), ShouldSample::No);
>         break;
>     }
> #else
>diff --git a/Source/WebCore/platform/RegistrableDomain.h b/Source/WebCore/platform/RegistrableDomain.h
>new file mode 100644
>index 0000000000000000000000000000000000000000..4a391513392a999d0148d28eca5d86329508e2d4
>--- /dev/null
>+++ b/Source/WebCore/platform/RegistrableDomain.h
>@@ -0,0 +1,124 @@
>+/*
>+ * Copyright (C) 2019 Apple Inc. All rights reserved.
>+ *
>+ * Redistribution and use in source and binary forms, with or without
>+ * modification, are permitted provided that the following conditions
>+ * are met:
>+ * 1. Redistributions of source code must retain the above copyright
>+ *    notice, this list of conditions and the following disclaimer.
>+ * 2. Redistributions in binary form must reproduce the above copyright
>+ *    notice, this list of conditions and the following disclaimer in the
>+ *    documentation and/or other materials provided with the distribution.
>+ *
>+ * THIS SOFTWARE IS PROVIDED BY APPLE INC. AND ITS CONTRIBUTORS ``AS IS''
>+ * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO,
>+ * THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
>+ * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL APPLE INC. OR ITS CONTRIBUTORS
>+ * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
>+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
>+ * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
>+ * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
>+ * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
>+ * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF
>+ * THE POSSIBILITY OF SUCH DAMAGE.
>+ */
>+
>+#pragma once
>+
>+#include "PublicSuffix.h"
>+#include <wtf/HashTraits.h>
>+#include <wtf/URL.h>
>+#include <wtf/text/WTFString.h>
>+
>+namespace WebCore {
>+
>+class RegistrableDomain {
>+    WTF_MAKE_FAST_ALLOCATED;
>+public:
>+    RegistrableDomain() = default;
>+    explicit RegistrableDomain(const URL& url)
>+#if ENABLE(PUBLIC_SUFFIX_LIST)
>+        : m_registrableDomain { topPrivatelyControlledDomain(url.host().toString()) }
>+#else
>+        : m_registrableDomain { url.host().toString() }
>+#endif
>+    {
>+        auto host = url.host();
>+        if (host.isNull() || host.isEmpty())
>+            m_registrableDomain = "nullOrigin"_s;
>+        else if (m_registrableDomain.isEmpty())
>+            m_registrableDomain = host.toString();
>+    }
>+
>+    explicit RegistrableDomain(const String& domain)
>+#if ENABLE(PUBLIC_SUFFIX_LIST)
>+        : m_registrableDomain { topPrivatelyControlledDomain(domain) }
>+#else
>+        : m_registrableDomain { domain }
>+#endif
>+    {
>+        if (m_registrableDomain.isEmpty())
>+            m_registrableDomain = domain;
>+    }
>+
>+    bool isEmpty() const { return m_registrableDomain.isEmpty() || m_registrableDomain == "nullOrigin"_s; }
>+    const String& string() const { return m_registrableDomain; }
>+
>+    bool operator!=(const RegistrableDomain& other) const { return m_registrableDomain != other.m_registrableDomain; }
>+    bool operator==(const RegistrableDomain& other) const { return m_registrableDomain == other.m_registrableDomain; }
>+
>+    bool matches(const URL& url) const
>+    {
>+        auto host = url.host();
>+        if (!host.endsWith(m_registrableDomain))
>+            return false;
>+        if (host.length() == m_registrableDomain.length())
>+            return true;
>+        return host[host.length() - m_registrableDomain.length() - 1] == '.';
>+    }
>+
>+    RegistrableDomain isolatedCopy() const { return RegistrableDomain { m_registrableDomain.isolatedCopy() }; }
>+
>+    RegistrableDomain(WTF::HashTableDeletedValueType)
>+        : m_registrableDomain(WTF::HashTableDeletedValue) { }
>+    bool isHashTableDeletedValue() const { return m_registrableDomain.isHashTableDeletedValue(); }
>+    unsigned hash() const { return m_registrableDomain.hash(); }
>+
>+    struct RegistrableDomainHash {
>+        static unsigned hash(const RegistrableDomain& registrableDomain) { return registrableDomain.m_registrableDomain.hash(); }
>+        static bool equal(const RegistrableDomain& a, const RegistrableDomain& b) { return a == b; }
>+        static const bool safeToCompareToEmptyOrDeleted = false;
>+    };
>+    
>+    template<class Encoder> void encode(Encoder&) const;
>+    template<class Decoder> static Optional<RegistrableDomain> decode(Decoder&);
>+    
>+private:
>+    String m_registrableDomain;
>+};
>+
>+template<class Encoder>
>+void RegistrableDomain::encode(Encoder& encoder) const
>+{
>+    encoder << m_registrableDomain;
>+}
>+
>+template<class Decoder>
>+Optional<RegistrableDomain> RegistrableDomain::decode(Decoder& decoder)
>+{
>+    Optional<String> domain;
>+    decoder >> domain;
>+    if (!domain)
>+        return WTF::nullopt;
>+
>+    return RegistrableDomain { *domain };
>+}
>+
>+} // namespace WebCore
>+
>+namespace WTF {
>+template<> struct DefaultHash<WebCore::RegistrableDomain> {
>+    using Hash = WebCore::RegistrableDomain::RegistrableDomainHash;
>+};
>+template<> struct HashTraits<WebCore::RegistrableDomain> : SimpleClassHashTraits<WebCore::RegistrableDomain> { };
>+}
>diff --git a/Source/WebCore/platform/network/NetworkStorageSession.cpp b/Source/WebCore/platform/network/NetworkStorageSession.cpp
>index 84cc570486c69911bafa6561f388699ee9a91b1d..99060781855a0f12354f7c6a2721f6ce6401eee8 100644
>--- a/Source/WebCore/platform/network/NetworkStorageSession.cpp
>+++ b/Source/WebCore/platform/network/NetworkStorageSession.cpp
>@@ -58,24 +58,12 @@ void NetworkStorageSession::permitProcessToUseCookieAPI(bool value)
> 
> #if ENABLE(RESOURCE_LOAD_STATISTICS)
> 
>-static inline String getPartitioningDomain(const URL& url)
>+bool NetworkStorageSession::shouldBlockThirdPartyCookies(const RegistrableDomain& registrableDomain) const
> {
>-#if ENABLE(PUBLIC_SUFFIX_LIST)
>-    auto domain = topPrivatelyControlledDomain(url.host().toString());
>-    if (domain.isEmpty())
>-        domain = url.host().toString();
>-#else
>-    auto domain = url.host().toString();
>-#endif
>-    return domain;
>-}
>-
>-bool NetworkStorageSession::shouldBlockThirdPartyCookies(const String& topPrivatelyControlledDomain) const
>-{
>-    if (topPrivatelyControlledDomain.isEmpty())
>+    if (registrableDomain.isEmpty())
>         return false;
> 
>-    return m_topPrivatelyControlledDomainsToBlock.contains(topPrivatelyControlledDomain);
>+    return m_registrableDomainsToBlockCookieFor.contains(registrableDomain);
> }
> 
> bool NetworkStorageSession::shouldBlockCookies(const ResourceRequest& request, Optional<uint64_t> frameID, Optional<uint64_t> pageID) const
>@@ -85,11 +73,11 @@ bool NetworkStorageSession::shouldBlockCookies(const ResourceRequest& request, O
>     
> bool NetworkStorageSession::shouldBlockCookies(const URL& firstPartyForCookies, const URL& resource, Optional<uint64_t> frameID, Optional<uint64_t> pageID) const
> {
>-    auto firstPartyDomain = getPartitioningDomain(firstPartyForCookies);
>+    RegistrableDomain firstPartyDomain { firstPartyForCookies };
>     if (firstPartyDomain.isEmpty())
>         return false;
> 
>-    auto resourceDomain = getPartitioningDomain(resource);
>+    RegistrableDomain resourceDomain { resource };
>     if (resourceDomain.isEmpty())
>         return false;
> 
>@@ -114,19 +102,19 @@ void NetworkStorageSession::setAgeCapForClientSideCookies(Optional<Seconds> seco
>     m_ageCapForClientSideCookies = seconds;
> }
> 
>-void NetworkStorageSession::setPrevalentDomainsToBlockCookiesFor(const Vector<String>& domains)
>+void NetworkStorageSession::setPrevalentDomainsToBlockCookiesFor(const Vector<RegistrableDomain>& domains)
> {
>-    m_topPrivatelyControlledDomainsToBlock.clear();
>-    m_topPrivatelyControlledDomainsToBlock.add(domains.begin(), domains.end());
>+    m_registrableDomainsToBlockCookieFor.clear();
>+    m_registrableDomainsToBlockCookieFor.add(domains.begin(), domains.end());
> }
> 
>-void NetworkStorageSession::removePrevalentDomains(const Vector<String>& domains)
>+void NetworkStorageSession::removePrevalentDomains(const Vector<RegistrableDomain>& domains)
> {
>     for (auto& domain : domains)
>-        m_topPrivatelyControlledDomainsToBlock.remove(domain);
>+        m_registrableDomainsToBlockCookieFor.remove(domain);
> }
> 
>-bool NetworkStorageSession::hasStorageAccess(const String& resourceDomain, const String& firstPartyDomain, Optional<uint64_t> frameID, uint64_t pageID) const
>+bool NetworkStorageSession::hasStorageAccess(const RegistrableDomain& resourceDomain, const RegistrableDomain& firstPartyDomain, Optional<uint64_t> frameID, uint64_t pageID) const
> {
>     if (frameID) {
>         auto framesGrantedIterator = m_framesGrantedStorageAccess.find(pageID);
>@@ -154,19 +142,19 @@ Vector<String> NetworkStorageSession::getAllStorageAccessEntries() const
>     Vector<String> entries;
>     for (auto& innerMap : m_framesGrantedStorageAccess.values()) {
>         for (auto& value : innerMap.values())
>-            entries.append(value);
>+            entries.append(value.string());
>     }
>     return entries;
> }
>     
>-void NetworkStorageSession::grantStorageAccess(const String& resourceDomain, const String& firstPartyDomain, Optional<uint64_t> frameID, uint64_t pageID)
>+void NetworkStorageSession::grantStorageAccess(const RegistrableDomain& resourceDomain, const RegistrableDomain& firstPartyDomain, Optional<uint64_t> frameID, uint64_t pageID)
> {
>     if (!frameID) {
>         if (firstPartyDomain.isEmpty())
>             return;
>         auto pagesGrantedIterator = m_pagesGrantedStorageAccess.find(pageID);
>         if (pagesGrantedIterator == m_pagesGrantedStorageAccess.end()) {
>-            HashMap<String, String> entry;
>+            HashMap<RegistrableDomain, RegistrableDomain> entry;
>             entry.add(firstPartyDomain, resourceDomain);
>             m_pagesGrantedStorageAccess.add(pageID, entry);
>         } else {
>@@ -181,7 +169,7 @@ void NetworkStorageSession::grantStorageAccess(const String& resourceDomain, con
> 
>     auto pagesGrantedIterator = m_framesGrantedStorageAccess.find(pageID);
>     if (pagesGrantedIterator == m_framesGrantedStorageAccess.end()) {
>-        HashMap<uint64_t, String, DefaultHash<uint64_t>::Hash, WTF::UnsignedWithZeroKeyHashTraits<uint64_t>> entry;
>+        HashMap<uint64_t, RegistrableDomain, DefaultHash<uint64_t>::Hash, WTF::UnsignedWithZeroKeyHashTraits<uint64_t>> entry;
>         entry.add(frameID.value(), resourceDomain);
>         m_framesGrantedStorageAccess.add(pageID, entry);
>     } else {
>diff --git a/Source/WebCore/platform/network/NetworkStorageSession.h b/Source/WebCore/platform/network/NetworkStorageSession.h
>index 014e1c6d93a4689f6e9fb20b8ae82f957dd29e7c..5897941154041906a50aa5fb965a605e384d1371 100644
>--- a/Source/WebCore/platform/network/NetworkStorageSession.h
>+++ b/Source/WebCore/platform/network/NetworkStorageSession.h
>@@ -26,6 +26,7 @@
> #pragma once
> 
> #include "CredentialStorage.h"
>+#include "RegistrableDomain.h"
> #include <pal/SessionID.h>
> #include <wtf/Function.h>
> #include <wtf/HashMap.h>
>@@ -141,12 +142,12 @@ public:
> #if ENABLE(RESOURCE_LOAD_STATISTICS)
>     WEBCORE_EXPORT bool shouldBlockCookies(const ResourceRequest&, Optional<uint64_t> frameID, Optional<uint64_t> pageID) const;
>     WEBCORE_EXPORT bool shouldBlockCookies(const URL& firstPartyForCookies, const URL& resource, Optional<uint64_t> frameID, Optional<uint64_t> pageID) const;
>-    WEBCORE_EXPORT void setPrevalentDomainsToBlockCookiesFor(const Vector<String>&);
>+    WEBCORE_EXPORT void setPrevalentDomainsToBlockCookiesFor(const Vector<RegistrableDomain>&);
>     WEBCORE_EXPORT void setAgeCapForClientSideCookies(Optional<Seconds>);
>-    WEBCORE_EXPORT void removePrevalentDomains(const Vector<String>& domains);
>-    WEBCORE_EXPORT bool hasStorageAccess(const String& resourceDomain, const String& firstPartyDomain, Optional<uint64_t> frameID, uint64_t pageID) const;
>+    WEBCORE_EXPORT void removePrevalentDomains(const Vector<RegistrableDomain>& domains);
>+    WEBCORE_EXPORT bool hasStorageAccess(const RegistrableDomain& resourceDomain, const RegistrableDomain& firstPartyDomain, Optional<uint64_t> frameID, uint64_t pageID) const;
>     WEBCORE_EXPORT Vector<String> getAllStorageAccessEntries() const;
>-    WEBCORE_EXPORT void grantStorageAccess(const String& resourceDomain, const String& firstPartyDomain, Optional<uint64_t> frameID, uint64_t pageID);
>+    WEBCORE_EXPORT void grantStorageAccess(const RegistrableDomain& resourceDomain, const RegistrableDomain& firstPartyDomain, Optional<uint64_t> frameID, uint64_t pageID);
>     WEBCORE_EXPORT void removeStorageAccessForFrame(uint64_t frameID, uint64_t pageID);
>     WEBCORE_EXPORT void removeStorageAccessForAllFramesOnPage(uint64_t pageID);
>     WEBCORE_EXPORT void removeAllStorageAccess();
>@@ -176,10 +177,10 @@ private:
>     CredentialStorage m_credentialStorage;
> 
> #if ENABLE(RESOURCE_LOAD_STATISTICS)
>-    bool shouldBlockThirdPartyCookies(const String& topPrivatelyControlledDomain) const;
>-    HashSet<String> m_topPrivatelyControlledDomainsToBlock;
>-    HashMap<uint64_t, HashMap<uint64_t, String, DefaultHash<uint64_t>::Hash, WTF::UnsignedWithZeroKeyHashTraits<uint64_t>>, DefaultHash<uint64_t>::Hash, WTF::UnsignedWithZeroKeyHashTraits<uint64_t>> m_framesGrantedStorageAccess;
>-    HashMap<uint64_t, HashMap<String, String>, DefaultHash<uint64_t>::Hash, WTF::UnsignedWithZeroKeyHashTraits<uint64_t>> m_pagesGrantedStorageAccess;
>+    bool shouldBlockThirdPartyCookies(const RegistrableDomain&) const;
>+    HashSet<RegistrableDomain> m_registrableDomainsToBlockCookieFor;
>+    HashMap<uint64_t, HashMap<uint64_t, RegistrableDomain, DefaultHash<uint64_t>::Hash, WTF::UnsignedWithZeroKeyHashTraits<uint64_t>>, DefaultHash<uint64_t>::Hash, WTF::UnsignedWithZeroKeyHashTraits<uint64_t>> m_framesGrantedStorageAccess;
>+    HashMap<uint64_t, HashMap<RegistrableDomain, RegistrableDomain>, DefaultHash<uint64_t>::Hash, WTF::UnsignedWithZeroKeyHashTraits<uint64_t>> m_pagesGrantedStorageAccess;
>     Optional<Seconds> m_cacheMaxAgeCapForPrevalentResources { };
>     Optional<Seconds> m_ageCapForClientSideCookies { };
> #endif
>diff --git a/Source/WebKit/NetworkProcess/Classifier/ResourceLoadStatisticsMemoryStore.cpp b/Source/WebKit/NetworkProcess/Classifier/ResourceLoadStatisticsMemoryStore.cpp
>index 4183c0c6509f5d16460651248027bb776c51df69..300c1519e2f95e1209b703b4b93ba7f14dc4861a 100644
>--- a/Source/WebKit/NetworkProcess/Classifier/ResourceLoadStatisticsMemoryStore.cpp
>+++ b/Source/WebKit/NetworkProcess/Classifier/ResourceLoadStatisticsMemoryStore.cpp
>@@ -53,16 +53,15 @@ constexpr unsigned maxNumberOfRecursiveCallsInRedirectTraceBack { 50 };
> constexpr Seconds minimumStatisticsProcessingInterval { 5_s };
> constexpr unsigned operatingDatesWindow { 30 };
> constexpr unsigned maxImportance { 3 };
>-static const char* debugStaticPrevalentResource { "3rdpartytestwebkit.org" };
> 
> #if !RELEASE_LOG_DISABLED
>-static String domainsToString(const Vector<String>& domains)
>+static String domainsToString(const Vector<RegistrableDomain>& domains)
> {
>     StringBuilder builder;
>     for (auto& domain : domains) {
>         if (!builder.isEmpty())
>             builder.appendLiteral(", ");
>-        builder.append(domain);
>+        builder.append(domain.string());
>     }
>     return builder.toString();
> }
>@@ -140,11 +139,11 @@ static Vector<OperatingDate> mergeOperatingDates(const Vector<OperatingDate>& ex
> }
> 
> struct StatisticsLastSeen {
>-    String topPrivatelyOwnedDomain;
>+    RegistrableDomain domain;
>     WallTime lastSeen;
> };
> 
>-static void pruneResources(HashMap<String, WebCore::ResourceLoadStatistics>& statisticsMap, Vector<StatisticsLastSeen>& statisticsToPrune, size_t& numberOfEntriesToPrune)
>+static void pruneResources(HashMap<RegistrableDomain, ResourceLoadStatistics>& statisticsMap, Vector<StatisticsLastSeen>& statisticsToPrune, size_t& numberOfEntriesToPrune)
> {
>     if (statisticsToPrune.size() > numberOfEntriesToPrune) {
>         std::sort(statisticsToPrune.begin(), statisticsToPrune.end(), [](const StatisticsLastSeen& a, const StatisticsLastSeen& b) {
>@@ -153,7 +152,7 @@ static void pruneResources(HashMap<String, WebCore::ResourceLoadStatistics>& sta
>     }
> 
>     for (size_t i = 0, end = std::min(numberOfEntriesToPrune, statisticsToPrune.size()); i != end; ++i, --numberOfEntriesToPrune)
>-        statisticsMap.remove(statisticsToPrune[i].topPrivatelyOwnedDomain);
>+        statisticsMap.remove(statisticsToPrune[i].domain);
> }
> 
> static unsigned computeImportance(const ResourceLoadStatistics& resourceStatistic)
>@@ -234,7 +233,7 @@ void ResourceLoadStatisticsMemoryStore::removeDataRecords(CompletionHandler<void
>         m_activePluginTokens.add(plugin->pluginProcessToken());
> #endif
> 
>-    auto prevalentResourceDomains = topPrivatelyControlledDomainsToRemoveWebsiteDataFor();
>+    auto prevalentResourceDomains = registrableDomainsToRemoveWebsiteDataFor();
>     if (prevalentResourceDomains.isEmpty()) {
>         callback();
>         return;
>@@ -252,14 +251,14 @@ void ResourceLoadStatisticsMemoryStore::removeDataRecords(CompletionHandler<void
>             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 {
>+        weakThis->m_store.deleteWebsiteDataForRegistrableDomainsInAllPersistentDataStores(WebResourceLoadStatisticsStore::monitoredDataTypes(), WTFMove(prevalentResourceDomains), shouldNotifyPagesWhenDataRecordsWereScanned, [callback = WTFMove(callback), weakThis = WTFMove(weakThis), workQueue = workQueue.copyRef()](const HashSet<String>& domainsWithDeletedWebsiteData) mutable {
>+            workQueue->dispatch([domainsWithDeletedWebsiteData = crossThreadCopy(domainsWithDeletedWebsiteData), callback = WTFMove(callback), weakThis = WTFMove(weakThis)] () mutable {
>                 if (!weakThis) {
>                     callback();
>                     return;
>                 }
>-                for (auto& prevalentResourceDomain : topDomains) {
>-                    auto& statistic = weakThis->ensureResourceStatisticsForPrimaryDomain(prevalentResourceDomain);
>+                for (auto& domain : domainsWithDeletedWebsiteData) {
>+                    auto& statistic = weakThis->ensureResourceStatisticsForRegistrableDomain(RegistrableDomain { domain });
>                     ++statistic.dataRecordsRemoved;
>                 }
>                 weakThis->setDataRecordsBeingRemoved(false);
>@@ -272,7 +271,7 @@ void ResourceLoadStatisticsMemoryStore::removeDataRecords(CompletionHandler<void
>     });
> }
> 
>-unsigned ResourceLoadStatisticsMemoryStore::recursivelyGetAllDomainsThatHaveRedirectedToThisDomain(const WebCore::ResourceLoadStatistics& resourceStatistic, HashSet<String>& domainsThatHaveRedirectedTo, unsigned numberOfRecursiveCalls) const
>+unsigned ResourceLoadStatisticsMemoryStore::recursivelyGetAllDomainsThatHaveRedirectedToThisDomain(const ResourceLoadStatistics& resourceStatistic, HashSet<RegistrableDomain>& domainsThatHaveRedirectedTo, unsigned numberOfRecursiveCalls) const
> {
>     ASSERT(!RunLoop::isMain());
> 
>@@ -287,24 +286,24 @@ unsigned ResourceLoadStatisticsMemoryStore::recursivelyGetAllDomainsThatHaveRedi
>     numberOfRecursiveCalls++;
> 
>     for (auto& subresourceUniqueRedirectFromDomain : resourceStatistic.subresourceUniqueRedirectsFrom.values()) {
>-        auto mapEntry = m_resourceStatisticsMap.find(subresourceUniqueRedirectFromDomain);
>+        auto mapEntry = m_resourceStatisticsMap.find(RegistrableDomain { subresourceUniqueRedirectFromDomain });
>         if (mapEntry == m_resourceStatisticsMap.end() || mapEntry->value.isPrevalentResource)
>             continue;
>-        if (domainsThatHaveRedirectedTo.add(mapEntry->value.highLevelDomain).isNewEntry)
>+        if (domainsThatHaveRedirectedTo.add(mapEntry->value.registrableDomain).isNewEntry)
>             numberOfRecursiveCalls = recursivelyGetAllDomainsThatHaveRedirectedToThisDomain(mapEntry->value, domainsThatHaveRedirectedTo, numberOfRecursiveCalls);
>     }
>     for (auto& topFrameUniqueRedirectFromDomain : resourceStatistic.topFrameUniqueRedirectsFrom.values()) {
>-        auto mapEntry = m_resourceStatisticsMap.find(topFrameUniqueRedirectFromDomain);
>+        auto mapEntry = m_resourceStatisticsMap.find(RegistrableDomain { topFrameUniqueRedirectFromDomain });
>         if (mapEntry == m_resourceStatisticsMap.end() || mapEntry->value.isPrevalentResource)
>             continue;
>-        if (domainsThatHaveRedirectedTo.add(mapEntry->value.highLevelDomain).isNewEntry)
>+        if (domainsThatHaveRedirectedTo.add(mapEntry->value.registrableDomain).isNewEntry)
>             numberOfRecursiveCalls = recursivelyGetAllDomainsThatHaveRedirectedToThisDomain(mapEntry->value, domainsThatHaveRedirectedTo, numberOfRecursiveCalls);
>     }
> 
>     return numberOfRecursiveCalls;
> }
> 
>-void ResourceLoadStatisticsMemoryStore::markAsPrevalentIfHasRedirectedToPrevalent(WebCore::ResourceLoadStatistics& resourceStatistic)
>+void ResourceLoadStatisticsMemoryStore::markAsPrevalentIfHasRedirectedToPrevalent(ResourceLoadStatistics& resourceStatistic)
> {
>     ASSERT(!RunLoop::isMain());
> 
>@@ -312,7 +311,7 @@ void ResourceLoadStatisticsMemoryStore::markAsPrevalentIfHasRedirectedToPrevalen
>         return;
> 
>     for (auto& subresourceDomainRedirectedTo : resourceStatistic.subresourceUniqueRedirectsTo.values()) {
>-        auto mapEntry = m_resourceStatisticsMap.find(subresourceDomainRedirectedTo);
>+        auto mapEntry = m_resourceStatisticsMap.find(RegistrableDomain { subresourceDomainRedirectedTo });
>         if (mapEntry != m_resourceStatisticsMap.end() && mapEntry->value.isPrevalentResource) {
>             setPrevalentResource(resourceStatistic, ResourceLoadPrevalence::High);
>             return;
>@@ -320,7 +319,7 @@ void ResourceLoadStatisticsMemoryStore::markAsPrevalentIfHasRedirectedToPrevalen
>     }
> 
>     for (auto& topFrameDomainRedirectedTo : resourceStatistic.topFrameUniqueRedirectsTo.values()) {
>-        auto mapEntry = m_resourceStatisticsMap.find(topFrameDomainRedirectedTo);
>+        auto mapEntry = m_resourceStatisticsMap.find(RegistrableDomain { topFrameDomainRedirectedTo });
>         if (mapEntry != m_resourceStatisticsMap.end() && mapEntry->value.isPrevalentResource) {
>             setPrevalentResource(resourceStatistic, ResourceLoadPrevalence::High);
>             return;
>@@ -333,7 +332,7 @@ bool ResourceLoadStatisticsMemoryStore::isPrevalentDueToDebugMode(ResourceLoadSt
>     if (!m_debugModeEnabled)
>         return false;
> 
>-    return resourceStatistic.highLevelDomain == debugStaticPrevalentResource || resourceStatistic.highLevelDomain == m_debugManualPrevalentResource;
>+    return resourceStatistic.registrableDomain == m_debugStaticPrevalentResource || resourceStatistic.registrableDomain == m_debugManualPrevalentResource;
> }
> 
> void ResourceLoadStatisticsMemoryStore::processStatisticsAndDataRecords()
>@@ -376,11 +375,11 @@ void ResourceLoadStatisticsMemoryStore::processStatisticsAndDataRecords()
>     });
> }
> 
>-void ResourceLoadStatisticsMemoryStore::hasStorageAccess(const String& subFramePrimaryDomain, const String& topFramePrimaryDomain, Optional<uint64_t> frameID, uint64_t pageID, CompletionHandler<void(bool)>&& completionHandler)
>+void ResourceLoadStatisticsMemoryStore::hasStorageAccess(const RegistrableDomain& subFrameDomain, const RegistrableDomain& topFrameDomain, Optional<uint64_t> frameID, uint64_t pageID, CompletionHandler<void(bool)>&& completionHandler)
> {
>     ASSERT(!RunLoop::isMain());
> 
>-    auto& subFrameStatistic = ensureResourceStatisticsForPrimaryDomain(subFramePrimaryDomain);
>+    auto& subFrameStatistic = ensureResourceStatisticsForRegistrableDomain(subFrameDomain);
>     if (shouldBlockAndPurgeCookies(subFrameStatistic)) {
>         completionHandler(false);
>         return;
>@@ -391,8 +390,8 @@ void ResourceLoadStatisticsMemoryStore::hasStorageAccess(const String& subFrameP
>         return;
>     }
> 
>-    RunLoop::main().dispatch([store = makeRef(m_store), subFramePrimaryDomain = subFramePrimaryDomain.isolatedCopy(), topFramePrimaryDomain = topFramePrimaryDomain.isolatedCopy(), frameID, pageID, completionHandler = WTFMove(completionHandler)]() mutable {
>-        store->callHasStorageAccessForFrameHandler(subFramePrimaryDomain, topFramePrimaryDomain, frameID.value(), pageID, [store = store.copyRef(), completionHandler = WTFMove(completionHandler)](bool result) mutable {
>+    RunLoop::main().dispatch([store = makeRef(m_store), subFrameDomain = subFrameDomain.isolatedCopy(), topFrameDomain = topFrameDomain.isolatedCopy(), frameID, pageID, completionHandler = WTFMove(completionHandler)]() mutable {
>+        store->callHasStorageAccessForFrameHandler(subFrameDomain, topFrameDomain, frameID.value(), pageID, [store = store.copyRef(), completionHandler = WTFMove(completionHandler)](bool result) mutable {
>             store->statisticsQueue().dispatch([completionHandler = WTFMove(completionHandler), result] () mutable {
>                 completionHandler(result);
>             });
>@@ -400,14 +399,14 @@ void ResourceLoadStatisticsMemoryStore::hasStorageAccess(const String& subFrameP
>     });
> }
> 
>-void ResourceLoadStatisticsMemoryStore::requestStorageAccess(String&& subFramePrimaryDomain, String&& topFramePrimaryDomain, uint64_t frameID, uint64_t pageID, bool promptEnabled, CompletionHandler<void(StorageAccessStatus)>&& completionHandler)
>+void ResourceLoadStatisticsMemoryStore::requestStorageAccess(RegistrableDomain&& subFrameDomain, RegistrableDomain&& topFrameDomain, uint64_t frameID, uint64_t pageID, bool promptEnabled, CompletionHandler<void(StorageAccessStatus)>&& completionHandler)
> {
>     ASSERT(!RunLoop::isMain());
> 
>-    auto& subFrameStatistic = ensureResourceStatisticsForPrimaryDomain(subFramePrimaryDomain);
>+    auto& subFrameStatistic = ensureResourceStatisticsForRegistrableDomain(subFrameDomain);
>     if (shouldBlockAndPurgeCookies(subFrameStatistic)) {
> #if !RELEASE_LOG_DISABLED
>-        RELEASE_LOG_INFO_IF(m_debugLoggingEnabled, ResourceLoadStatisticsDebug, "Cannot grant storage access to %{public}s since its cookies are blocked in third-party contexts and it has not received user interaction as first-party.", subFramePrimaryDomain.utf8().data());
>+        RELEASE_LOG_INFO_IF(m_debugLoggingEnabled, ResourceLoadStatisticsDebug, "Cannot grant storage access to %{public}s since its cookies are blocked in third-party contexts and it has not received user interaction as first-party.", subFrameDomain.string().utf8().data());
> #endif
>         completionHandler(StorageAccessStatus::CannotRequestAccess);
>         return;
>@@ -415,41 +414,41 @@ void ResourceLoadStatisticsMemoryStore::requestStorageAccess(String&& subFramePr
> 
>     if (!shouldBlockAndKeepCookies(subFrameStatistic)) {
> #if !RELEASE_LOG_DISABLED
>-        RELEASE_LOG_INFO_IF(m_debugLoggingEnabled, ResourceLoadStatisticsDebug, "No need to grant storage access to %{public}s since its cookies are not blocked in third-party contexts.", subFramePrimaryDomain.utf8().data());
>+        RELEASE_LOG_INFO_IF(m_debugLoggingEnabled, ResourceLoadStatisticsDebug, "No need to grant storage access to %{public}s since its cookies are not blocked in third-party contexts.", subFrameDomain.string().utf8().data());
> #endif
>         completionHandler(StorageAccessStatus::HasAccess);
>         return;
>     }
> 
>-    auto userWasPromptedEarlier = promptEnabled && hasUserGrantedStorageAccessThroughPrompt(subFrameStatistic, topFramePrimaryDomain);
>+    auto userWasPromptedEarlier = promptEnabled && hasUserGrantedStorageAccessThroughPrompt(subFrameStatistic, topFrameDomain);
>     if (promptEnabled && !userWasPromptedEarlier) {
> #if !RELEASE_LOG_DISABLED
>-        RELEASE_LOG_INFO_IF(m_debugLoggingEnabled, ResourceLoadStatisticsDebug, "About to ask the user whether they want to grant storage access to %{public}s under %{public}s or not.", subFramePrimaryDomain.utf8().data(), topFramePrimaryDomain.utf8().data());
>+        RELEASE_LOG_INFO_IF(m_debugLoggingEnabled, ResourceLoadStatisticsDebug, "About to ask the user whether they want to grant storage access to %{public}s under %{public}s or not.", subFrameDomain.string().utf8().data(), topFrameDomain.string().utf8().data());
> #endif
>         completionHandler(StorageAccessStatus::RequiresUserPrompt);
>         return;
>     } else if (userWasPromptedEarlier) {
> #if !RELEASE_LOG_DISABLED
>-        RELEASE_LOG_INFO_IF(m_debugLoggingEnabled, ResourceLoadStatisticsDebug, "Storage access was granted to %{public}s under %{public}s.", subFramePrimaryDomain.utf8().data(), topFramePrimaryDomain.utf8().data());
>+        RELEASE_LOG_INFO_IF(m_debugLoggingEnabled, ResourceLoadStatisticsDebug, "Storage access was granted to %{public}s under %{public}s.", subFrameDomain.string().utf8().data(), topFrameDomain.string().utf8().data());
> #endif
>     }
> 
>     subFrameStatistic.timesAccessedAsFirstPartyDueToStorageAccessAPI++;
> 
>-    grantStorageAccessInternal(WTFMove(subFramePrimaryDomain), WTFMove(topFramePrimaryDomain), frameID, pageID, userWasPromptedEarlier, [completionHandler = WTFMove(completionHandler)] (bool wasGrantedAccess) mutable {
>+    grantStorageAccessInternal(WTFMove(subFrameDomain), WTFMove(topFrameDomain), frameID, pageID, userWasPromptedEarlier, [completionHandler = WTFMove(completionHandler)] (bool wasGrantedAccess) mutable {
>         completionHandler(wasGrantedAccess ? StorageAccessStatus::HasAccess : StorageAccessStatus::CannotRequestAccess);
>     });
> }
> 
>-void ResourceLoadStatisticsMemoryStore::requestStorageAccessUnderOpener(String&& primaryDomainInNeedOfStorageAccess, uint64_t openerPageID, String&& openerPrimaryDomain)
>+void ResourceLoadStatisticsMemoryStore::requestStorageAccessUnderOpener(RegistrableDomain&& domainInNeedOfStorageAccess, uint64_t openerPageID, RegistrableDomain&& openerDomain)
> {
>-    ASSERT(primaryDomainInNeedOfStorageAccess != openerPrimaryDomain);
>+    ASSERT(domainInNeedOfStorageAccess != openerDomain);
>     ASSERT(!RunLoop::isMain());
> 
>-    if (primaryDomainInNeedOfStorageAccess == openerPrimaryDomain)
>+    if (domainInNeedOfStorageAccess == openerDomain)
>         return;
> 
>-    auto& domainInNeedOfStorageAccessStatistic = ensureResourceStatisticsForPrimaryDomain(primaryDomainInNeedOfStorageAccess);
>+    auto& domainInNeedOfStorageAccessStatistic = ensureResourceStatisticsForRegistrableDomain(domainInNeedOfStorageAccess);
>     auto cookiesBlockedAndPurged = shouldBlockAndPurgeCookies(domainInNeedOfStorageAccessStatistic);
> 
>     // The domain already has access if its cookies are not blocked.
>@@ -457,44 +456,42 @@ void ResourceLoadStatisticsMemoryStore::requestStorageAccessUnderOpener(String&&
>         return;
> 
> #if !RELEASE_LOG_DISABLED
>-    RELEASE_LOG_INFO_IF(m_debugLoggingEnabled, ResourceLoadStatisticsDebug, "[Temporary combatibility fix] Storage access was granted for %{public}s under opener page from %{public}s, with user interaction in the opened window.", primaryDomainInNeedOfStorageAccess.utf8().data(), openerPrimaryDomain.utf8().data());
>+    RELEASE_LOG_INFO_IF(m_debugLoggingEnabled, ResourceLoadStatisticsDebug, "[Temporary combatibility fix] Storage access was granted for %{public}s under opener page from %{public}s, with user interaction in the opened window.", domainInNeedOfStorageAccess.string().utf8().data(), openerDomain.string().utf8().data());
> #endif
>-    grantStorageAccessInternal(WTFMove(primaryDomainInNeedOfStorageAccess), WTFMove(openerPrimaryDomain), WTF::nullopt, openerPageID, false, [](bool) { });
>+    grantStorageAccessInternal(WTFMove(domainInNeedOfStorageAccess), WTFMove(openerDomain), WTF::nullopt, openerPageID, false, [](bool) { });
> }
> 
>-void ResourceLoadStatisticsMemoryStore::grantStorageAccess(String&& subFrameHost, String&& topFrameHost, uint64_t frameID, uint64_t pageID, bool userWasPromptedNow, CompletionHandler<void(bool)>&& completionHandler)
>+void ResourceLoadStatisticsMemoryStore::grantStorageAccess(RegistrableDomain&& subFrameDomain, RegistrableDomain&& topFrameDomain, uint64_t frameID, uint64_t pageID, bool userWasPromptedNow, CompletionHandler<void(bool)>&& completionHandler)
> {
>     ASSERT(!RunLoop::isMain());
> 
>-    auto subFramePrimaryDomain = ResourceLoadStatistics::primaryDomain(subFrameHost);
>-    auto topFramePrimaryDomain = ResourceLoadStatistics::primaryDomain(topFrameHost);
>     if (userWasPromptedNow) {
>-        auto& subFrameStatistic = ensureResourceStatisticsForPrimaryDomain(subFramePrimaryDomain);
>+        auto& subFrameStatistic = ensureResourceStatisticsForRegistrableDomain(subFrameDomain);
>         ASSERT(subFrameStatistic.hadUserInteraction);
>-        subFrameStatistic.storageAccessUnderTopFrameOrigins.add(topFramePrimaryDomain);
>+        subFrameStatistic.storageAccessUnderTopFrameOrigins.add(topFrameDomain.string());
>     }
>-    grantStorageAccessInternal(WTFMove(subFramePrimaryDomain), WTFMove(topFramePrimaryDomain), frameID, pageID, userWasPromptedNow, WTFMove(completionHandler));
>+    grantStorageAccessInternal(WTFMove(subFrameDomain), WTFMove(topFrameDomain), frameID, pageID, userWasPromptedNow, WTFMove(completionHandler));
> }
> 
>-void ResourceLoadStatisticsMemoryStore::grantStorageAccessInternal(String&& subFramePrimaryDomain, String&& topFramePrimaryDomain, Optional<uint64_t> frameID, uint64_t pageID, bool userWasPromptedNowOrEarlier, CompletionHandler<void(bool)>&& callback)
>+void ResourceLoadStatisticsMemoryStore::grantStorageAccessInternal(RegistrableDomain&& subFrameDomain, RegistrableDomain&& topFrameDomain, Optional<uint64_t> frameID, uint64_t pageID, bool userWasPromptedNowOrEarlier, CompletionHandler<void(bool)>&& callback)
> {
>     ASSERT(!RunLoop::isMain());
> 
>-    if (subFramePrimaryDomain == topFramePrimaryDomain) {
>+    if (subFrameDomain == topFrameDomain) {
>         callback(true);
>         return;
>     }
> 
>     // FIXME: Remove m_storageAccessPromptsEnabled check if prompting is no longer experimental.
>     if (userWasPromptedNowOrEarlier && m_storageAccessPromptsEnabled) {
>-        auto& subFrameStatistic = ensureResourceStatisticsForPrimaryDomain(subFramePrimaryDomain);
>+        auto& subFrameStatistic = ensureResourceStatisticsForRegistrableDomain(subFrameDomain);
>         ASSERT(subFrameStatistic.hadUserInteraction);
>-        ASSERT(subFrameStatistic.storageAccessUnderTopFrameOrigins.contains(topFramePrimaryDomain));
>+        ASSERT(subFrameStatistic.storageAccessUnderTopFrameOrigins.contains(topFrameDomain.string()));
>         subFrameStatistic.mostRecentUserInteractionTime = WallTime::now();
>     }
> 
>-    RunLoop::main().dispatch([subFramePrimaryDomain = subFramePrimaryDomain.isolatedCopy(), topFramePrimaryDomain = topFramePrimaryDomain.isolatedCopy(), frameID, pageID, store = makeRef(m_store), callback = WTFMove(callback)]() mutable {
>-        store->callGrantStorageAccessHandler(subFramePrimaryDomain, topFramePrimaryDomain, frameID, pageID, [callback = WTFMove(callback), store = store.copyRef()](bool value) mutable {
>+    RunLoop::main().dispatch([subFrameDomain = subFrameDomain.isolatedCopy(), topFrameDomain = topFrameDomain.isolatedCopy(), frameID, pageID, store = makeRef(m_store), callback = WTFMove(callback)]() mutable {
>+        store->callGrantStorageAccessHandler(subFrameDomain, topFrameDomain, frameID, pageID, [callback = WTFMove(callback), store = store.copyRef()](bool value) mutable {
>             store->statisticsQueue().dispatch([callback = WTFMove(callback), value] () mutable {
>                 callback(value);
>             });
>@@ -507,15 +504,15 @@ void ResourceLoadStatisticsMemoryStore::grandfatherExistingWebsiteData(Completio
>     ASSERT(!RunLoop::isMain());
> 
>     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 {
>+        store->registrableDomainsWithWebsiteData(WebResourceLoadStatisticsStore::monitoredDataTypes(), shouldNotifyPagesWhenDataRecordsWereScanned, [weakThis = WTFMove(weakThis), callback = WTFMove(callback), workQueue = workQueue.copyRef()] (HashSet<RegistrableDomain>&& domainsWithWebsiteData) mutable {
>+            workQueue->dispatch([weakThis = WTFMove(weakThis), domainsWithWebsiteData = crossThreadCopy(domainsWithWebsiteData), callback = WTFMove(callback)] () mutable {
>                 if (!weakThis) {
>                     callback();
>                     return;
>                 }
> 
>-                for (auto& topPrivatelyControlledDomain : topDomains) {
>-                    auto& statistic = weakThis->ensureResourceStatisticsForPrimaryDomain(topPrivatelyControlledDomain);
>+                for (auto& domain : domainsWithWebsiteData) {
>+                    auto& statistic = weakThis->ensureResourceStatisticsForRegistrableDomain(domain);
>                     statistic.grandfathered = true;
>                 }
>                 weakThis->m_endOfGrandfatheringTimestamp = WallTime::now() + weakThis->m_parameters.grandfatheringTime;
>@@ -528,28 +525,28 @@ void ResourceLoadStatisticsMemoryStore::grandfatherExistingWebsiteData(Completio
>     });
> }
> 
>-Vector<String> ResourceLoadStatisticsMemoryStore::ensurePrevalentResourcesForDebugMode()
>+Vector<RegistrableDomain> ResourceLoadStatisticsMemoryStore::ensurePrevalentResourcesForDebugMode()
> {
>     if (!m_debugModeEnabled)
>         return { };
> 
>-    Vector<String> primaryDomainsToBlock;
>-    primaryDomainsToBlock.reserveInitialCapacity(2);
>+    Vector<RegistrableDomain> domainsToBlock;
>+    domainsToBlock.reserveInitialCapacity(2);
> 
>-    auto& staticSesourceStatistic = ensureResourceStatisticsForPrimaryDomain(debugStaticPrevalentResource);
>+    auto& staticSesourceStatistic = ensureResourceStatisticsForRegistrableDomain(m_debugStaticPrevalentResource);
>     setPrevalentResource(staticSesourceStatistic, ResourceLoadPrevalence::High);
>-    primaryDomainsToBlock.uncheckedAppend(debugStaticPrevalentResource);
>+    domainsToBlock.uncheckedAppend(m_debugStaticPrevalentResource);
> 
>     if (!m_debugManualPrevalentResource.isEmpty()) {
>-        auto& manualResourceStatistic = ensureResourceStatisticsForPrimaryDomain(m_debugManualPrevalentResource);
>+        auto& manualResourceStatistic = ensureResourceStatisticsForRegistrableDomain(m_debugManualPrevalentResource);
>         setPrevalentResource(manualResourceStatistic, ResourceLoadPrevalence::High);
>-        primaryDomainsToBlock.uncheckedAppend(m_debugManualPrevalentResource);
>+        domainsToBlock.uncheckedAppend(m_debugManualPrevalentResource);
> #if !RELEASE_LOG_DISABLED
>-        RELEASE_LOG_INFO(ResourceLoadStatisticsDebug, "Did set %{public}s as prevalent resource for the purposes of ITP Debug Mode.", m_debugManualPrevalentResource.utf8().data());
>+        RELEASE_LOG_INFO(ResourceLoadStatisticsDebug, "Did set %{public}s as prevalent resource for the purposes of ITP Debug Mode.", m_debugManualPrevalentResource.string().utf8().data());
> #endif
>     }
>     
>-    return primaryDomainsToBlock;
>+    return domainsToBlock;
> }
> 
> void ResourceLoadStatisticsMemoryStore::setResourceLoadStatisticsDebugMode(bool enable)
>@@ -570,7 +567,7 @@ void ResourceLoadStatisticsMemoryStore::setResourceLoadStatisticsDebugMode(bool
>         updateCookieBlocking([]() { });
> }
> 
>-void ResourceLoadStatisticsMemoryStore::setPrevalentResourceForDebugMode(const String& domain)
>+void ResourceLoadStatisticsMemoryStore::setPrevalentResourceForDebugMode(const RegistrableDomain& domain)
> {
>     m_debugManualPrevalentResource = domain;
> }
>@@ -601,35 +598,35 @@ void ResourceLoadStatisticsMemoryStore::cancelPendingStatisticsProcessingRequest
>     m_pendingStatisticsProcessingRequestIdentifier = WTF::nullopt;
> }
> 
>-void ResourceLoadStatisticsMemoryStore::logFrameNavigation(const String& targetPrimaryDomain, const String& mainFramePrimaryDomain, const String& sourcePrimaryDomain, const String& targetHost, const String& mainFrameHost, bool isRedirect, bool isMainFrame)
>+void ResourceLoadStatisticsMemoryStore::logFrameNavigation(const RegistrableDomain& targetDomain, const RegistrableDomain& topFrameDomain, const RegistrableDomain& sourceDomain, bool isRedirect, bool isMainFrame)
> {
>     ASSERT(!RunLoop::isMain());
> 
>-    bool areTargetAndMainFrameDomainsAssociated = targetPrimaryDomain == mainFramePrimaryDomain;
>-    bool areTargetAndSourceDomainsAssociated = targetPrimaryDomain == sourcePrimaryDomain;
>+    bool areTargetAndTopFrameDomainsSameSite = targetDomain == topFrameDomain;
>+    bool areTargetAndSourceDomainsSameSite = targetDomain == sourceDomain;
> 
>     bool statisticsWereUpdated = false;
>-    if (!isMainFrame && targetHost != mainFrameHost && !(areTargetAndMainFrameDomainsAssociated || areTargetAndSourceDomainsAssociated)) {
>-        auto& targetStatistics = ensureResourceStatisticsForPrimaryDomain(targetPrimaryDomain);
>+    if (!isMainFrame && !(areTargetAndTopFrameDomainsSameSite || areTargetAndSourceDomainsSameSite)) {
>+        auto& targetStatistics = ensureResourceStatisticsForRegistrableDomain(targetDomain);
>         targetStatistics.lastSeen = ResourceLoadStatistics::reduceTimeResolution(WallTime::now());
>-        if (targetStatistics.subframeUnderTopFrameOrigins.add(mainFramePrimaryDomain).isNewEntry)
>+        if (targetStatistics.subframeUnderTopFrameOrigins.add(topFrameDomain.string()).isNewEntry)
>             statisticsWereUpdated = true;
>     }
> 
>-    if (isRedirect && !areTargetAndSourceDomainsAssociated) {
>+    if (isRedirect && !areTargetAndSourceDomainsSameSite) {
>         if (isMainFrame) {
>-            auto& redirectingOriginStatistics = ensureResourceStatisticsForPrimaryDomain(sourcePrimaryDomain);
>-            if (redirectingOriginStatistics.topFrameUniqueRedirectsTo.add(targetPrimaryDomain).isNewEntry)
>+            auto& redirectingOriginStatistics = ensureResourceStatisticsForRegistrableDomain(sourceDomain);
>+            if (redirectingOriginStatistics.topFrameUniqueRedirectsTo.add(targetDomain.string()).isNewEntry)
>                 statisticsWereUpdated = true;
>-            auto& targetStatistics = ensureResourceStatisticsForPrimaryDomain(targetPrimaryDomain);
>-            if (targetStatistics.topFrameUniqueRedirectsFrom.add(sourcePrimaryDomain).isNewEntry)
>+            auto& targetStatistics = ensureResourceStatisticsForRegistrableDomain(targetDomain);
>+            if (targetStatistics.topFrameUniqueRedirectsFrom.add(sourceDomain.string()).isNewEntry)
>                 statisticsWereUpdated = true;
>         } else {
>-            auto& redirectingOriginStatistics = ensureResourceStatisticsForPrimaryDomain(sourcePrimaryDomain);
>-            if (redirectingOriginStatistics.subresourceUniqueRedirectsTo.add(targetPrimaryDomain).isNewEntry)
>+            auto& redirectingOriginStatistics = ensureResourceStatisticsForRegistrableDomain(sourceDomain);
>+            if (redirectingOriginStatistics.subresourceUniqueRedirectsTo.add(targetDomain.string()).isNewEntry)
>                 statisticsWereUpdated = true;
>-            auto& targetStatistics = ensureResourceStatisticsForPrimaryDomain(targetPrimaryDomain);
>-            if (targetStatistics.subresourceUniqueRedirectsFrom.add(sourcePrimaryDomain).isNewEntry)
>+            auto& targetStatistics = ensureResourceStatisticsForRegistrableDomain(targetDomain);
>+            if (targetStatistics.subresourceUniqueRedirectsFrom.add(sourceDomain.string()).isNewEntry)
>                 statisticsWereUpdated = true;
>         }
>     }
>@@ -638,62 +635,62 @@ void ResourceLoadStatisticsMemoryStore::logFrameNavigation(const String& targetP
>         scheduleStatisticsProcessingRequestIfNecessary();
> }
> 
>-void ResourceLoadStatisticsMemoryStore::logSubresourceLoading(const String& targetPrimaryDomain, const String& mainFramePrimaryDomain, WallTime lastSeen)
>+void ResourceLoadStatisticsMemoryStore::logSubresourceLoading(const RegistrableDomain& targetDomain, const RegistrableDomain& topFrameDomain, WallTime lastSeen)
> {
>     ASSERT(!RunLoop::isMain());
> 
>-    auto& targetStatistics = ensureResourceStatisticsForPrimaryDomain(targetPrimaryDomain);
>+    auto& targetStatistics = ensureResourceStatisticsForRegistrableDomain(targetDomain);
>     targetStatistics.lastSeen = lastSeen;
>-    if (targetStatistics.subresourceUnderTopFrameOrigins.add(mainFramePrimaryDomain).isNewEntry)
>+    if (targetStatistics.subresourceUnderTopFrameOrigins.add(topFrameDomain.string()).isNewEntry)
>         scheduleStatisticsProcessingRequestIfNecessary();
> }
> 
>-void ResourceLoadStatisticsMemoryStore::logSubresourceRedirect(const String& sourcePrimaryDomain, const String& targetPrimaryDomain)
>+void ResourceLoadStatisticsMemoryStore::logSubresourceRedirect(const RegistrableDomain& sourceDomain, const RegistrableDomain& targetDomain)
> {
>     ASSERT(!RunLoop::isMain());
> 
>-    auto& redirectingOriginStatistics = ensureResourceStatisticsForPrimaryDomain(sourcePrimaryDomain);
>-    bool isNewRedirectToEntry = redirectingOriginStatistics.subresourceUniqueRedirectsTo.add(targetPrimaryDomain).isNewEntry;
>-    auto& targetStatistics = ensureResourceStatisticsForPrimaryDomain(targetPrimaryDomain);
>-    bool isNewRedirectFromEntry = targetStatistics.subresourceUniqueRedirectsFrom.add(sourcePrimaryDomain).isNewEntry;
>-    
>+    auto& redirectingOriginStatistics = ensureResourceStatisticsForRegistrableDomain(sourceDomain);
>+    bool isNewRedirectToEntry = redirectingOriginStatistics.subresourceUniqueRedirectsTo.add(targetDomain.string()).isNewEntry;
>+    auto& targetStatistics = ensureResourceStatisticsForRegistrableDomain(targetDomain);
>+    bool isNewRedirectFromEntry = targetStatistics.subresourceUniqueRedirectsFrom.add(sourceDomain.string()).isNewEntry;
>+
>     if (isNewRedirectToEntry || isNewRedirectFromEntry)
>         scheduleStatisticsProcessingRequestIfNecessary();
> }
> 
>-void ResourceLoadStatisticsMemoryStore::logUserInteraction(const String& primaryDomain)
>+void ResourceLoadStatisticsMemoryStore::logUserInteraction(const RegistrableDomain& domain)
> {
>     ASSERT(!RunLoop::isMain());
> 
>-    auto& statistics = ensureResourceStatisticsForPrimaryDomain(primaryDomain);
>+    auto& statistics = ensureResourceStatisticsForRegistrableDomain(domain);
>     statistics.hadUserInteraction = true;
>     statistics.mostRecentUserInteractionTime = WallTime::now();
> }
> 
>-void ResourceLoadStatisticsMemoryStore::clearUserInteraction(const String& primaryDomain)
>+void ResourceLoadStatisticsMemoryStore::clearUserInteraction(const RegistrableDomain& domain)
> {
>     ASSERT(!RunLoop::isMain());
> 
>-    auto& statistics = ensureResourceStatisticsForPrimaryDomain(primaryDomain);
>+    auto& statistics = ensureResourceStatisticsForRegistrableDomain(domain);
>     statistics.hadUserInteraction = false;
>     statistics.mostRecentUserInteractionTime = { };
> }
> 
>-bool ResourceLoadStatisticsMemoryStore::hasHadUserInteraction(const String& primaryDomain)
>+bool ResourceLoadStatisticsMemoryStore::hasHadUserInteraction(const RegistrableDomain& domain)
> {
>     ASSERT(!RunLoop::isMain());
> 
>-    auto mapEntry = m_resourceStatisticsMap.find(primaryDomain);
>+    auto mapEntry = m_resourceStatisticsMap.find(domain);
>     return mapEntry == m_resourceStatisticsMap.end() ? false: hasHadUnexpiredRecentUserInteraction(mapEntry->value);
> }
> 
>-void ResourceLoadStatisticsMemoryStore::setPrevalentResource(WebCore::ResourceLoadStatistics& resourceStatistic, ResourceLoadPrevalence newPrevalence)
>+void ResourceLoadStatisticsMemoryStore::setPrevalentResource(ResourceLoadStatistics& resourceStatistic, ResourceLoadPrevalence newPrevalence)
> {
>     ASSERT(!RunLoop::isMain());
> 
>     resourceStatistic.isPrevalentResource = true;
>     resourceStatistic.isVeryPrevalentResource = newPrevalence == ResourceLoadPrevalence::VeryHigh;
>-    HashSet<String> domainsThatHaveRedirectedTo;
>+    HashSet<RegistrableDomain> domainsThatHaveRedirectedTo;
>     recursivelyGetAllDomainsThatHaveRedirectedToThisDomain(resourceStatistic, domainsThatHaveRedirectedTo, 0);
>     for (auto& domain : domainsThatHaveRedirectedTo) {
>         auto mapEntry = m_resourceStatisticsMap.find(domain);
>@@ -715,129 +712,129 @@ String ResourceLoadStatisticsMemoryStore::dumpResourceLoadStatistics() const
>     return result.toString();
> }
> 
>-bool ResourceLoadStatisticsMemoryStore::isPrevalentResource(const String& primaryDomain) const
>+bool ResourceLoadStatisticsMemoryStore::isPrevalentResource(const RegistrableDomain& domain) const
> {
>     ASSERT(!RunLoop::isMain());
> 
>-    auto mapEntry = m_resourceStatisticsMap.find(primaryDomain);
>+    auto mapEntry = m_resourceStatisticsMap.find(domain);
>     return mapEntry == m_resourceStatisticsMap.end() ? false : mapEntry->value.isPrevalentResource;
> }
> 
>-bool ResourceLoadStatisticsMemoryStore::isVeryPrevalentResource(const String& primaryDomain) const
>+bool ResourceLoadStatisticsMemoryStore::isVeryPrevalentResource(const RegistrableDomain& domain) const
> {
>     ASSERT(!RunLoop::isMain());
> 
>-    auto mapEntry = m_resourceStatisticsMap.find(primaryDomain);
>+    auto mapEntry = m_resourceStatisticsMap.find(domain);
>     return mapEntry == m_resourceStatisticsMap.end() ? false : mapEntry->value.isPrevalentResource && mapEntry->value.isVeryPrevalentResource;
> }
> 
>-bool ResourceLoadStatisticsMemoryStore::isRegisteredAsSubresourceUnder(const String& subresourcePrimaryDomain, const String& topFramePrimaryDomain) const
>+bool ResourceLoadStatisticsMemoryStore::isRegisteredAsSubresourceUnder(const RegistrableDomain& subresourceDomain, const RegistrableDomain& topFrameDomain) const
> {
>     ASSERT(!RunLoop::isMain());
> 
>-    auto mapEntry = m_resourceStatisticsMap.find(subresourcePrimaryDomain);
>-    return mapEntry == m_resourceStatisticsMap.end() ? false : mapEntry->value.subresourceUnderTopFrameOrigins.contains(topFramePrimaryDomain);
>+    auto mapEntry = m_resourceStatisticsMap.find(subresourceDomain);
>+    return mapEntry == m_resourceStatisticsMap.end() ? false : mapEntry->value.subresourceUnderTopFrameOrigins.contains(topFrameDomain.string());
> }
> 
>-bool ResourceLoadStatisticsMemoryStore::isRegisteredAsSubFrameUnder(const String& subFramePrimaryDomain, const String& topFramePrimaryDomain) const
>+bool ResourceLoadStatisticsMemoryStore::isRegisteredAsSubFrameUnder(const RegistrableDomain& subFrameDomain, const RegistrableDomain& topFrameDomain) const
> {
>     ASSERT(!RunLoop::isMain());
> 
>-    auto mapEntry = m_resourceStatisticsMap.find(subFramePrimaryDomain);
>-    return mapEntry == m_resourceStatisticsMap.end() ? false : mapEntry->value.subframeUnderTopFrameOrigins.contains(topFramePrimaryDomain);
>+    auto mapEntry = m_resourceStatisticsMap.find(subFrameDomain);
>+    return mapEntry == m_resourceStatisticsMap.end() ? false : mapEntry->value.subframeUnderTopFrameOrigins.contains(topFrameDomain.string());
> }
> 
>-bool ResourceLoadStatisticsMemoryStore::isRegisteredAsRedirectingTo(const String& hostRedirectedFromPrimaryDomain, const String& hostRedirectedToPrimaryDomain) const
>+bool ResourceLoadStatisticsMemoryStore::isRegisteredAsRedirectingTo(const RegistrableDomain& redirectedFromDomain, const RegistrableDomain& redirectedToDomain) const
> {
>     ASSERT(!RunLoop::isMain());
> 
>-    auto mapEntry = m_resourceStatisticsMap.find(hostRedirectedFromPrimaryDomain);
>-    return mapEntry == m_resourceStatisticsMap.end() ? false : mapEntry->value.subresourceUniqueRedirectsTo.contains(hostRedirectedToPrimaryDomain);
>+    auto mapEntry = m_resourceStatisticsMap.find(redirectedFromDomain);
>+    return mapEntry == m_resourceStatisticsMap.end() ? false : mapEntry->value.subresourceUniqueRedirectsTo.contains(redirectedToDomain.string());
> }
> 
>-void ResourceLoadStatisticsMemoryStore::clearPrevalentResource(const String& primaryDomain)
>+void ResourceLoadStatisticsMemoryStore::clearPrevalentResource(const RegistrableDomain& domain)
> {
>     ASSERT(!RunLoop::isMain());
> 
>-    auto& statistics = ensureResourceStatisticsForPrimaryDomain(primaryDomain);
>+    auto& statistics = ensureResourceStatisticsForRegistrableDomain(domain);
>     statistics.isPrevalentResource = false;
>     statistics.isVeryPrevalentResource = false;
> }
> 
>-void ResourceLoadStatisticsMemoryStore::setGrandfathered(const String& primaryDomain, bool value)
>+void ResourceLoadStatisticsMemoryStore::setGrandfathered(const RegistrableDomain& domain, bool value)
> {
>     ASSERT(!RunLoop::isMain());
> 
>-    auto& statistics = ensureResourceStatisticsForPrimaryDomain(primaryDomain);
>+    auto& statistics = ensureResourceStatisticsForRegistrableDomain(domain);
>     statistics.grandfathered = value;
> }
> 
>-bool ResourceLoadStatisticsMemoryStore::isGrandfathered(const String& primaryDomain) const
>+bool ResourceLoadStatisticsMemoryStore::isGrandfathered(const RegistrableDomain& domain) const
> {
>     ASSERT(!RunLoop::isMain());
> 
>-    auto mapEntry = m_resourceStatisticsMap.find(primaryDomain);
>+    auto mapEntry = m_resourceStatisticsMap.find(domain);
>     return mapEntry == m_resourceStatisticsMap.end() ? false : mapEntry->value.grandfathered;
> }
> 
>-void ResourceLoadStatisticsMemoryStore::setSubframeUnderTopFrameOrigin(const String& primarySubFrameDomain, const String& primaryTopFrameDomain)
>+void ResourceLoadStatisticsMemoryStore::setSubframeUnderTopFrameOrigin(const RegistrableDomain& subFrameDomain, const RegistrableDomain& topFrameDomain)
> {
>     ASSERT(!RunLoop::isMain());
> 
>-    auto& statistics = ensureResourceStatisticsForPrimaryDomain(primarySubFrameDomain);
>-    statistics.subframeUnderTopFrameOrigins.add(primaryTopFrameDomain);
>+    auto& statistics = ensureResourceStatisticsForRegistrableDomain(subFrameDomain);
>+    statistics.subframeUnderTopFrameOrigins.add(topFrameDomain.string());
>     // For consistency, make sure we also have a statistics entry for the top frame domain.
>-    ensureResourceStatisticsForPrimaryDomain(primaryTopFrameDomain);
>+    ensureResourceStatisticsForRegistrableDomain(topFrameDomain);
> }
> 
>-void ResourceLoadStatisticsMemoryStore::setSubresourceUnderTopFrameOrigin(const String& primarySubresourceDomain, const String& primaryTopFrameDomain)
>+void ResourceLoadStatisticsMemoryStore::setSubresourceUnderTopFrameOrigin(const RegistrableDomain& subresourceDomain, const RegistrableDomain& topFrameDomain)
> {
>     ASSERT(!RunLoop::isMain());
> 
>-    auto& statistics = ensureResourceStatisticsForPrimaryDomain(primarySubresourceDomain);
>-    statistics.subresourceUnderTopFrameOrigins.add(primaryTopFrameDomain);
>+    auto& statistics = ensureResourceStatisticsForRegistrableDomain(subresourceDomain);
>+    statistics.subresourceUnderTopFrameOrigins.add(topFrameDomain.string());
>     // For consistency, make sure we also have a statistics entry for the top frame domain.
>-    ensureResourceStatisticsForPrimaryDomain(primaryTopFrameDomain);
>+    ensureResourceStatisticsForRegistrableDomain(topFrameDomain);
> }
> 
>-void ResourceLoadStatisticsMemoryStore::setSubresourceUniqueRedirectTo(const String& primarySubresourceDomain, const String& primaryRedirectDomain)
>+void ResourceLoadStatisticsMemoryStore::setSubresourceUniqueRedirectTo(const RegistrableDomain& subresourceDomain, const RegistrableDomain& redirectDomain)
> {
>     ASSERT(!RunLoop::isMain());
> 
>-    auto& statistics = ensureResourceStatisticsForPrimaryDomain(primarySubresourceDomain);
>-    statistics.subresourceUniqueRedirectsTo.add(primaryRedirectDomain);
>+    auto& statistics = ensureResourceStatisticsForRegistrableDomain(subresourceDomain);
>+    statistics.subresourceUniqueRedirectsTo.add(redirectDomain.string());
>     // For consistency, make sure we also have a statistics entry for the redirect domain.
>-    ensureResourceStatisticsForPrimaryDomain(primaryRedirectDomain);
>+    ensureResourceStatisticsForRegistrableDomain(redirectDomain);
> }
> 
>-void ResourceLoadStatisticsMemoryStore::setSubresourceUniqueRedirectFrom(const String& primarySubresourceDomain, const String& primaryRedirectDomain)
>+void ResourceLoadStatisticsMemoryStore::setSubresourceUniqueRedirectFrom(const RegistrableDomain& subresourceDomain, const RegistrableDomain& redirectDomain)
> {
>     ASSERT(!RunLoop::isMain());
> 
>-    auto& statistics = ensureResourceStatisticsForPrimaryDomain(primarySubresourceDomain);
>-    statistics.subresourceUniqueRedirectsFrom.add(primaryRedirectDomain);
>+    auto& statistics = ensureResourceStatisticsForRegistrableDomain(subresourceDomain);
>+    statistics.subresourceUniqueRedirectsFrom.add(redirectDomain.string());
>     // For consistency, make sure we also have a statistics entry for the redirect domain.
>-    ensureResourceStatisticsForPrimaryDomain(primaryRedirectDomain);
>+    ensureResourceStatisticsForRegistrableDomain(redirectDomain);
> }
> 
>-void ResourceLoadStatisticsMemoryStore::setTopFrameUniqueRedirectTo(const String& topFramePrimaryDomain, const String& primaryRedirectDomain)
>+void ResourceLoadStatisticsMemoryStore::setTopFrameUniqueRedirectTo(const RegistrableDomain& topFrameDomain, const RegistrableDomain& redirectDomain)
> {
>     ASSERT(!RunLoop::isMain());
> 
>-    auto& statistics = ensureResourceStatisticsForPrimaryDomain(topFramePrimaryDomain);
>-    statistics.topFrameUniqueRedirectsTo.add(primaryRedirectDomain);
>+    auto& statistics = ensureResourceStatisticsForRegistrableDomain(topFrameDomain);
>+    statistics.topFrameUniqueRedirectsTo.add(redirectDomain.string());
>     // For consistency, make sure we also have a statistics entry for the redirect domain.
>-    ensureResourceStatisticsForPrimaryDomain(primaryRedirectDomain);
>+    ensureResourceStatisticsForRegistrableDomain(redirectDomain);
> }
> 
>-void ResourceLoadStatisticsMemoryStore::setTopFrameUniqueRedirectFrom(const String& topFramePrimaryDomain, const String& primaryRedirectDomain)
>+void ResourceLoadStatisticsMemoryStore::setTopFrameUniqueRedirectFrom(const RegistrableDomain& topFrameDomain, const RegistrableDomain& redirectDomain)
> {
>     ASSERT(!RunLoop::isMain());
> 
>-    auto& statistics = ensureResourceStatisticsForPrimaryDomain(topFramePrimaryDomain);
>-    statistics.topFrameUniqueRedirectsFrom.add(primaryRedirectDomain);
>+    auto& statistics = ensureResourceStatisticsForRegistrableDomain(topFrameDomain);
>+    statistics.topFrameUniqueRedirectsFrom.add(redirectDomain.string());
>     // For consistency, make sure we also have a statistics entry for the redirect domain.
>-    ensureResourceStatisticsForPrimaryDomain(primaryRedirectDomain);
>+    ensureResourceStatisticsForRegistrableDomain(redirectDomain);
> }
> 
> void ResourceLoadStatisticsMemoryStore::setTimeToLiveUserInteraction(Seconds seconds)
>@@ -929,12 +926,12 @@ void ResourceLoadStatisticsMemoryStore::setDataRecordsBeingRemoved(bool value)
>         m_lastTimeDataRecordsWereRemoved = MonotonicTime::now();
> }
> 
>-ResourceLoadStatistics& ResourceLoadStatisticsMemoryStore::ensureResourceStatisticsForPrimaryDomain(const String& primaryDomain)
>+ResourceLoadStatistics& ResourceLoadStatisticsMemoryStore::ensureResourceStatisticsForRegistrableDomain(const RegistrableDomain& domain)
> {
>     ASSERT(!RunLoop::isMain());
> 
>-    return m_resourceStatisticsMap.ensure(primaryDomain, [&primaryDomain] {
>-        return ResourceLoadStatistics(primaryDomain);
>+    return m_resourceStatisticsMap.ensure(domain, [&domain] {
>+        return ResourceLoadStatistics(domain);
>     }).iterator->value;
> }
> 
>@@ -1033,7 +1030,7 @@ void ResourceLoadStatisticsMemoryStore::mergeStatistics(Vector<ResourceLoadStati
>     ASSERT(!RunLoop::isMain());
> 
>     for (auto& statistic : statistics) {
>-        auto result = m_resourceStatisticsMap.ensure(statistic.highLevelDomain, [&statistic] {
>+        auto result = m_resourceStatisticsMap.ensure(statistic.registrableDomain, [&statistic] {
>             return WTFMove(statistic);
>         });
>         if (!result.isNewEntry) {
>@@ -1054,12 +1051,12 @@ bool ResourceLoadStatisticsMemoryStore::shouldBlockAndPurgeCookies(const Resourc
>     return statistic.isPrevalentResource && !statistic.hadUserInteraction;
> }
> 
>-bool ResourceLoadStatisticsMemoryStore::hasUserGrantedStorageAccessThroughPrompt(const ResourceLoadStatistics& statistic, const String& firstPartyPrimaryDomain)
>+bool ResourceLoadStatisticsMemoryStore::hasUserGrantedStorageAccessThroughPrompt(const ResourceLoadStatistics& statistic, const RegistrableDomain& firstPartyDomain)
> {
>-    return statistic.storageAccessUnderTopFrameOrigins.contains(firstPartyPrimaryDomain);
>+    return statistic.storageAccessUnderTopFrameOrigins.contains(firstPartyDomain.string());
> }
> 
>-static void debugLogDomainsInBatches(const char* action, const Vector<String>& domains)
>+static void debugLogDomainsInBatches(const char* action, const Vector<RegistrableDomain>& domains)
> {
> #if !RELEASE_LOG_DISABLED
>     static const auto maxNumberOfDomainsInOneLogStatement = 50;
>@@ -1071,7 +1068,7 @@ static void debugLogDomainsInBatches(const char* action, const Vector<String>& d
>         return;
>     }
>     
>-    Vector<String> batch;
>+    Vector<RegistrableDomain> batch;
>     batch.reserveInitialCapacity(maxNumberOfDomainsInOneLogStatement);
>     auto batchNumber = 1;
>     unsigned numberOfBatches = std::ceil(domains.size() / static_cast<float>(maxNumberOfDomainsInOneLogStatement));
>@@ -1096,10 +1093,10 @@ void ResourceLoadStatisticsMemoryStore::updateCookieBlocking(CompletionHandler<v
> {
>     ASSERT(!RunLoop::isMain());
> 
>-    Vector<String> domainsToBlock;
>+    Vector<RegistrableDomain> domainsToBlock;
>     for (auto& resourceStatistic : m_resourceStatisticsMap.values()) {
>         if (resourceStatistic.isPrevalentResource)
>-            domainsToBlock.append(resourceStatistic.highLevelDomain);
>+            domainsToBlock.append(resourceStatistic.registrableDomain);
>     }
> 
>     if (domainsToBlock.isEmpty()) {
>@@ -1124,7 +1121,7 @@ void ResourceLoadStatisticsMemoryStore::updateCookieBlocking(CompletionHandler<v
>     });
> }
> 
>-void ResourceLoadStatisticsMemoryStore::updateCookieBlockingForDomains(const Vector<String>& domainsToBlock, CompletionHandler<void()>&& completionHandler)
>+void ResourceLoadStatisticsMemoryStore::updateCookieBlockingForDomains(const Vector<RegistrableDomain>& domainsToBlock, CompletionHandler<void()>&& completionHandler)
> {
>     ASSERT(!RunLoop::isMain());
> 
>@@ -1137,7 +1134,7 @@ void ResourceLoadStatisticsMemoryStore::updateCookieBlockingForDomains(const Vec
>     });
> }
> 
>-void ResourceLoadStatisticsMemoryStore::clearBlockingStateForDomains(const Vector<String>& domains, CompletionHandler<void()>&& completionHandler)
>+void ResourceLoadStatisticsMemoryStore::clearBlockingStateForDomains(const Vector<RegistrableDomain>& domains, CompletionHandler<void()>&& completionHandler)
> {
>     ASSERT(!RunLoop::isMain());
> 
>@@ -1177,7 +1174,7 @@ bool ResourceLoadStatisticsMemoryStore::hasHadUnexpiredRecentUserInteraction(Res
>     return resourceStatistic.hadUserInteraction;
> }
> 
>-Vector<String> ResourceLoadStatisticsMemoryStore::topPrivatelyControlledDomainsToRemoveWebsiteDataFor()
>+Vector<RegistrableDomain> ResourceLoadStatisticsMemoryStore::registrableDomainsToRemoveWebsiteDataFor()
> {
>     ASSERT(!RunLoop::isMain());
> 
>@@ -1187,10 +1184,10 @@ Vector<String> ResourceLoadStatisticsMemoryStore::topPrivatelyControlledDomainsT
>     if (shouldClearGrandfathering)
>         m_endOfGrandfatheringTimestamp = { };
> 
>-    Vector<String> prevalentResources;
>+    Vector<RegistrableDomain> prevalentResources;
>     for (auto& statistic : m_resourceStatisticsMap.values()) {
>         if (statistic.isPrevalentResource && !hasHadUnexpiredRecentUserInteraction(statistic) && (!shouldCheckForGrandfathering || !statistic.grandfathered))
>-            prevalentResources.append(statistic.highLevelDomain);
>+            prevalentResources.append(statistic.registrableDomain);
> 
>         if (shouldClearGrandfathering && statistic.grandfathered)
>             statistic.grandfathered = false;
>@@ -1259,7 +1256,7 @@ void ResourceLoadStatisticsMemoryStore::pruneStatisticsIfNeeded()
> 
>     Vector<StatisticsLastSeen> resourcesToPrunePerImportance[maxImportance + 1];
>     for (auto& resourceStatistic : m_resourceStatisticsMap.values())
>-        resourcesToPrunePerImportance[computeImportance(resourceStatistic)].append({ resourceStatistic.highLevelDomain, resourceStatistic.lastSeen });
>+        resourcesToPrunePerImportance[computeImportance(resourceStatistic)].append({ resourceStatistic.registrableDomain, resourceStatistic.lastSeen });
> 
>     for (unsigned importance = 0; numberOfEntriesLeftToPrune && importance <= maxImportance; ++importance)
>         pruneResources(m_resourceStatisticsMap, resourcesToPrunePerImportance[importance], numberOfEntriesLeftToPrune);
>@@ -1283,27 +1280,27 @@ void ResourceLoadStatisticsMemoryStore::logTestingEvent(const String& event)
>     });
> }
> 
>-void ResourceLoadStatisticsMemoryStore::setLastSeen(const String& primaryDomain, Seconds seconds)
>+void ResourceLoadStatisticsMemoryStore::setLastSeen(const RegistrableDomain& domain, Seconds seconds)
> {
>     ASSERT(!RunLoop::isMain());
> 
>-    auto& statistics = ensureResourceStatisticsForPrimaryDomain(primaryDomain);
>+    auto& statistics = ensureResourceStatisticsForRegistrableDomain(domain);
>     statistics.lastSeen = WallTime::fromRawSeconds(seconds.seconds());
> }
> 
>-void ResourceLoadStatisticsMemoryStore::setPrevalentResource(const String& primaryDomain)
>+void ResourceLoadStatisticsMemoryStore::setPrevalentResource(const RegistrableDomain& domain)
> {
>     ASSERT(!RunLoop::isMain());
> 
>-    auto& resourceStatistic = ensureResourceStatisticsForPrimaryDomain(primaryDomain);
>+    auto& resourceStatistic = ensureResourceStatisticsForRegistrableDomain(domain);
>     setPrevalentResource(resourceStatistic, ResourceLoadPrevalence::High);
> }
> 
>-void ResourceLoadStatisticsMemoryStore::setVeryPrevalentResource(const String& primaryDomain)
>+void ResourceLoadStatisticsMemoryStore::setVeryPrevalentResource(const RegistrableDomain& domain)
> {
>     ASSERT(!RunLoop::isMain());
> 
>-    auto& resourceStatistic = ensureResourceStatisticsForPrimaryDomain(primaryDomain);
>+    auto& resourceStatistic = ensureResourceStatisticsForRegistrableDomain(domain);
>     setPrevalentResource(resourceStatistic, ResourceLoadPrevalence::VeryHigh);
> }
> 
>diff --git a/Source/WebKit/NetworkProcess/Classifier/ResourceLoadStatisticsMemoryStore.h b/Source/WebKit/NetworkProcess/Classifier/ResourceLoadStatisticsMemoryStore.h
>index 40e8197f27678a5b8388b4cc814e5ab2b44d3ba9..69e330cefb1b73ce4c2e8bad60434241ecee17be 100644
>--- a/Source/WebKit/NetworkProcess/Classifier/ResourceLoadStatisticsMemoryStore.h
>+++ b/Source/WebKit/NetworkProcess/Classifier/ResourceLoadStatisticsMemoryStore.h
>@@ -52,6 +52,22 @@ class ResourceLoadStatisticsPersistentStorage;
> // This is always constructed / used / destroyed on the WebResourceLoadStatisticsStore's statistics queue.
> class ResourceLoadStatisticsMemoryStore : public CanMakeWeakPtr<ResourceLoadStatisticsMemoryStore> {
> public:
>+    using ResourceLoadStatistics = WebCore::ResourceLoadStatistics;
>+    using RegistrableDomain = WebCore::RegistrableDomain;
>+    using TopFrameDomain = WebCore::RegistrableDomain;
>+    using SubFrameDomain = WebCore::RegistrableDomain;
>+    using SubResourceDomain = WebCore::RegistrableDomain;
>+    using RedirectDomain = WebCore::RegistrableDomain;
>+    using RedirectedFromDomain = WebCore::RegistrableDomain;
>+    using RedirectedToDomain = WebCore::RegistrableDomain;
>+    using NavigatedFromDomain = WebCore::RegistrableDomain;
>+    using NavigatedToDomain = WebCore::RegistrableDomain;
>+    using DomainInNeedOfStorageAccess = WebCore::RegistrableDomain;
>+    using OpenerDomain = WebCore::RegistrableDomain;
>+    using OpenerPageID = uint64_t;
>+    using PageID = uint64_t;
>+    using FrameID = uint64_t;
>+
>     ResourceLoadStatisticsMemoryStore(WebResourceLoadStatisticsStore&, WorkQueue&);
>     ~ResourceLoadStatisticsMemoryStore();
> 
>@@ -63,42 +79,42 @@ public:
>     std::unique_ptr<WebCore::KeyedEncoder> createEncoderFromData() const;
>     void mergeWithDataFromDecoder(WebCore::KeyedDecoder&);
> 
>-    void mergeStatistics(Vector<WebCore::ResourceLoadStatistics>&&);
>-    void processStatistics(const Function<void(const WebCore::ResourceLoadStatistics&)>&) const;
>+    void mergeStatistics(Vector<ResourceLoadStatistics>&&);
>+    void processStatistics(const Function<void(const ResourceLoadStatistics&)>&) const;
> 
>     void updateCookieBlocking(CompletionHandler<void()>&&);
>-    void updateCookieBlockingForDomains(const Vector<String>& domainsToBlock, CompletionHandler<void()>&&);
>-    void clearBlockingStateForDomains(const Vector<String>& domains, CompletionHandler<void()>&&);
>+    void updateCookieBlockingForDomains(const Vector<RegistrableDomain>&, CompletionHandler<void()>&&);
>+    void clearBlockingStateForDomains(const Vector<RegistrableDomain>&, CompletionHandler<void()>&&);
> 
>     void includeTodayAsOperatingDateIfNecessary();
>     void processStatisticsAndDataRecords();
> 
>-    void requestStorageAccessUnderOpener(String&& primaryDomainInNeedOfStorageAccess, uint64_t openerPageID, String&& openerPrimaryDomain);
>+    void requestStorageAccessUnderOpener(DomainInNeedOfStorageAccess&&, OpenerPageID, OpenerDomain&&);
>     void removeAllStorageAccess(CompletionHandler<void()>&&);
> 
>     void grandfatherExistingWebsiteData(CompletionHandler<void()>&&);
>     void cancelPendingStatisticsProcessingRequest();
> 
>-    bool isRegisteredAsSubresourceUnder(const String& subresourcePrimaryDomain, const String& topFramePrimaryDomain) const;
>-    bool isRegisteredAsSubFrameUnder(const String& subFramePrimaryDomain, const String& topFramePrimaryDomain) const;
>-    bool isRegisteredAsRedirectingTo(const String& hostRedirectedFromPrimaryDomain, const String& hostRedirectedToPrimaryDomain) const;
>+    bool isRegisteredAsSubresourceUnder(const SubResourceDomain&, const TopFrameDomain&) const;
>+    bool isRegisteredAsSubFrameUnder(const SubFrameDomain&, const TopFrameDomain&) const;
>+    bool isRegisteredAsRedirectingTo(const RedirectedFromDomain&, const RedirectedToDomain&) const;
> 
>-    void clearPrevalentResource(const String& primaryDomain);
>+    void clearPrevalentResource(const RegistrableDomain&);
>     String dumpResourceLoadStatistics() const;
>-    bool isPrevalentResource(const String& primaryDomain) const;
>-    bool isVeryPrevalentResource(const String& primaryDomain) const;
>-    void setPrevalentResource(const String& primaryDomain);
>-    void setVeryPrevalentResource(const String& primaryDomain);
>+    bool isPrevalentResource(const RegistrableDomain&) const;
>+    bool isVeryPrevalentResource(const RegistrableDomain&) const;
>+    void setPrevalentResource(const RegistrableDomain&);
>+    void setVeryPrevalentResource(const RegistrableDomain&);
> 
>-    void setGrandfathered(const String& primaryDomain, bool value);
>-    bool isGrandfathered(const String& primaryDomain) const;
>+    void setGrandfathered(const RegistrableDomain&, bool value);
>+    bool isGrandfathered(const RegistrableDomain&) const;
> 
>-    void setSubframeUnderTopFrameOrigin(const String& primarySubFrameDomain, const String& primaryTopFrameDomain);
>-    void setSubresourceUnderTopFrameOrigin(const String& primarySubresourceDomain, const String& primaryTopFrameDomain);
>-    void setSubresourceUniqueRedirectTo(const String& primarySubresourceDomain, const String& primaryRedirectDomain);
>-    void setSubresourceUniqueRedirectFrom(const String& primarySubresourceDomain, const String& primaryRedirectDomain);
>-    void setTopFrameUniqueRedirectTo(const String& topFramePrimaryDomain, const String& primaryRedirectDomain);
>-    void setTopFrameUniqueRedirectFrom(const String& topFramePrimaryDomain, const String& primaryRedirectDomain);
>+    void setSubframeUnderTopFrameOrigin(const SubFrameDomain&, const TopFrameDomain&);
>+    void setSubresourceUnderTopFrameOrigin(const SubResourceDomain&, const TopFrameDomain&);
>+    void setSubresourceUniqueRedirectTo(const SubResourceDomain&, const RedirectDomain&);
>+    void setSubresourceUniqueRedirectFrom(const SubResourceDomain&, const RedirectDomain&);
>+    void setTopFrameUniqueRedirectTo(const TopFrameDomain&, const RedirectDomain&);
>+    void setTopFrameUniqueRedirectFrom(const TopFrameDomain&, const RedirectDomain&);
> 
>     void logTestingEvent(const String&);
> 
>@@ -116,48 +132,48 @@ public:
>     void setGrandfatheringTime(Seconds);
>     void setResourceLoadStatisticsDebugMode(bool);
>     bool isDebugModeEnabled() const { return m_debugModeEnabled; };
>-    void setPrevalentResourceForDebugMode(const String& domain);
>+    void setPrevalentResourceForDebugMode(const RegistrableDomain&);
> 
>-    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)>&&);
>+    void hasStorageAccess(const SubFrameDomain&, const TopFrameDomain&, Optional<FrameID>, PageID, CompletionHandler<void(bool)>&&);
>+    void requestStorageAccess(SubFrameDomain&&, TopFrameDomain&&, FrameID, PageID, bool promptEnabled, CompletionHandler<void(StorageAccessStatus)>&&);
>+    void grantStorageAccess(SubFrameDomain&&, TopFrameDomain&&, FrameID, PageID, bool userWasPromptedNow, CompletionHandler<void(bool)>&&);
> 
>-    void logFrameNavigation(const String& targetPrimaryDomain, const String& mainFramePrimaryDomain, const String& sourcePrimaryDomain, const String& targetHost, const String& mainFrameHost, bool isRedirect, bool isMainFrame);
>-    void logUserInteraction(const String& primaryDomain);
>-    void logSubresourceLoading(const String& targetPrimaryDomain, const String& mainFramePrimaryDomain, WallTime lastSeen);
>-    void logSubresourceRedirect(const String& sourcePrimaryDomain, const String& targetPrimaryDomain);
>+    void logFrameNavigation(const NavigatedToDomain&, const TopFrameDomain&, const NavigatedFromDomain&, bool isRedirect, bool isMainFrame);
>+    void logUserInteraction(const TopFrameDomain&);
>+    void logSubresourceLoading(const SubResourceDomain&, const TopFrameDomain&, WallTime lastSeen);
>+    void logSubresourceRedirect(const RedirectedFromDomain&, const RedirectedToDomain&);
> 
>-    void clearUserInteraction(const String& primaryDomain);
>-    bool hasHadUserInteraction(const String& primaryDomain);
>+    void clearUserInteraction(const RegistrableDomain&);
>+    bool hasHadUserInteraction(const RegistrableDomain&);
> 
>-    void setLastSeen(const String& primaryDomain, Seconds);
>+    void setLastSeen(const RegistrableDomain&, Seconds);
> 
>     void didCreateNetworkProcess();
> 
>     const WebResourceLoadStatisticsStore& store() const { return m_store; }
> 
> private:
>-    static bool shouldBlockAndKeepCookies(const WebCore::ResourceLoadStatistics&);
>-    static bool shouldBlockAndPurgeCookies(const WebCore::ResourceLoadStatistics&);
>-    static bool hasUserGrantedStorageAccessThroughPrompt(const WebCore::ResourceLoadStatistics&, const String& firstPartyPrimaryDomain);
>-    bool hasHadUnexpiredRecentUserInteraction(WebCore::ResourceLoadStatistics&) const;
>-    bool hasStatisticsExpired(const WebCore::ResourceLoadStatistics&) const;
>-    bool wasAccessedAsFirstPartyDueToUserInteraction(const WebCore::ResourceLoadStatistics& current, const WebCore::ResourceLoadStatistics& updated) const;
>-    void setPrevalentResource(WebCore::ResourceLoadStatistics&, ResourceLoadPrevalence);
>-    unsigned recursivelyGetAllDomainsThatHaveRedirectedToThisDomain(const WebCore::ResourceLoadStatistics&, HashSet<String>& domainsThatHaveRedirectedTo, unsigned numberOfRecursiveCalls) const;
>+    static bool shouldBlockAndKeepCookies(const ResourceLoadStatistics&);
>+    static bool shouldBlockAndPurgeCookies(const ResourceLoadStatistics&);
>+    static bool hasUserGrantedStorageAccessThroughPrompt(const ResourceLoadStatistics&, const RegistrableDomain&);
>+    bool hasHadUnexpiredRecentUserInteraction(ResourceLoadStatistics&) const;
>+    bool hasStatisticsExpired(const ResourceLoadStatistics&) const;
>+    bool wasAccessedAsFirstPartyDueToUserInteraction(const ResourceLoadStatistics& current, const ResourceLoadStatistics& updated) const;
>+    void setPrevalentResource(ResourceLoadStatistics&, ResourceLoadPrevalence);
>+    unsigned recursivelyGetAllDomainsThatHaveRedirectedToThisDomain(const ResourceLoadStatistics&, HashSet<RedirectedToDomain>&, unsigned numberOfRecursiveCalls) const;
>     void setStorageAccessPromptsEnabled(bool enabled) { m_storageAccessPromptsEnabled  = enabled; }
>     bool shouldRemoveDataRecords() const;
>     void setDebugLogggingEnabled(bool enabled) { m_debugLoggingEnabled  = enabled; }
>     void setDataRecordsBeingRemoved(bool);
>     void scheduleStatisticsProcessingRequestIfNecessary();
>-    void grantStorageAccessInternal(String&& subFrameHost, String&& topFrameHost, Optional<uint64_t> frameID, uint64_t pageID, bool userWasPromptedNowOrEarlier, CompletionHandler<void(bool)>&&);
>-    void markAsPrevalentIfHasRedirectedToPrevalent(WebCore::ResourceLoadStatistics&);
>-    bool isPrevalentDueToDebugMode(WebCore::ResourceLoadStatistics&);
>-    Vector<String> ensurePrevalentResourcesForDebugMode();
>+    void grantStorageAccessInternal(SubFrameDomain&&, TopFrameDomain&&, Optional<FrameID>, PageID, bool userWasPromptedNowOrEarlier, CompletionHandler<void(bool)>&&);
>+    void markAsPrevalentIfHasRedirectedToPrevalent(ResourceLoadStatistics&);
>+    bool isPrevalentDueToDebugMode(ResourceLoadStatistics&);
>+    Vector<RegistrableDomain> ensurePrevalentResourcesForDebugMode();
>     void removeDataRecords(CompletionHandler<void()>&&);
>     void pruneStatisticsIfNeeded();
>-    WebCore::ResourceLoadStatistics& ensureResourceStatisticsForPrimaryDomain(const String&);
>-    Vector<String> topPrivatelyControlledDomainsToRemoveWebsiteDataFor();
>+    ResourceLoadStatistics& ensureResourceStatisticsForRegistrableDomain(const RegistrableDomain&);
>+    Vector<RegistrableDomain> registrableDomainsToRemoveWebsiteDataFor();
>     void setCacheMaxAgeCap(Seconds);
>     void updateCacheMaxAgeCap();
>     void setAgeCapForClientSideCookies(Seconds);
>@@ -183,7 +199,7 @@ private:
>     WebResourceLoadStatisticsStore& m_store;
>     Ref<WorkQueue> m_workQueue;
>     WeakPtr<ResourceLoadStatisticsPersistentStorage> m_persistentStorage;
>-    HashMap<String, WebCore::ResourceLoadStatistics> m_resourceStatisticsMap;
>+    HashMap<RegistrableDomain, ResourceLoadStatistics> m_resourceStatisticsMap;
> #if HAVE(CORE_PREDICTION)
>     ResourceLoadStatisticsClassifierCocoa m_resourceLoadStatisticsClassifier;
> #else
>@@ -197,7 +213,8 @@ private:
>     WallTime m_endOfGrandfatheringTimestamp;
>     bool m_debugLoggingEnabled { false };
>     bool m_debugModeEnabled { false };
>-    String m_debugManualPrevalentResource;
>+    const RegistrableDomain m_debugStaticPrevalentResource { "3rdpartytestwebkit.org" };
>+    RegistrableDomain m_debugManualPrevalentResource;
>     bool m_storageAccessPromptsEnabled { false };
>     bool m_dataRecordsBeingRemoved { false };
>     MonotonicTime m_lastTimeDataRecordsWereRemoved;
>diff --git a/Source/WebKit/NetworkProcess/Classifier/WebResourceLoadStatisticsStore.cpp b/Source/WebKit/NetworkProcess/Classifier/WebResourceLoadStatisticsStore.cpp
>index 30fe91f4c085d5d8c280e6a9a9e2171f685b7ebc..adbdad2398fb8e077ca41797a79fedc040518d39 100644
>--- a/Source/WebKit/NetworkProcess/Classifier/WebResourceLoadStatisticsStore.cpp
>+++ b/Source/WebKit/NetworkProcess/Classifier/WebResourceLoadStatisticsStore.cpp
>@@ -56,11 +56,6 @@
> namespace WebKit {
> using namespace WebCore;
> 
>-template<typename T> static inline String isolatedPrimaryDomain(const T& value)
>-{
>-    return ResourceLoadStatistics::primaryDomain(value).isolatedCopy();
>-}
>-
> const OptionSet<WebsiteDataType>& WebResourceLoadStatisticsStore::monitoredDataTypes()
> {
>     static NeverDestroyed<OptionSet<WebsiteDataType>> dataTypes(std::initializer_list<WebsiteDataType>({
>@@ -208,13 +203,13 @@ void WebResourceLoadStatisticsStore::setResourceLoadStatisticsDebugMode(bool val
>     });
> }
> 
>-void WebResourceLoadStatisticsStore::setPrevalentResourceForDebugMode(const String& primaryDomain, CompletionHandler<void()>&& completionHandler)
>+void WebResourceLoadStatisticsStore::setPrevalentResourceForDebugMode(const RegistrableDomain& domain, CompletionHandler<void()>&& completionHandler)
> {
>     ASSERT(RunLoop::isMain());
>     
>-    postTask([this, primaryDomain = isolatedPrimaryDomain(primaryDomain), completionHandler = WTFMove(completionHandler)]() mutable {
>+    postTask([this, domain = domain.isolatedCopy(), completionHandler = WTFMove(completionHandler)]() mutable {
>         if (m_memoryStore)
>-            m_memoryStore->setPrevalentResourceForDebugMode(primaryDomain);
>+            m_memoryStore->setPrevalentResourceForDebugMode(domain);
>         postTaskReply(WTFMove(completionHandler));
>     });
> }
>@@ -257,19 +252,19 @@ void WebResourceLoadStatisticsStore::resourceLoadStatisticsUpdated(Vector<WebCor
>     });
> }
> 
>-void WebResourceLoadStatisticsStore::hasStorageAccess(const String& subFrameHost, const String& topFrameHost, Optional<uint64_t> frameID, uint64_t pageID, CompletionHandler<void(bool)>&& completionHandler)
>+void WebResourceLoadStatisticsStore::hasStorageAccess(const RegistrableDomain& subFrameDomain, const RegistrableDomain& topFrameDomain, Optional<uint64_t> frameID, uint64_t pageID, CompletionHandler<void(bool)>&& completionHandler)
> {
>-    ASSERT(subFrameHost != topFrameHost);
>+    ASSERT(subFrameDomain != topFrameDomain);
>     ASSERT(RunLoop::isMain());
> 
>-    postTask([this, subFramePrimaryDomain = isolatedPrimaryDomain(subFrameHost), topFramePrimaryDomain = isolatedPrimaryDomain(topFrameHost), frameID, pageID, completionHandler = WTFMove(completionHandler)]() mutable {
>+    postTask([this, subFrameDomain = subFrameDomain.isolatedCopy(), topFrameDomain = topFrameDomain.isolatedCopy(), frameID, pageID, completionHandler = WTFMove(completionHandler)]() mutable {
>         if (!m_memoryStore) {
>             postTaskReply([completionHandler = WTFMove(completionHandler)]() mutable {
>                 completionHandler(false);
>             });
>             return;
>         }
>-        m_memoryStore->hasStorageAccess(subFramePrimaryDomain, topFramePrimaryDomain, frameID, pageID, [completionHandler = WTFMove(completionHandler)](bool hasStorageAccess) mutable {
>+        m_memoryStore->hasStorageAccess(subFrameDomain, topFrameDomain, frameID, pageID, [completionHandler = WTFMove(completionHandler)](bool hasStorageAccess) mutable {
>             postTaskReply([completionHandler = WTFMove(completionHandler), hasStorageAccess]() mutable {
>                 completionHandler(hasStorageAccess);
>             });
>@@ -277,12 +272,12 @@ void WebResourceLoadStatisticsStore::hasStorageAccess(const String& subFrameHost
>     });
> }
> 
>-bool WebResourceLoadStatisticsStore::hasStorageAccessForFrame(const String& resourceDomain, const String& firstPartyDomain, uint64_t frameID, uint64_t pageID)
>+bool WebResourceLoadStatisticsStore::hasStorageAccessForFrame(const RegistrableDomain& resourceDomain, const RegistrableDomain& firstPartyDomain, uint64_t frameID, uint64_t pageID)
> {
>     return m_networkSession ? m_networkSession->networkStorageSession().hasStorageAccess(resourceDomain, firstPartyDomain, frameID, pageID) : false;
> }
> 
>-void WebResourceLoadStatisticsStore::callHasStorageAccessForFrameHandler(const String& resourceDomain, const String& firstPartyDomain, uint64_t frameID, uint64_t pageID, CompletionHandler<void(bool hasAccess)>&& callback)
>+void WebResourceLoadStatisticsStore::callHasStorageAccessForFrameHandler(const RegistrableDomain& resourceDomain, const RegistrableDomain& firstPartyDomain, uint64_t frameID, uint64_t pageID, CompletionHandler<void(bool hasAccess)>&& callback)
> {
>     ASSERT(RunLoop::isMain());
> 
>@@ -294,9 +289,9 @@ void WebResourceLoadStatisticsStore::callHasStorageAccessForFrameHandler(const S
>     callback(false);
> }
> 
>-void WebResourceLoadStatisticsStore::requestStorageAccessGranted(const String& subFrameHost, const String& topFrameHost, uint64_t frameID, uint64_t pageID, bool promptEnabled, CompletionHandler<void(bool)>&& completionHandler)
>+void WebResourceLoadStatisticsStore::requestStorageAccessGranted(const RegistrableDomain& subFrameDomain, const RegistrableDomain& topFrameDomain, uint64_t frameID, uint64_t pageID, bool promptEnabled, CompletionHandler<void(bool)>&& completionHandler)
> {
>-    auto statusHandler = [this, protectedThis = makeRef(*this), subFrameHost = isolatedPrimaryDomain(subFrameHost), topFrameHost = isolatedPrimaryDomain(topFrameHost), promptEnabled, frameID, pageID, completionHandler = WTFMove(completionHandler)](StorageAccessStatus status) mutable {
>+    auto statusHandler = [this, protectedThis = makeRef(*this), subFrameDomain = subFrameDomain.isolatedCopy(), topFrameDomain = topFrameDomain.isolatedCopy(), promptEnabled, frameID, pageID, completionHandler = WTFMove(completionHandler)](StorageAccessStatus status) mutable {
>         switch (status) {
>         case StorageAccessStatus::CannotRequestAccess:
>             completionHandler(false);
>@@ -304,15 +299,13 @@ void WebResourceLoadStatisticsStore::requestStorageAccessGranted(const String& s
>         case StorageAccessStatus::RequiresUserPrompt:
>             {
>             ASSERT_UNUSED(promptEnabled, promptEnabled);
>-            auto subFramePrimaryDomain = ResourceLoadStatistics::primaryDomain(subFrameHost);
>-            auto topFramePrimaryDomain = ResourceLoadStatistics::primaryDomain(topFrameHost);
>-            CompletionHandler<void(bool)> requestConfirmationCompletionHandler = [this, protectedThis = protectedThis.copyRef(), subFrameHost = WTFMove(subFrameHost), topFrameHost = WTFMove(topFrameHost), frameID, pageID, completionHandler = WTFMove(completionHandler)] (bool userDidGrantAccess) mutable {
>+            CompletionHandler<void(bool)> requestConfirmationCompletionHandler = [this, protectedThis = protectedThis.copyRef(), subFrameDomain, topFrameDomain, frameID, pageID, completionHandler = WTFMove(completionHandler)] (bool userDidGrantAccess) mutable {
>                 if (userDidGrantAccess)
>-                    grantStorageAccess(WTFMove(subFrameHost), WTFMove(topFrameHost), frameID, pageID, userDidGrantAccess, WTFMove(completionHandler));
>+                    grantStorageAccess(subFrameDomain, topFrameDomain, frameID, pageID, userDidGrantAccess, WTFMove(completionHandler));
>                 else
>                     completionHandler(false);
>             };
>-            m_networkSession->networkProcess().parentProcessConnection()->sendWithAsyncReply(Messages::NetworkProcessProxy::RequestStorageAccessConfirm(pageID, frameID, subFramePrimaryDomain, topFramePrimaryDomain), WTFMove(requestConfirmationCompletionHandler));
>+            m_networkSession->networkProcess().parentProcessConnection()->sendWithAsyncReply(Messages::NetworkProcessProxy::RequestStorageAccessConfirm(pageID, frameID, subFrameDomain.string(), topFrameDomain.string()), WTFMove(requestConfirmationCompletionHandler));
>             }
>             return;
>         case StorageAccessStatus::HasAccess:
>@@ -321,19 +314,17 @@ void WebResourceLoadStatisticsStore::requestStorageAccessGranted(const String& s
>         }
>     };
> 
>-    requestStorageAccess(subFrameHost, topFrameHost, frameID, pageID, promptEnabled, WTFMove(statusHandler));
>+    requestStorageAccess(subFrameDomain, topFrameDomain, frameID, pageID, promptEnabled, WTFMove(statusHandler));
> }
> 
>-void WebResourceLoadStatisticsStore::requestStorageAccess(const String& subFrameHost, const String& topFrameHost, Optional<uint64_t> frameID, uint64_t pageID, bool promptEnabled, CompletionHandler<void(StorageAccessStatus)>&& completionHandler)
>+void WebResourceLoadStatisticsStore::requestStorageAccess(const RegistrableDomain& subFrameDomain, const RegistrableDomain& topFrameDomain, Optional<uint64_t> frameID, uint64_t pageID, bool promptEnabled, CompletionHandler<void(StorageAccessStatus)>&& completionHandler)
> {
>-    auto subFramePrimaryDomain = isolatedPrimaryDomain(subFrameHost);
>-    auto topFramePrimaryDomain = isolatedPrimaryDomain(topFrameHost);
>-    if (subFramePrimaryDomain == topFramePrimaryDomain) {
>+    if (subFrameDomain == topFrameDomain) {
>         completionHandler(StorageAccessStatus::HasAccess);
>         return;
>     }
> 
>-    postTask([this, subFramePrimaryDomain = crossThreadCopy(subFramePrimaryDomain), topFramePrimaryDomain = crossThreadCopy(topFramePrimaryDomain), frameID, pageID, promptEnabled, completionHandler = WTFMove(completionHandler)]() mutable {
>+    postTask([this, subFrameDomain = subFrameDomain.isolatedCopy(), topFrameDomain = topFrameDomain.isolatedCopy(), frameID, pageID, promptEnabled, completionHandler = WTFMove(completionHandler)]() mutable {
>         if (!m_memoryStore) {
>             postTaskReply([completionHandler = WTFMove(completionHandler)]() mutable {
>                 completionHandler(StorageAccessStatus::CannotRequestAccess);
>@@ -341,7 +332,7 @@ void WebResourceLoadStatisticsStore::requestStorageAccess(const String& subFrame
>             return;
>         }
> 
>-        m_memoryStore->requestStorageAccess(WTFMove(subFramePrimaryDomain), WTFMove(topFramePrimaryDomain), frameID.value(), pageID, promptEnabled, [completionHandler = WTFMove(completionHandler)](StorageAccessStatus status) mutable {
>+        m_memoryStore->requestStorageAccess(WTFMove(subFrameDomain), WTFMove(topFrameDomain), frameID.value(), pageID, promptEnabled, [completionHandler = WTFMove(completionHandler)](StorageAccessStatus status) mutable {
>             postTaskReply([completionHandler = WTFMove(completionHandler), status]() mutable {
>                 completionHandler(status);
>             });
>@@ -349,23 +340,23 @@ void WebResourceLoadStatisticsStore::requestStorageAccess(const String& subFrame
>     });
> }
> 
>-void WebResourceLoadStatisticsStore::requestStorageAccessUnderOpener(String&& primaryDomainInNeedOfStorageAccess, uint64_t openerPageID, String&& openerPrimaryDomain)
>+void WebResourceLoadStatisticsStore::requestStorageAccessUnderOpener(RegistrableDomain&& domainInNeedOfStorageAccess, uint64_t openerPageID, RegistrableDomain&& openerDomain)
> {
>     ASSERT(RunLoop::isMain());
> 
>     // It is safe to move the strings to the background queue without isolated copy here because they are r-value references
>     // coming from IPC. Strings which are safe to move to other threads as long as nobody on this thread holds a reference
>     // to those strings.
>-    postTask([this, primaryDomainInNeedOfStorageAccess = WTFMove(primaryDomainInNeedOfStorageAccess), openerPageID, openerPrimaryDomain = WTFMove(openerPrimaryDomain)]() mutable {
>+    postTask([this, domainInNeedOfStorageAccess = WTFMove(domainInNeedOfStorageAccess), openerPageID, openerDomain = WTFMove(openerDomain)]() mutable {
>         if (m_memoryStore)
>-            m_memoryStore->requestStorageAccessUnderOpener(WTFMove(primaryDomainInNeedOfStorageAccess), openerPageID, WTFMove(openerPrimaryDomain));
>+            m_memoryStore->requestStorageAccessUnderOpener(WTFMove(domainInNeedOfStorageAccess), openerPageID, WTFMove(openerDomain));
>     });
> }
> 
>-void WebResourceLoadStatisticsStore::grantStorageAccess(const String& subFrameHost, const String& topFrameHost, uint64_t frameID, uint64_t pageID, bool userWasPromptedNow, CompletionHandler<void(bool)>&& completionHandler)
>+void WebResourceLoadStatisticsStore::grantStorageAccess(const RegistrableDomain& subFrameDomain, const RegistrableDomain& topFrameDomain, 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, subFrameDomain = subFrameDomain.isolatedCopy(), topFrameDomain = topFrameDomain.isolatedCopy(), frameID, pageID, userWasPromptedNow, completionHandler = WTFMove(completionHandler)]() mutable {
>         if (!m_memoryStore) {
>             postTaskReply([completionHandler = WTFMove(completionHandler)]() mutable {
>                 completionHandler(false);
>@@ -373,7 +364,7 @@ void WebResourceLoadStatisticsStore::grantStorageAccess(const String& subFrameHo
>             return;
>         }
> 
>-        m_memoryStore->grantStorageAccess(WTFMove(subFrameHost), WTFMove(topFrameHost), frameID, pageID, userWasPromptedNow, [completionHandler = WTFMove(completionHandler)](bool wasGrantedAccess) mutable {
>+        m_memoryStore->grantStorageAccess(WTFMove(subFrameDomain), WTFMove(topFrameDomain), frameID, pageID, userWasPromptedNow, [completionHandler = WTFMove(completionHandler)](bool wasGrantedAccess) mutable {
>             postTaskReply([completionHandler = WTFMove(completionHandler), wasGrantedAccess]() mutable {
>                 completionHandler(wasGrantedAccess);
>             });
>@@ -381,7 +372,7 @@ void WebResourceLoadStatisticsStore::grantStorageAccess(const String& subFrameHo
>     });
> }
> 
>-bool WebResourceLoadStatisticsStore::grantStorageAccess(const String& resourceDomain, const String& firstPartyDomain, Optional<uint64_t> frameID, uint64_t pageID)
>+bool WebResourceLoadStatisticsStore::grantStorageAccess(const RegistrableDomain& resourceDomain, const RegistrableDomain& firstPartyDomain, Optional<uint64_t> frameID, uint64_t pageID)
> {
>     bool isStorageGranted = false;
> 
>@@ -394,11 +385,11 @@ bool WebResourceLoadStatisticsStore::grantStorageAccess(const String& resourceDo
>     return isStorageGranted;
> }
> 
>-void WebResourceLoadStatisticsStore::callGrantStorageAccessHandler(const String& subFramePrimaryDomain, const String& topFramePrimaryDomain, Optional<uint64_t> frameID, uint64_t pageID, CompletionHandler<void(bool)>&& callback)
>+void WebResourceLoadStatisticsStore::callGrantStorageAccessHandler(const RegistrableDomain& subFrameDomain, const RegistrableDomain& topFrameDomain, Optional<uint64_t> frameID, uint64_t pageID, CompletionHandler<void(bool)>&& callback)
> {
>     ASSERT(RunLoop::isMain());
> 
>-    callback(grantStorageAccess(subFramePrimaryDomain, topFramePrimaryDomain, frameID, pageID));
>+    callback(grantStorageAccess(subFrameDomain, topFrameDomain, frameID, pageID));
> }
> 
> void WebResourceLoadStatisticsStore::didCreateNetworkProcess()
>@@ -475,113 +466,113 @@ void WebResourceLoadStatisticsStore::logFrameNavigation(const WebFrameProxy& fra
>     if (targetHost.isEmpty() || mainFrameHost.isEmpty() || targetHost == sourceURL.host())
>         return;
> 
>-    auto targetPrimaryDomain = ResourceLoadStatistics::primaryDomain(targetURL);
>-    auto mainFramePrimaryDomain = ResourceLoadStatistics::primaryDomain(pageURL);
>-    auto sourcePrimaryDomain = ResourceLoadStatistics::primaryDomain(sourceURL);
>+    RegistrableDomain targetDomain { targetURL };
>+    RegistrableDomain topFrameDomain { pageURL };
>+    RegistrableDomain sourceDomain { sourceURL };
> 
>-    logFrameNavigation(targetPrimaryDomain, mainFramePrimaryDomain, sourcePrimaryDomain, targetHost.toString(), mainFrameHost.toString(), isRedirect, frame.isMainFrame());
>+    logFrameNavigation(targetDomain, topFrameDomain, sourceDomain, isRedirect, frame.isMainFrame());
> }
> 
>-void WebResourceLoadStatisticsStore::logFrameNavigation(const String& targetPrimaryDomain, const String& mainFramePrimaryDomain, const String& sourcePrimaryDomain, const String& targetHost, const String& mainFrameHost, bool isRedirect, bool isMainFrame)
>+void WebResourceLoadStatisticsStore::logFrameNavigation(const RegistrableDomain& targetDomain, const RegistrableDomain& topFrameDomain, const RegistrableDomain& sourceDomain, bool isRedirect, bool isMainFrame)
> {
>-    postTask([this, targetPrimaryDomain = isolatedPrimaryDomain(targetPrimaryDomain), mainFramePrimaryDomain = isolatedPrimaryDomain(mainFramePrimaryDomain), sourcePrimaryDomain = isolatedPrimaryDomain(sourcePrimaryDomain), targetHost = isolatedPrimaryDomain(targetHost), mainFrameHost = isolatedPrimaryDomain(mainFrameHost), isRedirect, isMainFrame] {
>-        
>+    postTask([this, targetDomain = targetDomain.isolatedCopy(), topFrameDomain = topFrameDomain.isolatedCopy(), sourceDomain = sourceDomain.isolatedCopy(), isRedirect, isMainFrame] {
>+
>         if (m_memoryStore)
>-            m_memoryStore->logFrameNavigation(targetPrimaryDomain, mainFramePrimaryDomain, sourcePrimaryDomain, targetHost, mainFrameHost, isRedirect, isMainFrame);
>+            m_memoryStore->logFrameNavigation(targetDomain, topFrameDomain, sourceDomain, isRedirect, isMainFrame);
>     });
> }
> 
>-void WebResourceLoadStatisticsStore::logWebSocketLoading(const String& targetPrimaryDomain, const String& mainFramePrimaryDomain, WallTime lastSeen, CompletionHandler<void()>&& completionHandler)
>+void WebResourceLoadStatisticsStore::logWebSocketLoading(const RegistrableDomain& targetDomain, const RegistrableDomain& topFrameDomain, WallTime lastSeen, CompletionHandler<void()>&& completionHandler)
> {
>-    postTask([this, targetPrimaryDomain = isolatedPrimaryDomain(targetPrimaryDomain), mainFramePrimaryDomain = isolatedPrimaryDomain(mainFramePrimaryDomain), lastSeen, completionHandler = WTFMove(completionHandler)]() mutable {
>+    postTask([this, targetDomain = targetDomain.isolatedCopy(), topFrameDomain = topFrameDomain.isolatedCopy(), lastSeen, completionHandler = WTFMove(completionHandler)]() mutable {
>         if (m_memoryStore)
>-            m_memoryStore->logSubresourceLoading(targetPrimaryDomain, mainFramePrimaryDomain, lastSeen);
>+            m_memoryStore->logSubresourceLoading(targetDomain, topFrameDomain, lastSeen);
> 
>         postTaskReply(WTFMove(completionHandler));
>     });
> }
> 
>-void WebResourceLoadStatisticsStore::logSubresourceLoading(const String& targetPrimaryDomain, const String& mainFramePrimaryDomain, WallTime lastSeen, CompletionHandler<void()>&& completionHandler)
>+void WebResourceLoadStatisticsStore::logSubresourceLoading(const RegistrableDomain& targetDomain, const RegistrableDomain& topFrameDomain, WallTime lastSeen, CompletionHandler<void()>&& completionHandler)
> {
>-    postTask([this, targetPrimaryDomain = isolatedPrimaryDomain(targetPrimaryDomain), mainFramePrimaryDomain = isolatedPrimaryDomain(mainFramePrimaryDomain), lastSeen, completionHandler = WTFMove(completionHandler)]() mutable {
>+    postTask([this, targetDomain = targetDomain.isolatedCopy(), topFrameDomain = topFrameDomain.isolatedCopy(), lastSeen, completionHandler = WTFMove(completionHandler)]() mutable {
>         if (m_memoryStore)
>-            m_memoryStore->logSubresourceLoading(targetPrimaryDomain, mainFramePrimaryDomain, lastSeen);
>-        
>+            m_memoryStore->logSubresourceLoading(targetDomain, topFrameDomain, lastSeen);
>+
>         postTaskReply(WTFMove(completionHandler));
>     });
> }
> 
>-void WebResourceLoadStatisticsStore::logSubresourceRedirect(const String& sourcePrimaryDomain, const String& targetPrimaryDomain, CompletionHandler<void()>&& completionHandler)
>+void WebResourceLoadStatisticsStore::logSubresourceRedirect(const RegistrableDomain& sourceDomain, const RegistrableDomain& targetDomain, CompletionHandler<void()>&& completionHandler)
> {
>-    postTask([this, sourcePrimaryDomain = isolatedPrimaryDomain(sourcePrimaryDomain), targetPrimaryDomain = isolatedPrimaryDomain(targetPrimaryDomain), completionHandler = WTFMove(completionHandler)]() mutable {
>+    postTask([this, sourceDomain = sourceDomain.isolatedCopy(), targetDomain = targetDomain.isolatedCopy(), completionHandler = WTFMove(completionHandler)]() mutable {
>         if (m_memoryStore)
>-            m_memoryStore->logSubresourceRedirect(sourcePrimaryDomain, targetPrimaryDomain);
>-        
>+            m_memoryStore->logSubresourceRedirect(sourceDomain, targetDomain);
>+
>         postTaskReply(WTFMove(completionHandler));
>     });
> }
> 
>-void WebResourceLoadStatisticsStore::logUserInteraction(const String& targetPrimaryDomain, CompletionHandler<void()>&& completionHandler)
>+void WebResourceLoadStatisticsStore::logUserInteraction(const RegistrableDomain& domain, CompletionHandler<void()>&& completionHandler)
> {
>     ASSERT(RunLoop::isMain());
> 
>-    postTask([this, primaryDomain = isolatedPrimaryDomain(targetPrimaryDomain), completionHandler = WTFMove(completionHandler)]() mutable {
>+    postTask([this, domain = domain.isolatedCopy(), completionHandler = WTFMove(completionHandler)]() mutable {
>         if (m_memoryStore)
>-            m_memoryStore->logUserInteraction(primaryDomain);
>+            m_memoryStore->logUserInteraction(domain);
>         postTaskReply(WTFMove(completionHandler));
>     });
> }
> 
>-void WebResourceLoadStatisticsStore::clearUserInteraction(const String& targetPrimaryDomain, CompletionHandler<void()>&& completionHandler)
>+void WebResourceLoadStatisticsStore::clearUserInteraction(const RegistrableDomain& domain, CompletionHandler<void()>&& completionHandler)
> {
>     ASSERT(RunLoop::isMain());
>     
>-    postTask([this, primaryDomain = isolatedPrimaryDomain(targetPrimaryDomain), completionHandler = WTFMove(completionHandler)]() mutable {
>+    postTask([this, domain = domain.isolatedCopy(), completionHandler = WTFMove(completionHandler)]() mutable {
>         if (m_memoryStore)
>-            m_memoryStore->clearUserInteraction(primaryDomain);
>+            m_memoryStore->clearUserInteraction(domain);
>         postTaskReply(WTFMove(completionHandler));
>     });
> }
> 
>-void WebResourceLoadStatisticsStore::hasHadUserInteraction(const String& primaryDomain, CompletionHandler<void(bool)>&& completionHandler)
>+void WebResourceLoadStatisticsStore::hasHadUserInteraction(const RegistrableDomain& domain, CompletionHandler<void(bool)>&& completionHandler)
> {
>-    postTask([this, primaryDomain = isolatedPrimaryDomain(primaryDomain), completionHandler = WTFMove(completionHandler)]() mutable {
>-        bool hadUserInteraction = m_memoryStore ? m_memoryStore->hasHadUserInteraction(primaryDomain) : false;
>+    postTask([this, domain, completionHandler = WTFMove(completionHandler)]() mutable {
>+        bool hadUserInteraction = m_memoryStore ? m_memoryStore->hasHadUserInteraction(domain) : false;
>         postTaskReply([hadUserInteraction, completionHandler = WTFMove(completionHandler)]() mutable {
>             completionHandler(hadUserInteraction);
>         });
>     });
> }
> 
>-void WebResourceLoadStatisticsStore::setLastSeen(const String& resourceDomain, Seconds seconds, CompletionHandler<void()>&& completionHandler)
>+void WebResourceLoadStatisticsStore::setLastSeen(const RegistrableDomain& domain, Seconds seconds, CompletionHandler<void()>&& completionHandler)
> {
>     ASSERT(RunLoop::isMain());
>     
>-    postTask([this, resourceDomain = isolatedPrimaryDomain(resourceDomain), seconds, completionHandler = WTFMove(completionHandler)]() mutable {
>+    postTask([this, domain = domain.isolatedCopy(), seconds, completionHandler = WTFMove(completionHandler)]() mutable {
>         if (m_memoryStore)
>-            m_memoryStore->setLastSeen(resourceDomain, seconds);
>+            m_memoryStore->setLastSeen(domain, seconds);
>         postTaskReply(WTFMove(completionHandler));
>     });
> }
>     
>-void WebResourceLoadStatisticsStore::setPrevalentResource(const String& resourceDomain, CompletionHandler<void()>&& completionHandler)
>+void WebResourceLoadStatisticsStore::setPrevalentResource(const RegistrableDomain& domain, CompletionHandler<void()>&& completionHandler)
> {
>     ASSERT(RunLoop::isMain());
> 
>-    postTask([this, resourceDomain = isolatedPrimaryDomain(resourceDomain), completionHandler = WTFMove(completionHandler)]() mutable {
>+    postTask([this, domain = domain.isolatedCopy(), completionHandler = WTFMove(completionHandler)]() mutable {
>         if (m_memoryStore)
>-            m_memoryStore->setPrevalentResource(resourceDomain);
>+            m_memoryStore->setPrevalentResource(domain);
>         postTaskReply(WTFMove(completionHandler));
>     });
> }
> 
>-void WebResourceLoadStatisticsStore::setVeryPrevalentResource(const String& primaryDomain, CompletionHandler<void()>&& completionHandler)
>+void WebResourceLoadStatisticsStore::setVeryPrevalentResource(const RegistrableDomain& domain, CompletionHandler<void()>&& completionHandler)
> {
>     ASSERT(RunLoop::isMain());
> 
>-    postTask([this, primaryDomain = isolatedPrimaryDomain(primaryDomain), completionHandler = WTFMove(completionHandler)]() mutable {
>+    postTask([this, domain = domain.isolatedCopy(), completionHandler = WTFMove(completionHandler)]() mutable {
>         if (m_memoryStore)
>-            m_memoryStore->setVeryPrevalentResource(primaryDomain);
>+            m_memoryStore->setVeryPrevalentResource(domain);
>         postTaskReply(WTFMove(completionHandler));
>     });
> }
>@@ -598,162 +589,162 @@ void WebResourceLoadStatisticsStore::dumpResourceLoadStatistics(CompletionHandle
>     });
> }
> 
>-void WebResourceLoadStatisticsStore::isPrevalentResource(const String& primaryDomain, CompletionHandler<void(bool)>&& completionHandler)
>+void WebResourceLoadStatisticsStore::isPrevalentResource(const RegistrableDomain& domain, CompletionHandler<void(bool)>&& completionHandler)
> {
>     ASSERT(RunLoop::isMain());
>     
>-    postTask([this, primaryDomain = isolatedPrimaryDomain(primaryDomain), completionHandler = WTFMove(completionHandler)]() mutable {
>-        bool isPrevalentResource = m_memoryStore ? m_memoryStore->isPrevalentResource(primaryDomain) : false;
>+    postTask([this, domain = domain.isolatedCopy(), completionHandler = WTFMove(completionHandler)]() mutable {
>+        bool isPrevalentResource = m_memoryStore ? m_memoryStore->isPrevalentResource(domain) : false;
>         postTaskReply([isPrevalentResource, completionHandler = WTFMove(completionHandler)]() mutable {
>             completionHandler(isPrevalentResource);
>         });
>     });
> }
>     
>-void WebResourceLoadStatisticsStore::isVeryPrevalentResource(const String& primaryDomain, CompletionHandler<void(bool)>&& completionHandler)
>+void WebResourceLoadStatisticsStore::isVeryPrevalentResource(const RegistrableDomain& domain, CompletionHandler<void(bool)>&& completionHandler)
> {
>     ASSERT(RunLoop::isMain());
>     
>-    postTask([this, primaryDomain = isolatedPrimaryDomain(primaryDomain), completionHandler = WTFMove(completionHandler)]() mutable {
>-        bool isVeryPrevalentResource = m_memoryStore ? m_memoryStore->isVeryPrevalentResource(primaryDomain) : false;
>+    postTask([this, domain = domain.isolatedCopy(), completionHandler = WTFMove(completionHandler)]() mutable {
>+        bool isVeryPrevalentResource = m_memoryStore ? m_memoryStore->isVeryPrevalentResource(domain) : false;
>         postTaskReply([isVeryPrevalentResource, completionHandler = WTFMove(completionHandler)]() mutable {
>             completionHandler(isVeryPrevalentResource);
>         });
>     });
> }
> 
>-void WebResourceLoadStatisticsStore::isRegisteredAsSubresourceUnder(const String& subresource, const String& topFrame, CompletionHandler<void(bool)>&& completionHandler)
>+void WebResourceLoadStatisticsStore::isRegisteredAsSubresourceUnder(const RegistrableDomain& subresourceDomain, const RegistrableDomain& topFrameDomain, CompletionHandler<void(bool)>&& completionHandler)
> {
>     ASSERT(RunLoop::isMain());
> 
>-    postTask([this, subresourcePrimaryDomain = isolatedPrimaryDomain(subresource), topFramePrimaryDomain = isolatedPrimaryDomain(topFrame), completionHandler = WTFMove(completionHandler)]() mutable {
>-        bool isRegisteredAsSubresourceUnder = m_memoryStore ? m_memoryStore->isRegisteredAsSubresourceUnder(subresourcePrimaryDomain, topFramePrimaryDomain) : false;
>+    postTask([this, subresourceDomain = subresourceDomain.isolatedCopy(), topFrameDomain = topFrameDomain.isolatedCopy(), completionHandler = WTFMove(completionHandler)]() mutable {
>+        bool isRegisteredAsSubresourceUnder = m_memoryStore ? m_memoryStore->isRegisteredAsSubresourceUnder(subresourceDomain, topFrameDomain) : false;
>         postTaskReply([isRegisteredAsSubresourceUnder, completionHandler = WTFMove(completionHandler)]() mutable {
>             completionHandler(isRegisteredAsSubresourceUnder);
>         });
>     });
> }
> 
>-void WebResourceLoadStatisticsStore::isRegisteredAsSubFrameUnder(const String& subFrame, const String& topFrame, CompletionHandler<void(bool)>&& completionHandler)
>+void WebResourceLoadStatisticsStore::isRegisteredAsSubFrameUnder(const RegistrableDomain& subFrameDomain, const RegistrableDomain& topFrameDomain, CompletionHandler<void(bool)>&& completionHandler)
> {
>     ASSERT(RunLoop::isMain());
> 
>-    postTask([this, subFramePrimaryDomain = isolatedPrimaryDomain(subFrame), topFramePrimaryDomain = isolatedPrimaryDomain(topFrame), completionHandler = WTFMove(completionHandler)]() mutable {
>-        bool isRegisteredAsSubFrameUnder = m_memoryStore ? m_memoryStore->isRegisteredAsSubFrameUnder(subFramePrimaryDomain, topFramePrimaryDomain) : false;
>+    postTask([this, subFrameDomain = subFrameDomain.isolatedCopy(), topFrameDomain = topFrameDomain.isolatedCopy(), completionHandler = WTFMove(completionHandler)]() mutable {
>+        bool isRegisteredAsSubFrameUnder = m_memoryStore ? m_memoryStore->isRegisteredAsSubFrameUnder(subFrameDomain, topFrameDomain) : false;
>         postTaskReply([isRegisteredAsSubFrameUnder, completionHandler = WTFMove(completionHandler)]() mutable {
>             completionHandler(isRegisteredAsSubFrameUnder);
>         });
>     });
> }
> 
>-void WebResourceLoadStatisticsStore::isRegisteredAsRedirectingTo(const String& hostRedirectedFrom, const String& hostRedirectedTo, CompletionHandler<void(bool)>&& completionHandler)
>+void WebResourceLoadStatisticsStore::isRegisteredAsRedirectingTo(const RegistrableDomain& domainRedirectedFrom, const RegistrableDomain& domainRedirectedTo, CompletionHandler<void(bool)>&& completionHandler)
> {
>     ASSERT(RunLoop::isMain());
> 
>-    postTask([this, hostRedirectedFromPrimaryDomain = isolatedPrimaryDomain(hostRedirectedFrom), hostRedirectedToPrimaryDomain = isolatedPrimaryDomain(hostRedirectedTo), completionHandler = WTFMove(completionHandler)]() mutable {
>-        bool isRegisteredAsRedirectingTo = m_memoryStore ? m_memoryStore->isRegisteredAsRedirectingTo(hostRedirectedFromPrimaryDomain, hostRedirectedToPrimaryDomain) : false;
>+    postTask([this, domainRedirectedFrom = domainRedirectedFrom.isolatedCopy(), domainRedirectedTo = domainRedirectedTo.isolatedCopy(), completionHandler = WTFMove(completionHandler)]() mutable {
>+        bool isRegisteredAsRedirectingTo = m_memoryStore ? m_memoryStore->isRegisteredAsRedirectingTo(domainRedirectedFrom, domainRedirectedTo) : false;
>         postTaskReply([isRegisteredAsRedirectingTo, completionHandler = WTFMove(completionHandler)]() mutable {
>             completionHandler(isRegisteredAsRedirectingTo);
>         });
>     });
> }
> 
>-void WebResourceLoadStatisticsStore::clearPrevalentResource(const String& resourceDomain, CompletionHandler<void()>&& completionHandler)
>+void WebResourceLoadStatisticsStore::clearPrevalentResource(const RegistrableDomain& domain, CompletionHandler<void()>&& completionHandler)
> {
>     ASSERT(RunLoop::isMain());
>     
>-    postTask([this, resourceDomain = isolatedPrimaryDomain(resourceDomain), completionHandler = WTFMove(completionHandler)]() mutable {
>+    postTask([this, domain = domain.isolatedCopy(), completionHandler = WTFMove(completionHandler)]() mutable {
>         if (m_memoryStore)
>-            m_memoryStore->clearPrevalentResource(resourceDomain);
>+            m_memoryStore->clearPrevalentResource(domain);
>         postTaskReply(WTFMove(completionHandler));
>     });
> }
> 
>-void WebResourceLoadStatisticsStore::setGrandfathered(const String& domain, bool value, CompletionHandler<void()>&& completionHandler)
>+void WebResourceLoadStatisticsStore::setGrandfathered(const RegistrableDomain& domain, bool value, CompletionHandler<void()>&& completionHandler)
> {
>     ASSERT(RunLoop::isMain());
> 
>-    postTask([this, primaryDomain = isolatedPrimaryDomain(domain), value, completionHandler = WTFMove(completionHandler)]() mutable {
>+    postTask([this, domain = domain.isolatedCopy(), value, completionHandler = WTFMove(completionHandler)]() mutable {
>         if (m_memoryStore)
>-            m_memoryStore->setGrandfathered(primaryDomain, value);
>+            m_memoryStore->setGrandfathered(domain, value);
>         postTaskReply(WTFMove(completionHandler));
>     });
> }
>     
>-void WebResourceLoadStatisticsStore::isGrandfathered(const String& primaryDomain, CompletionHandler<void(bool)>&& completionHandler)
>+void WebResourceLoadStatisticsStore::isGrandfathered(const RegistrableDomain& domain, CompletionHandler<void(bool)>&& completionHandler)
> {
>     ASSERT(RunLoop::isMain());
> 
>-    postTask([this, completionHandler = WTFMove(completionHandler), primaryDomain = isolatedPrimaryDomain(primaryDomain)]() mutable {
>-        bool isGrandFathered = m_memoryStore ? m_memoryStore->isGrandfathered(primaryDomain) : false;
>+    postTask([this, completionHandler = WTFMove(completionHandler), domain = domain.isolatedCopy()]() mutable {
>+        bool isGrandFathered = m_memoryStore ? m_memoryStore->isGrandfathered(domain) : false;
>         postTaskReply([isGrandFathered, completionHandler = WTFMove(completionHandler)]() mutable {
>             completionHandler(isGrandFathered);
>         });
>     });
> }
> 
>-void WebResourceLoadStatisticsStore::setSubframeUnderTopFrameOrigin(const String& subframe, const String& topFrame, CompletionHandler<void()>&& completionHandler)
>+void WebResourceLoadStatisticsStore::setSubframeUnderTopFrameOrigin(const RegistrableDomain& subFrameDomain, const RegistrableDomain& topFrameDomain, CompletionHandler<void()>&& completionHandler)
> {
>     ASSERT(RunLoop::isMain());
>     
>-    postTask([this, completionHandler = WTFMove(completionHandler), primaryTopFrameDomain = isolatedPrimaryDomain(topFrame), primarySubFrameDomain = isolatedPrimaryDomain(subframe)]() mutable {
>+    postTask([this, completionHandler = WTFMove(completionHandler), subFrameDomain = subFrameDomain.isolatedCopy(), topFrameDomain = topFrameDomain.isolatedCopy()]() mutable {
>         if (m_memoryStore)
>-            m_memoryStore->setSubframeUnderTopFrameOrigin(primarySubFrameDomain, primaryTopFrameDomain);
>+            m_memoryStore->setSubframeUnderTopFrameOrigin(subFrameDomain, topFrameDomain);
>         postTaskReply(WTFMove(completionHandler));
>     });
> }
> 
>-void WebResourceLoadStatisticsStore::setSubresourceUnderTopFrameOrigin(const String& subresource, const String& topFrame, CompletionHandler<void()>&& completionHandler)
>+void WebResourceLoadStatisticsStore::setSubresourceUnderTopFrameOrigin(const RegistrableDomain& subresourceDomain, const RegistrableDomain& topFrameDomain, CompletionHandler<void()>&& completionHandler)
> {
>     ASSERT(RunLoop::isMain());
>     
>-    postTask([this, completionHandler = WTFMove(completionHandler), primaryTopFrameDomain = isolatedPrimaryDomain(topFrame), primarySubresourceDomain = isolatedPrimaryDomain(subresource)]() mutable {
>+    postTask([this, completionHandler = WTFMove(completionHandler), subresourceDomain = subresourceDomain.isolatedCopy(), topFrameDomain = topFrameDomain.isolatedCopy()]() mutable {
>         if (m_memoryStore)
>-            m_memoryStore->setSubresourceUnderTopFrameOrigin(primarySubresourceDomain, primaryTopFrameDomain);
>+            m_memoryStore->setSubresourceUnderTopFrameOrigin(subresourceDomain, topFrameDomain);
>         postTaskReply(WTFMove(completionHandler));
>     });
> }
> 
>-void WebResourceLoadStatisticsStore::setSubresourceUniqueRedirectTo(const String& subresource, const String& hostNameRedirectedTo, CompletionHandler<void()>&& completionHandler)
>+void WebResourceLoadStatisticsStore::setSubresourceUniqueRedirectTo(const RegistrableDomain& subresourceDomain, const RegistrableDomain& domainRedirectedTo, CompletionHandler<void()>&& completionHandler)
> {
>     ASSERT(RunLoop::isMain());
>     
>-    postTask([this, completionHandler = WTFMove(completionHandler), primaryRedirectDomain = isolatedPrimaryDomain(hostNameRedirectedTo), primarySubresourceDomain = isolatedPrimaryDomain(subresource)]() mutable {
>+    postTask([this, completionHandler = WTFMove(completionHandler), subresourceDomain = subresourceDomain.isolatedCopy(), domainRedirectedTo = domainRedirectedTo.isolatedCopy()]() mutable {
>         if (m_memoryStore)
>-            m_memoryStore->setSubresourceUniqueRedirectTo(primarySubresourceDomain, primaryRedirectDomain);
>+            m_memoryStore->setSubresourceUniqueRedirectTo(subresourceDomain, domainRedirectedTo);
>         postTaskReply(WTFMove(completionHandler));
>     });
> }
> 
>-void WebResourceLoadStatisticsStore::setSubresourceUniqueRedirectFrom(const String& subresource, const String& hostNameRedirectedFrom, CompletionHandler<void()>&& completionHandler)
>+void WebResourceLoadStatisticsStore::setSubresourceUniqueRedirectFrom(const RegistrableDomain& subresourceDomain, const RegistrableDomain& domainRedirectedFrom, CompletionHandler<void()>&& completionHandler)
> {
>     ASSERT(RunLoop::isMain());
>     
>-    postTask([this, completionHandler = WTFMove(completionHandler), primaryRedirectDomain = isolatedPrimaryDomain(hostNameRedirectedFrom), primarySubresourceDomain = isolatedPrimaryDomain(subresource)]() mutable {
>+    postTask([this, completionHandler = WTFMove(completionHandler), subresourceDomain = subresourceDomain.isolatedCopy(), domainRedirectedFrom = domainRedirectedFrom.isolatedCopy()]() mutable {
>         if (m_memoryStore)
>-            m_memoryStore->setSubresourceUniqueRedirectFrom(primarySubresourceDomain, primaryRedirectDomain);
>+            m_memoryStore->setSubresourceUniqueRedirectFrom(subresourceDomain, domainRedirectedFrom);
>         postTaskReply(WTFMove(completionHandler));
>     });
> }
> 
>-void WebResourceLoadStatisticsStore::setTopFrameUniqueRedirectTo(const String& topFrameHostName, const String& hostNameRedirectedTo, CompletionHandler<void()>&& completionHandler)
>+void WebResourceLoadStatisticsStore::setTopFrameUniqueRedirectTo(const RegistrableDomain& topFrameDomain, const RegistrableDomain& domainRedirectedTo, CompletionHandler<void()>&& completionHandler)
> {
>     ASSERT(RunLoop::isMain());
>     
>-    postTask([this, completionHandler = WTFMove(completionHandler), topFramePrimaryDomain = isolatedPrimaryDomain(topFrameHostName), primaryRedirectDomain = isolatedPrimaryDomain(hostNameRedirectedTo)]() mutable {
>+    postTask([this, completionHandler = WTFMove(completionHandler), topFrameDomain = topFrameDomain.isolatedCopy(), domainRedirectedTo = domainRedirectedTo.isolatedCopy()]() mutable {
>         if (m_memoryStore)
>-            m_memoryStore->setTopFrameUniqueRedirectTo(topFramePrimaryDomain, primaryRedirectDomain);
>+            m_memoryStore->setTopFrameUniqueRedirectTo(topFrameDomain, domainRedirectedTo);
>         postTaskReply(WTFMove(completionHandler));
>     });
> }
> 
>-void WebResourceLoadStatisticsStore::setTopFrameUniqueRedirectFrom(const String& topFrameHostName, const String& hostNameRedirectedFrom, CompletionHandler<void()>&& completionHandler)
>+void WebResourceLoadStatisticsStore::setTopFrameUniqueRedirectFrom(const RegistrableDomain& topFrameDomain, const RegistrableDomain& domainRedirectedFrom, CompletionHandler<void()>&& completionHandler)
> {
>     ASSERT(RunLoop::isMain());
>     
>-    postTask([this, completionHandler = WTFMove(completionHandler), topFramePrimaryDomain = isolatedPrimaryDomain(topFrameHostName), primaryRedirectDomain = isolatedPrimaryDomain(hostNameRedirectedFrom)]() mutable {
>+    postTask([this, completionHandler = WTFMove(completionHandler), topFrameDomain = topFrameDomain.isolatedCopy(), domainRedirectedFrom = domainRedirectedFrom.isolatedCopy()]() mutable {
>         if (m_memoryStore)
>-            m_memoryStore->setTopFrameUniqueRedirectFrom(topFramePrimaryDomain, primaryRedirectDomain);
>+            m_memoryStore->setTopFrameUniqueRedirectFrom(topFrameDomain, domainRedirectedFrom);
>         postTaskReply(WTFMove(completionHandler));
>     });
> }
>@@ -774,7 +765,7 @@ void WebResourceLoadStatisticsStore::scheduleCookieBlockingUpdate(CompletionHand
>     });
> }
> 
>-void WebResourceLoadStatisticsStore::scheduleCookieBlockingUpdateForDomains(const Vector<String>& domainsToBlock, CompletionHandler<void()>&& completionHandler)
>+void WebResourceLoadStatisticsStore::scheduleCookieBlockingUpdateForDomains(const Vector<RegistrableDomain>& domainsToBlock, CompletionHandler<void()>&& completionHandler)
> {
>     // Helper function used by testing system. Should only be called from the main thread.
>     ASSERT(RunLoop::isMain());
>@@ -790,7 +781,7 @@ void WebResourceLoadStatisticsStore::scheduleCookieBlockingUpdateForDomains(cons
>     });
> }
> 
>-void WebResourceLoadStatisticsStore::scheduleClearBlockingStateForDomains(const Vector<String>& domains, CompletionHandler<void()>&& completionHandler)
>+void WebResourceLoadStatisticsStore::scheduleClearBlockingStateForDomains(const Vector<RegistrableDomain>& domains, CompletionHandler<void()>&& completionHandler)
> {
>     // Helper function used by testing system. Should only be called from the main thread.
>     ASSERT(RunLoop::isMain());
>@@ -885,7 +876,7 @@ void WebResourceLoadStatisticsStore::setCacheMaxAgeCap(Seconds seconds, Completi
>     completionHandler();
> }
> 
>-void WebResourceLoadStatisticsStore::callUpdatePrevalentDomainsToBlockCookiesForHandler(const Vector<String>& domainsToBlock, CompletionHandler<void()>&& completionHandler)
>+void WebResourceLoadStatisticsStore::callUpdatePrevalentDomainsToBlockCookiesForHandler(const Vector<RegistrableDomain>& domainsToBlock, CompletionHandler<void()>&& completionHandler)
> {
>     ASSERT(RunLoop::isMain());
> 
>@@ -895,13 +886,13 @@ void WebResourceLoadStatisticsStore::callUpdatePrevalentDomainsToBlockCookiesFor
>     completionHandler();
> }
> 
>-void WebResourceLoadStatisticsStore::removePrevalentDomains(const Vector<String>& domains)
>+void WebResourceLoadStatisticsStore::removePrevalentDomains(const Vector<RegistrableDomain>& domains)
> {
>     if (m_networkSession)
>         m_networkSession->networkStorageSession().removePrevalentDomains(domains);
> }
> 
>-void WebResourceLoadStatisticsStore::callRemoveDomainsHandler(const Vector<String>& domains)
>+void WebResourceLoadStatisticsStore::callRemoveDomainsHandler(const Vector<RegistrableDomain>& domains)
> {
>     ASSERT(RunLoop::isMain());
> 
>@@ -959,24 +950,24 @@ void WebResourceLoadStatisticsStore::notifyResourceLoadStatisticsProcessed()
>         m_networkSession->notifyResourceLoadStatisticsProcessed();
> }
> 
>-void WebResourceLoadStatisticsStore::deleteWebsiteDataForTopPrivatelyControlledDomainsInAllPersistentDataStores(OptionSet<WebsiteDataType> dataTypes, Vector<String>&& topPrivatelyControlledDomains, bool shouldNotifyPage, CompletionHandler<void(const HashSet<String>&)>&& completionHandler)
>+void WebResourceLoadStatisticsStore::deleteWebsiteDataForRegistrableDomainsInAllPersistentDataStores(OptionSet<WebsiteDataType> dataTypes, Vector<RegistrableDomain>&& domains, bool shouldNotifyPage, CompletionHandler<void(const HashSet<String>&)>&& completionHandler)
> {
>     ASSERT(RunLoop::isMain());
>     
>     if (m_networkSession) {
>-        m_networkSession->deleteWebsiteDataForTopPrivatelyControlledDomainsInAllPersistentDataStores(dataTypes, WTFMove(topPrivatelyControlledDomains), shouldNotifyPage, WTFMove(completionHandler));
>+        m_networkSession->deleteWebsiteDataForRegistrableDomainsInAllPersistentDataStores(dataTypes, WTFMove(domains), shouldNotifyPage, WTFMove(completionHandler));
>         return;
>     }
> 
>     completionHandler({ });
> }
> 
>-void WebResourceLoadStatisticsStore::topPrivatelyControlledDomainsWithWebsiteData(OptionSet<WebsiteDataType> dataTypes, bool shouldNotifyPage, CompletionHandler<void(HashSet<String>&&)>&& completionHandler)
>+void WebResourceLoadStatisticsStore::registrableDomainsWithWebsiteData(OptionSet<WebsiteDataType> dataTypes, bool shouldNotifyPage, CompletionHandler<void(HashSet<RegistrableDomain>&&)>&& completionHandler)
> {
>     ASSERT(RunLoop::isMain());
>     
>     if (m_networkSession) {
>-        m_networkSession->topPrivatelyControlledDomainsWithWebsiteData(dataTypes, shouldNotifyPage, WTFMove(completionHandler));
>+        m_networkSession->registrableDomainsWithWebsiteData(dataTypes, shouldNotifyPage, WTFMove(completionHandler));
>         return;
>     }
> 
>diff --git a/Source/WebKit/NetworkProcess/Classifier/WebResourceLoadStatisticsStore.h b/Source/WebKit/NetworkProcess/Classifier/WebResourceLoadStatisticsStore.h
>index 11c00ca85d169710b6990b419b4438a92ae891dc..2058f78cb94cab50473e7fde2506b8ce95fb6bb7 100644
>--- a/Source/WebKit/NetworkProcess/Classifier/WebResourceLoadStatisticsStore.h
>+++ b/Source/WebKit/NetworkProcess/Classifier/WebResourceLoadStatisticsStore.h
>@@ -30,6 +30,7 @@
> #include "Connection.h"
> #include "StorageAccessStatus.h"
> #include "WebsiteDataType.h"
>+#include <WebCore/RegistrableDomain.h>
> #include <wtf/CompletionHandler.h>
> #include <wtf/RunLoop.h>
> #include <wtf/ThreadSafeRefCounted.h>
>@@ -59,6 +60,22 @@ enum class ShouldGrandfatherStatistics : bool;
> 
> class WebResourceLoadStatisticsStore final : public ThreadSafeRefCounted<WebResourceLoadStatisticsStore, WTF::DestructionThread::Main>, public IPC::MessageReceiver {
> public:
>+    using ResourceLoadStatistics = WebCore::ResourceLoadStatistics;
>+    using RegistrableDomain = WebCore::RegistrableDomain;
>+    using TopFrameDomain = WebCore::RegistrableDomain;
>+    using SubFrameDomain = WebCore::RegistrableDomain;
>+    using SubResourceDomain = WebCore::RegistrableDomain;
>+    using RedirectDomain = WebCore::RegistrableDomain;
>+    using RedirectedFromDomain = WebCore::RegistrableDomain;
>+    using RedirectedToDomain = WebCore::RegistrableDomain;
>+    using NavigatedFromDomain = WebCore::RegistrableDomain;
>+    using NavigatedToDomain = WebCore::RegistrableDomain;
>+    using DomainInNeedOfStorageAccess = WebCore::RegistrableDomain;
>+    using OpenerDomain = WebCore::RegistrableDomain;
>+    using OpenerPageID = uint64_t;
>+    using PageID = uint64_t;
>+    using FrameID = uint64_t;
>+
>     static Ref<WebResourceLoadStatisticsStore> create(NetworkSession& networkSession, const String& resourceLoadStatisticsDirectory)
>     {
>         return adoptRef(*new WebResourceLoadStatisticsStore(networkSession, resourceLoadStatisticsDirectory));
>@@ -75,49 +92,49 @@ public:
>     void setShouldClassifyResourcesBeforeDataRecordsRemoval(bool, CompletionHandler<void()>&&);
>     void setShouldSubmitTelemetry(bool);
> 
>-    void grantStorageAccess(const String& subFrameHost, const String& topFrameHost, uint64_t frameID, uint64_t pageID, bool userWasPromptedNow, CompletionHandler<void(bool)>&&);
>+    void grantStorageAccess(const SubFrameDomain&, const TopFrameDomain&, FrameID, PageID, bool userWasPromptedNow, CompletionHandler<void(bool)>&&);
> 
>     void applicationWillTerminate();
> 
>     void logFrameNavigation(const WebFrameProxy&, const URL& pageURL, const WebCore::ResourceRequest&, const URL& redirectURL);
>-    void logFrameNavigation(const String& targetPrimaryDomain, const String& mainFramePrimaryDomain, const String& sourcePrimaryDomain, const String& targetHost, const String& mainFrameHost, bool isRedirect, bool isMainFrame);
>-    void logUserInteraction(const String& targetPrimaryDomain, CompletionHandler<void()>&&);
>-    void logWebSocketLoading(const String& targetPrimaryDomain, const String& mainFramePrimaryDomain, WallTime lastSeen, CompletionHandler<void()>&&);
>-    void logSubresourceLoading(const String& targetPrimaryDomain, const String& mainFramePrimaryDomain, WallTime lastSeen, CompletionHandler<void()>&&);
>-    void logSubresourceRedirect(const String& sourcePrimaryDomain, const String& targetPrimaryDomain, 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 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 requestStorageAccessGranted(const String& subFrameHost, const String& topFrameHost, uint64_t frameID, uint64_t pageID, bool promptEnabled, CompletionHandler<void(bool)>&&);
>+    void logFrameNavigation(const NavigatedToDomain&, const TopFrameDomain&, const NavigatedFromDomain&, bool isRedirect, bool isMainFrame);
>+    void logUserInteraction(const TopFrameDomain&, CompletionHandler<void()>&&);
>+    void logWebSocketLoading(const SubResourceDomain&, const TopFrameDomain&, WallTime lastSeen, CompletionHandler<void()>&&);
>+    void logSubresourceLoading(const SubResourceDomain&, const TopFrameDomain&, WallTime lastSeen, CompletionHandler<void()>&&);
>+    void logSubresourceRedirect(const RedirectedFromDomain&, const RedirectedToDomain&, CompletionHandler<void()>&&);
>+    void clearUserInteraction(const TopFrameDomain&, CompletionHandler<void()>&&);
>+    void deleteWebsiteDataForRegistrableDomainsInAllPersistentDataStores(OptionSet<WebsiteDataType>, Vector<RegistrableDomain>&&, bool shouldNotifyPage, CompletionHandler<void(const HashSet<String>&)>&&);
>+    void registrableDomainsWithWebsiteData(OptionSet<WebsiteDataType>, bool shouldNotifyPage, CompletionHandler<void(HashSet<RegistrableDomain>&&)>&&);
>+    bool grantStorageAccess(const SubFrameDomain&, const TopFrameDomain&, Optional<FrameID>, PageID);
>+    void hasHadUserInteraction(const RegistrableDomain&, CompletionHandler<void(bool)>&&);
>+    void hasStorageAccess(const SubFrameDomain&, const TopFrameDomain&, Optional<FrameID>, PageID, CompletionHandler<void(bool)>&& callback);
>+    bool hasStorageAccessForFrame(const SubFrameDomain&, const TopFrameDomain&, FrameID, PageID);
>+    void requestStorageAccess(const SubFrameDomain&, const TopFrameDomain&, Optional<FrameID>, PageID, bool promptEnabled, CompletionHandler<void(StorageAccessStatus)>&&);
>+    void requestStorageAccessGranted(const SubFrameDomain&, const TopFrameDomain&, FrameID, PageID, bool promptEnabled, CompletionHandler<void(bool)>&&);
>     void requestUpdate();
>-    void setLastSeen(const String& resourceDomain, Seconds, CompletionHandler<void()>&&);
>-    void setPrevalentResource(const String& resourceDomain, CompletionHandler<void()>&&);
>-    void setVeryPrevalentResource(const String& resourceDomain, CompletionHandler<void()>&&);
>+    void setLastSeen(const RegistrableDomain&, Seconds, CompletionHandler<void()>&&);
>+    void setPrevalentResource(const RegistrableDomain&, CompletionHandler<void()>&&);
>+    void setVeryPrevalentResource(const RegistrableDomain&, CompletionHandler<void()>&&);
>     void dumpResourceLoadStatistics(CompletionHandler<void(String)>&&);
>-    void isPrevalentResource(const String&, CompletionHandler<void(bool)>&&);
>-    void isVeryPrevalentResource(const String&, CompletionHandler<void(bool)>&&);
>-    void isRegisteredAsSubresourceUnder(const String& subresource, const String& topFrame, CompletionHandler<void(bool)>&&);
>-    void isRegisteredAsSubFrameUnder(const String& subFrame, const String& topFrame, CompletionHandler<void(bool)>&&);
>-    void isRegisteredAsRedirectingTo(const String& hostRedirectedFrom, const String& hostRedirectedTo, CompletionHandler<void(bool)>&&);
>-    void clearPrevalentResource(const String&, CompletionHandler<void()>&&);
>-    void setGrandfathered(const String&, bool, CompletionHandler<void()>&&);
>-    void isGrandfathered(const String&, CompletionHandler<void(bool)>&&);
>-    void removePrevalentDomains(const Vector<String>& domainsToBlock);
>+    void isPrevalentResource(const RegistrableDomain&, CompletionHandler<void(bool)>&&);
>+    void isVeryPrevalentResource(const RegistrableDomain&, CompletionHandler<void(bool)>&&);
>+    void isRegisteredAsSubresourceUnder(const SubResourceDomain&, const TopFrameDomain&, CompletionHandler<void(bool)>&&);
>+    void isRegisteredAsSubFrameUnder(const SubFrameDomain&, const TopFrameDomain&, CompletionHandler<void(bool)>&&);
>+    void isRegisteredAsRedirectingTo(const RedirectedFromDomain&, const RedirectedToDomain&, CompletionHandler<void(bool)>&&);
>+    void clearPrevalentResource(const RegistrableDomain&, CompletionHandler<void()>&&);
>+    void setGrandfathered(const RegistrableDomain&, bool, CompletionHandler<void()>&&);
>+    void isGrandfathered(const RegistrableDomain&, CompletionHandler<void(bool)>&&);
>+    void removePrevalentDomains(const Vector<RegistrableDomain>&);
>     void setNotifyPagesWhenDataRecordsWereScanned(bool, CompletionHandler<void()>&&);
>-    void setSubframeUnderTopFrameOrigin(const String& subframe, const String& topFrame, CompletionHandler<void()>&&);
>-    void setSubresourceUnderTopFrameOrigin(const String& subresource, const String& topFrame, CompletionHandler<void()>&&);
>-    void setSubresourceUniqueRedirectTo(const String& subresource, const String& hostNameRedirectedTo, CompletionHandler<void()>&&);
>-    void setSubresourceUniqueRedirectFrom(const String& subresource, const String& hostNameRedirectedFrom, CompletionHandler<void()>&&);
>-    void setTopFrameUniqueRedirectTo(const String& topFrameHostName, const String& hostNameRedirectedTo, CompletionHandler<void()>&&);
>-    void setTopFrameUniqueRedirectFrom(const String& topFrameHostName, const String& hostNameRedirectedFrom, CompletionHandler<void()>&&);
>+    void setSubframeUnderTopFrameOrigin(const SubFrameDomain&, const TopFrameDomain&, CompletionHandler<void()>&&);
>+    void setSubresourceUnderTopFrameOrigin(const SubResourceDomain&, const TopFrameDomain&, CompletionHandler<void()>&&);
>+    void setSubresourceUniqueRedirectTo(const SubResourceDomain&, const RedirectedToDomain&, CompletionHandler<void()>&&);
>+    void setSubresourceUniqueRedirectFrom(const SubResourceDomain&, const RedirectedFromDomain&, CompletionHandler<void()>&&);
>+    void setTopFrameUniqueRedirectTo(const TopFrameDomain&, const RedirectedToDomain&, CompletionHandler<void()>&&);
>+    void setTopFrameUniqueRedirectFrom(const TopFrameDomain&, const RedirectedFromDomain&, CompletionHandler<void()>&&);
>     void scheduleCookieBlockingUpdate(CompletionHandler<void()>&&);
>-    void scheduleCookieBlockingUpdateForDomains(const Vector<String>& domainsToBlock, CompletionHandler<void()>&&);
>-    void scheduleClearBlockingStateForDomains(const Vector<String>& domains, CompletionHandler<void()>&&);
>+    void scheduleCookieBlockingUpdateForDomains(const Vector<RegistrableDomain>&, CompletionHandler<void()>&&);
>+    void scheduleClearBlockingStateForDomains(const Vector<RegistrableDomain>&, CompletionHandler<void()>&&);
>     void scheduleStatisticsAndDataRecordsProcessing(CompletionHandler<void()>&&);
>     void submitTelemetry(CompletionHandler<void()>&&);
>     void scheduleClearInMemoryAndPersistent(ShouldGrandfatherStatistics, CompletionHandler<void()>&&);
>@@ -133,14 +150,14 @@ public:
>     void resetParametersToDefaultValues(CompletionHandler<void()>&&);
> 
>     void setResourceLoadStatisticsDebugMode(bool, CompletionHandler<void()>&&);
>-    void setPrevalentResourceForDebugMode(const String& resourceDomain, CompletionHandler<void()>&&);
>+    void setPrevalentResourceForDebugMode(const RegistrableDomain&, 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 callGrantStorageAccessHandler(const SubFrameDomain&, const TopFrameDomain&, Optional<FrameID>, PageID, CompletionHandler<void(bool)>&&);
>     void removeAllStorageAccess(CompletionHandler<void()>&&);
>-    void callUpdatePrevalentDomainsToBlockCookiesForHandler(const Vector<String>& domainsToBlock, CompletionHandler<void()>&&);
>-    void callRemoveDomainsHandler(const Vector<String>& domains);
>-    void callHasStorageAccessForFrameHandler(const String& resourceDomain, const String& firstPartyDomain, uint64_t frameID, uint64_t pageID, CompletionHandler<void(bool)>&&);
>+    void callUpdatePrevalentDomainsToBlockCookiesForHandler(const Vector<RegistrableDomain>&, CompletionHandler<void()>&&);
>+    void callRemoveDomainsHandler(const Vector<RegistrableDomain>&);
>+    void callHasStorageAccessForFrameHandler(const SubFrameDomain&, const TopFrameDomain&, FrameID, PageID, CompletionHandler<void(bool)>&&);
> 
>     void didCreateNetworkProcess();
> 
>@@ -161,8 +178,8 @@ private:
>     void didReceiveMessage(IPC::Connection&, IPC::Decoder&) override;
> 
>     // IPC message handlers.
>-    void resourceLoadStatisticsUpdated(Vector<WebCore::ResourceLoadStatistics>&& origins);
>-    void requestStorageAccessUnderOpener(String&& primaryDomainInNeedOfStorageAccess, uint64_t openerPageID, String&& openerPrimaryDomain);
>+    void resourceLoadStatisticsUpdated(Vector<ResourceLoadStatistics>&& origins);
>+    void requestStorageAccessUnderOpener(DomainInNeedOfStorageAccess&&, uint64_t openerPageID, OpenerDomain&&);
> 
>     void performDailyTasks();
> 
>diff --git a/Source/WebKit/NetworkProcess/NetworkConnectionToWebProcess.cpp b/Source/WebKit/NetworkProcess/NetworkConnectionToWebProcess.cpp
>index b1c7213275101318b727602355a07614b0b280fa..c300ac10b9a2eab12ed4657528574c9720856035 100644
>--- a/Source/WebKit/NetworkProcess/NetworkConnectionToWebProcess.cpp
>+++ b/Source/WebKit/NetworkProcess/NetworkConnectionToWebProcess.cpp
>@@ -63,6 +63,7 @@
> 
> namespace WebKit {
> using namespace WebCore;
>+using RegistrableDomain = WebCore::RegistrableDomain;
> 
> Ref<NetworkConnectionToWebProcess> NetworkConnectionToWebProcess::create(NetworkProcess& networkProcess, IPC::Connection::Identifier connectionIdentifier)
> {
>@@ -585,7 +586,7 @@ void NetworkConnectionToWebProcess::removeStorageAccessForAllFramesOnPage(PAL::S
>         storageSession->removeStorageAccessForAllFramesOnPage(pageID);
> }
> 
>-void NetworkConnectionToWebProcess::logUserInteraction(PAL::SessionID sessionID, const String& topLevelOrigin)
>+void NetworkConnectionToWebProcess::logUserInteraction(PAL::SessionID sessionID, const RegistrableDomain& domain)
> {
>     ASSERT(sessionID.isValid());
>     if (!sessionID.isValid())
>@@ -593,31 +594,31 @@ void NetworkConnectionToWebProcess::logUserInteraction(PAL::SessionID sessionID,
> 
>     if (auto networkSession = networkProcess().networkSession(sessionID)) {
>         if (auto* resourceLoadStatistics = networkSession->resourceLoadStatistics())
>-            resourceLoadStatistics->logUserInteraction(topLevelOrigin, [] { });
>+            resourceLoadStatistics->logUserInteraction(domain, [] { });
>     }
> }
> 
>-void NetworkConnectionToWebProcess::logWebSocketLoading(PAL::SessionID sessionID, const String& targetPrimaryDomain, const String& mainFramePrimaryDomain, WallTime lastSeen)
>+void NetworkConnectionToWebProcess::logWebSocketLoading(PAL::SessionID sessionID, const RegistrableDomain& targetDomain, const RegistrableDomain& topFrameDomain, WallTime lastSeen)
> {
>     if (auto networkSession = networkProcess().networkSession(sessionID)) {
>         if (auto* resourceLoadStatistics = networkSession->resourceLoadStatistics())
>-            resourceLoadStatistics->logWebSocketLoading(targetPrimaryDomain, mainFramePrimaryDomain, lastSeen, [] { });
>+            resourceLoadStatistics->logWebSocketLoading(targetDomain, topFrameDomain, lastSeen, [] { });
>     }
> }
> 
>-void NetworkConnectionToWebProcess::logSubresourceLoading(PAL::SessionID sessionID, const String& targetPrimaryDomain, const String& mainFramePrimaryDomain, WallTime lastSeen)
>+void NetworkConnectionToWebProcess::logSubresourceLoading(PAL::SessionID sessionID, const RegistrableDomain& targetDomain, const RegistrableDomain& topFrameDomain, WallTime lastSeen)
> {
>     if (auto networkSession = networkProcess().networkSession(sessionID)) {
>         if (auto* resourceLoadStatistics = networkSession->resourceLoadStatistics())
>-            resourceLoadStatistics->logSubresourceLoading(targetPrimaryDomain, mainFramePrimaryDomain, lastSeen, [] { });
>+            resourceLoadStatistics->logSubresourceLoading(targetDomain, topFrameDomain, lastSeen, [] { });
>     }
> }
> 
>-void NetworkConnectionToWebProcess::logSubresourceRedirect(PAL::SessionID sessionID, const String& sourcePrimaryDomain, const String& targetPrimaryDomain)
>+void NetworkConnectionToWebProcess::logSubresourceRedirect(PAL::SessionID sessionID, const RegistrableDomain& sourceDomain, const RegistrableDomain& targetDomain)
> {
>     if (auto networkSession = networkProcess().networkSession(sessionID)) {
>         if (auto* resourceLoadStatistics = networkSession->resourceLoadStatistics())
>-            resourceLoadStatistics->logSubresourceRedirect(sourcePrimaryDomain, targetPrimaryDomain, [] { });
>+            resourceLoadStatistics->logSubresourceRedirect(sourceDomain, targetDomain, [] { });
>     }
> }
> 
>@@ -632,14 +633,14 @@ void NetworkConnectionToWebProcess::requestResourceLoadStatisticsUpdate()
>     }
> }
> 
>-void NetworkConnectionToWebProcess::hasStorageAccess(PAL::SessionID sessionID, const String& subFrameHost, const String& topFrameHost, uint64_t frameID, uint64_t pageID, CompletionHandler<void(bool)>&& completionHandler)
>+void NetworkConnectionToWebProcess::hasStorageAccess(PAL::SessionID sessionID, const RegistrableDomain& subFrameDomain, const RegistrableDomain& topFrameDomain, uint64_t frameID, uint64_t pageID, CompletionHandler<void(bool)>&& completionHandler)
> {
>-    networkProcess().hasStorageAccess(sessionID, subFrameHost, topFrameHost, frameID, pageID, WTFMove(completionHandler));
>+    networkProcess().hasStorageAccess(sessionID, subFrameDomain, topFrameDomain, frameID, pageID, WTFMove(completionHandler));
> }
> 
>-void NetworkConnectionToWebProcess::requestStorageAccess(PAL::SessionID sessionID, const String& subFrameHost, const String& topFrameHost, uint64_t frameID, uint64_t pageID, bool promptEnabled, CompletionHandler<void(bool)>&& completionHandler)
>+void NetworkConnectionToWebProcess::requestStorageAccess(PAL::SessionID sessionID, const RegistrableDomain& subFrameDomain, const RegistrableDomain& topFrameDomain, uint64_t frameID, uint64_t pageID, bool promptEnabled, CompletionHandler<void(bool)>&& completionHandler)
> {
>-    networkProcess().requestStorageAccessGranted(sessionID, subFrameHost, topFrameHost, frameID, pageID, promptEnabled, WTFMove(completionHandler));
>+    networkProcess().requestStorageAccessGranted(sessionID, subFrameDomain, topFrameDomain, frameID, pageID, promptEnabled, WTFMove(completionHandler));
> }
> #endif
> 
>diff --git a/Source/WebKit/NetworkProcess/NetworkConnectionToWebProcess.h b/Source/WebKit/NetworkProcess/NetworkConnectionToWebProcess.h
>index f5618e647d6d997fc9e51c7d9522cc4d8a84ac82..97ea3358d9405d0e9d7937e1e6343fcbff8ebcf0 100644
>--- a/Source/WebKit/NetworkProcess/NetworkConnectionToWebProcess.h
>+++ b/Source/WebKit/NetworkProcess/NetworkConnectionToWebProcess.h
>@@ -33,6 +33,7 @@
> #include "NetworkMDNSRegister.h"
> #include "NetworkRTCProvider.h"
> #include <WebCore/NetworkLoadInformation.h>
>+#include <WebCore/RegistrableDomain.h>
> #include <wtf/RefCounted.h>
> 
> namespace PAL {
>@@ -64,6 +65,8 @@ struct DataKey;
> 
> class NetworkConnectionToWebProcess : public RefCounted<NetworkConnectionToWebProcess>, IPC::Connection::Client {
> public:
>+    using RegistrableDomain = WebCore::RegistrableDomain;
>+
>     static Ref<NetworkConnectionToWebProcess> create(NetworkProcess&, IPC::Connection::Identifier);
>     virtual ~NetworkConnectionToWebProcess();
> 
>@@ -199,13 +202,13 @@ 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 logWebSocketLoading(PAL::SessionID, const String& targetPrimaryDomain, const String& mainFramePrimaryDomain, WallTime lastSeen);
>-    void logSubresourceLoading(PAL::SessionID, const String& targetPrimaryDomain, const String& mainFramePrimaryDomain, WallTime lastSeen);
>-    void logSubresourceRedirect(PAL::SessionID, const String& sourcePrimaryDomain, const String& targetPrimaryDomain);
>+    void logUserInteraction(PAL::SessionID, const RegistrableDomain&);
>+    void logWebSocketLoading(PAL::SessionID, const RegistrableDomain& targetDomain, const RegistrableDomain& topFrameDomain, WallTime lastSeen);
>+    void logSubresourceLoading(PAL::SessionID, const RegistrableDomain& targetDomain, const RegistrableDomain& topFrameDomain, WallTime lastSeen);
>+    void logSubresourceRedirect(PAL::SessionID, const RegistrableDomain& sourceDomain, const RegistrableDomain& targetDomain);
>     void requestResourceLoadStatisticsUpdate();
>-    void hasStorageAccess(PAL::SessionID, const String& subFrameHost, const String& topFrameHost, uint64_t frameID, uint64_t pageID, CompletionHandler<void(bool)>&&);
>-    void requestStorageAccess(PAL::SessionID, const String& subFrameHost, const String& topFrameHost, uint64_t frameID, uint64_t pageID, bool prompt, CompletionHandler<void(bool)>&&);
>+    void hasStorageAccess(PAL::SessionID, const RegistrableDomain& subFrameDomain, const RegistrableDomain& topFrameDomain, uint64_t frameID, uint64_t pageID, CompletionHandler<void(bool)>&&);
>+    void requestStorageAccess(PAL::SessionID, const RegistrableDomain& subFrameDomain, const RegistrableDomain& topFrameDomain, uint64_t frameID, uint64_t pageID, bool prompt, CompletionHandler<void(bool)>&&);
> #endif
> 
>     void addOriginAccessWhitelistEntry(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 3f1613b7cf53fb366884918feb21c3fdcbd8135e..bcf89441bfcad96b0254cb98a77b8fe996c78fa3 100644
>--- a/Source/WebKit/NetworkProcess/NetworkConnectionToWebProcess.messages.in
>+++ b/Source/WebKit/NetworkProcess/NetworkConnectionToWebProcess.messages.in
>@@ -58,13 +58,13 @@ messages -> NetworkConnectionToWebProcess LegacyReceiver {
> #if ENABLE(RESOURCE_LOAD_STATISTICS)
>     RemoveStorageAccessForFrame(PAL::SessionID sessionID, uint64_t frameID, uint64_t pageID);
>     RemoveStorageAccessForAllFramesOnPage(PAL::SessionID sessionID, uint64_t pageID);
>-    LogUserInteraction(PAL::SessionID sessionID, String topLevelOrigin)
>-    LogWebSocketLoading(PAL::SessionID sessionID, String targetPrimaryDomain, String mainFramePrimaryDomain, WallTime lastSeen)
>-    LogSubresourceLoading(PAL::SessionID sessionID, String targetPrimaryDomain, String mainFramePrimaryDomain, WallTime lastSeen)
>-    LogSubresourceRedirect(PAL::SessionID sessionID, String sourcePrimaryDomain, String targetPrimaryDomain)
>+    LogUserInteraction(PAL::SessionID sessionID, WebCore::RegistrableDomain domain)
>+    LogWebSocketLoading(PAL::SessionID sessionID, WebCore::RegistrableDomain targetDomain, WebCore::RegistrableDomain topFrameDomain, WallTime lastSeen)
>+    LogSubresourceLoading(PAL::SessionID sessionID, WebCore::RegistrableDomain targetDomain, WebCore::RegistrableDomain topFrameDomain, WallTime lastSeen)
>+    LogSubresourceRedirect(PAL::SessionID sessionID, WebCore::RegistrableDomain sourceDomain, WebCore::RegistrableDomain targetDomain)
>     RequestResourceLoadStatisticsUpdate();
>-    HasStorageAccess(PAL::SessionID sessionID, String subFrameHost, String topFrameHost, uint64_t frameID, uint64_t pageID) -> (bool hasStorageAccess) Async
>-    RequestStorageAccess(PAL::SessionID sessionID, String subFrameHost, String topFrameHost, uint64_t frameID, uint64_t pageID, bool prompt) -> (bool accessGranted) Async
>+    HasStorageAccess(PAL::SessionID sessionID, WebCore::RegistrableDomain subFrameDomain, WebCore::RegistrableDomain topFrameDomain, uint64_t frameID, uint64_t pageID) -> (bool hasStorageAccess) Async
>+    RequestStorageAccess(PAL::SessionID sessionID, WebCore::RegistrableDomain subFrameDomain, WebCore::RegistrableDomain topFrameDomain, uint64_t frameID, uint64_t pageID, bool prompt) -> (bool accessGranted) Async
> #endif
> 
>     AddOriginAccessWhitelistEntry(String sourceOrigin, String destinationProtocol, String destinationHost, bool allowDestinationSubdomains);
>diff --git a/Source/WebKit/NetworkProcess/NetworkProcess.cpp b/Source/WebKit/NetworkProcess/NetworkProcess.cpp
>index 9f1f000d98d7ba73d24c181fb41be14b5835e2b6..63881349bbb52f552e3aa1f7cad485467e9a157c 100644
>--- a/Source/WebKit/NetworkProcess/NetworkProcess.cpp
>+++ b/Source/WebKit/NetworkProcess/NetworkProcess.cpp
>@@ -577,18 +577,18 @@ void NetworkProcess::dumpResourceLoadStatistics(PAL::SessionID sessionID, Comple
>     }
> }
> 
>-void NetworkProcess::updatePrevalentDomainsToBlockCookiesFor(PAL::SessionID sessionID, const Vector<String>& domainsToBlock, CompletionHandler<void()>&& completionHandler)
>+void NetworkProcess::updatePrevalentDomainsToBlockCookiesFor(PAL::SessionID sessionID, const Vector<RegistrableDomain>& domainsToBlock, CompletionHandler<void()>&& completionHandler)
> {
>     if (auto* networkStorageSession = storageSession(sessionID))
>         networkStorageSession->setPrevalentDomainsToBlockCookiesFor(domainsToBlock);
>     completionHandler();
> }
> 
>-void NetworkProcess::isGrandfathered(PAL::SessionID sessionID, const String& targetPrimaryDomain, CompletionHandler<void(bool)>&& completionHandler)
>+void NetworkProcess::isGrandfathered(PAL::SessionID sessionID, const RegistrableDomain& domain, CompletionHandler<void(bool)>&& completionHandler)
> {
>     if (auto* networkSession = this->networkSession(sessionID)) {
>         if (auto* resourceLoadStatistics = networkSession->resourceLoadStatistics())
>-            resourceLoadStatistics->isGrandfathered(targetPrimaryDomain, WTFMove(completionHandler));
>+            resourceLoadStatistics->isGrandfathered(domain, WTFMove(completionHandler));
>         else
>             completionHandler(false);
>     } else {
>@@ -597,11 +597,11 @@ void NetworkProcess::isGrandfathered(PAL::SessionID sessionID, const String& tar
>     }
> }
> 
>-void NetworkProcess::isPrevalentResource(PAL::SessionID sessionID, const String& resourceDomain, CompletionHandler<void(bool)>&& completionHandler)
>+void NetworkProcess::isPrevalentResource(PAL::SessionID sessionID, const RegistrableDomain& domain, CompletionHandler<void(bool)>&& completionHandler)
> {
>     if (auto* networkSession = this->networkSession(sessionID)) {
>         if (auto* resourceLoadStatistics = networkSession->resourceLoadStatistics())
>-            resourceLoadStatistics->isPrevalentResource(resourceDomain, WTFMove(completionHandler));
>+            resourceLoadStatistics->isPrevalentResource(domain, WTFMove(completionHandler));
>         else
>             completionHandler(false);
>     } else {
>@@ -610,11 +610,11 @@ void NetworkProcess::isPrevalentResource(PAL::SessionID sessionID, const String&
>     }
> }
> 
>-void NetworkProcess::isVeryPrevalentResource(PAL::SessionID sessionID, const String& resourceDomain, CompletionHandler<void(bool)>&& completionHandler)
>+void NetworkProcess::isVeryPrevalentResource(PAL::SessionID sessionID, const RegistrableDomain& domain, CompletionHandler<void(bool)>&& completionHandler)
> {
>     if (auto* networkSession = this->networkSession(sessionID)) {
>         if (auto* resourceLoadStatistics = networkSession->resourceLoadStatistics())
>-            resourceLoadStatistics->isVeryPrevalentResource(resourceDomain, WTFMove(completionHandler));
>+            resourceLoadStatistics->isVeryPrevalentResource(domain, WTFMove(completionHandler));
>         else
>             completionHandler(false);
>     } else {
>@@ -630,11 +630,11 @@ void NetworkProcess::setAgeCapForClientSideCookies(PAL::SessionID sessionID, Opt
>     completionHandler();
> }
> 
>-void NetworkProcess::setGrandfathered(PAL::SessionID sessionID, const String& resourceDomain, bool isGrandfathered, CompletionHandler<void()>&& completionHandler)
>+void NetworkProcess::setGrandfathered(PAL::SessionID sessionID, const RegistrableDomain& domain, bool isGrandfathered, CompletionHandler<void()>&& completionHandler)
> {
>     if (auto* networkSession = this->networkSession(sessionID)) {
>         if (auto* resourceLoadStatistics = networkSession->resourceLoadStatistics())
>-            resourceLoadStatistics->setGrandfathered(resourceDomain, isGrandfathered, WTFMove(completionHandler));
>+            resourceLoadStatistics->setGrandfathered(domain, isGrandfathered, WTFMove(completionHandler));
>         else
>             completionHandler();
>     } else {
>@@ -643,11 +643,11 @@ void NetworkProcess::setGrandfathered(PAL::SessionID sessionID, const String& re
>     }
> }
> 
>-void NetworkProcess::setPrevalentResource(PAL::SessionID sessionID, const String& resourceDomain, CompletionHandler<void()>&& completionHandler)
>+void NetworkProcess::setPrevalentResource(PAL::SessionID sessionID, const RegistrableDomain& domain, CompletionHandler<void()>&& completionHandler)
> {
>     if (auto* networkSession = this->networkSession(sessionID)) {
>         if (auto* resourceLoadStatistics = networkSession->resourceLoadStatistics())
>-            resourceLoadStatistics->setPrevalentResource(resourceDomain, WTFMove(completionHandler));
>+            resourceLoadStatistics->setPrevalentResource(domain, WTFMove(completionHandler));
>         else
>             completionHandler();
>     } else {
>@@ -656,11 +656,11 @@ void NetworkProcess::setPrevalentResource(PAL::SessionID sessionID, const String
>     }
> }
> 
>-void NetworkProcess::setPrevalentResourceForDebugMode(PAL::SessionID sessionID, String resourceDomain, CompletionHandler<void()>&& completionHandler)
>+void NetworkProcess::setPrevalentResourceForDebugMode(PAL::SessionID sessionID, const RegistrableDomain& domain, CompletionHandler<void()>&& completionHandler)
> {
>     if (auto* networkSession = this->networkSession(sessionID)) {
>         if (auto* resourceLoadStatistics = networkSession->resourceLoadStatistics())
>-            resourceLoadStatistics->setPrevalentResourceForDebugMode(resourceDomain, WTFMove(completionHandler));
>+            resourceLoadStatistics->setPrevalentResourceForDebugMode(domain, WTFMove(completionHandler));
>         else
>             completionHandler();
>     } else {
>@@ -669,11 +669,11 @@ void NetworkProcess::setPrevalentResourceForDebugMode(PAL::SessionID sessionID,
>     }
> }
> 
>-void NetworkProcess::setVeryPrevalentResource(PAL::SessionID sessionID, const String& resourceDomain, CompletionHandler<void()>&& completionHandler)
>+void NetworkProcess::setVeryPrevalentResource(PAL::SessionID sessionID, const RegistrableDomain& domain, CompletionHandler<void()>&& completionHandler)
> {
>     if (auto* networkSession = this->networkSession(sessionID)) {
>         if (auto* resourceLoadStatistics = networkSession->resourceLoadStatistics())
>-            resourceLoadStatistics->setVeryPrevalentResource(resourceDomain, WTFMove(completionHandler));
>+            resourceLoadStatistics->setVeryPrevalentResource(domain, WTFMove(completionHandler));
>         else
>             completionHandler();
>     } else {
>@@ -682,11 +682,11 @@ void NetworkProcess::setVeryPrevalentResource(PAL::SessionID sessionID, const St
>     }
> }
> 
>-void NetworkProcess::clearPrevalentResource(PAL::SessionID sessionID, const String& resourceDomain, CompletionHandler<void()>&& completionHandler)
>+void NetworkProcess::clearPrevalentResource(PAL::SessionID sessionID, const RegistrableDomain& domain, CompletionHandler<void()>&& completionHandler)
> {
>     if (auto* networkSession = this->networkSession(sessionID)) {
>         if (auto* resourceLoadStatistics = networkSession->resourceLoadStatistics())
>-            resourceLoadStatistics->clearPrevalentResource(resourceDomain, WTFMove(completionHandler));
>+            resourceLoadStatistics->clearPrevalentResource(domain, WTFMove(completionHandler));
>         else
>             completionHandler();
>     } else {
>@@ -789,11 +789,11 @@ void NetworkProcess::setNotifyPagesWhenTelemetryWasCaptured(PAL::SessionID sessi
>     }
> }
> 
>-void NetworkProcess::setSubframeUnderTopFrameOrigin(PAL::SessionID sessionID, String subframe, String topFrame, CompletionHandler<void()>&& completionHandler)
>+void NetworkProcess::setSubframeUnderTopFrameOrigin(PAL::SessionID sessionID, const RegistrableDomain& subFrameDomain, const RegistrableDomain& topFrameDomain, CompletionHandler<void()>&& completionHandler)
> {
>     if (auto* networkSession = this->networkSession(sessionID)) {
>         if (auto* resourceLoadStatistics = networkSession->resourceLoadStatistics())
>-            resourceLoadStatistics->setSubframeUnderTopFrameOrigin(subframe, topFrame, WTFMove(completionHandler));
>+            resourceLoadStatistics->setSubframeUnderTopFrameOrigin(subFrameDomain, topFrameDomain, WTFMove(completionHandler));
>         else
>             completionHandler();
>     } else {
>@@ -802,11 +802,11 @@ void NetworkProcess::setSubframeUnderTopFrameOrigin(PAL::SessionID sessionID, St
>     }
> }
> 
>-void NetworkProcess::isRegisteredAsRedirectingTo(PAL::SessionID sessionID, const String& redirectedFrom, const String& redirectedTo, CompletionHandler<void(bool)>&& completionHandler)
>+void NetworkProcess::isRegisteredAsRedirectingTo(PAL::SessionID sessionID, const RegistrableDomain& domainRedirectedFrom, const RegistrableDomain& domainRedirectedTo, CompletionHandler<void(bool)>&& completionHandler)
> {
>     if (auto* networkSession = this->networkSession(sessionID)) {
>         if (auto* resourceLoadStatistics = networkSession->resourceLoadStatistics())
>-            resourceLoadStatistics->isRegisteredAsRedirectingTo(redirectedFrom, redirectedTo, WTFMove(completionHandler));
>+            resourceLoadStatistics->isRegisteredAsRedirectingTo(domainRedirectedFrom, domainRedirectedTo, WTFMove(completionHandler));
>         else
>             completionHandler(false);
>     } else {
>@@ -815,11 +815,11 @@ void NetworkProcess::isRegisteredAsRedirectingTo(PAL::SessionID sessionID, const
>     }
> }
> 
>-void NetworkProcess::isRegisteredAsSubFrameUnder(PAL::SessionID sessionID, const String& subframe, const String& topFrame, CompletionHandler<void(bool)>&& completionHandler)
>+void NetworkProcess::isRegisteredAsSubFrameUnder(PAL::SessionID sessionID, const RegistrableDomain& subFrameDomain, const RegistrableDomain& topFrameDomain, CompletionHandler<void(bool)>&& completionHandler)
> {
>     if (auto* networkSession = this->networkSession(sessionID)) {
>         if (auto* resourceLoadStatistics = networkSession->resourceLoadStatistics())
>-            resourceLoadStatistics->isRegisteredAsSubFrameUnder(subframe, topFrame, WTFMove(completionHandler));
>+            resourceLoadStatistics->isRegisteredAsSubFrameUnder(subFrameDomain, topFrameDomain, WTFMove(completionHandler));
>         else
>             completionHandler(false);
>     } else {
>@@ -828,11 +828,11 @@ void NetworkProcess::isRegisteredAsSubFrameUnder(PAL::SessionID sessionID, const
>     }
> }
> 
>-void NetworkProcess::setSubresourceUnderTopFrameOrigin(PAL::SessionID sessionID, String subresource, String topFrame, CompletionHandler<void()>&& completionHandler)
>+void NetworkProcess::setSubresourceUnderTopFrameOrigin(PAL::SessionID sessionID, const RegistrableDomain& subresourceDomain, const RegistrableDomain& topFrameDomain, CompletionHandler<void()>&& completionHandler)
> {
>     if (auto* networkSession = this->networkSession(sessionID)) {
>         if (auto* resourceLoadStatistics = networkSession->resourceLoadStatistics())
>-            resourceLoadStatistics->setSubresourceUnderTopFrameOrigin(subresource, topFrame, WTFMove(completionHandler));
>+            resourceLoadStatistics->setSubresourceUnderTopFrameOrigin(subresourceDomain, topFrameDomain, WTFMove(completionHandler));
>         else
>             completionHandler();
>     } else {
>@@ -841,11 +841,11 @@ void NetworkProcess::setSubresourceUnderTopFrameOrigin(PAL::SessionID sessionID,
>     }
> }
> 
>-void NetworkProcess::setSubresourceUniqueRedirectTo(PAL::SessionID sessionID, String subresource, String hostNameRedirectedTo, CompletionHandler<void()>&& completionHandler)
>+void NetworkProcess::setSubresourceUniqueRedirectTo(PAL::SessionID sessionID, const RegistrableDomain& subresourceDomain, const RegistrableDomain& domainRedirectedTo, CompletionHandler<void()>&& completionHandler)
> {
>     if (auto* networkSession = this->networkSession(sessionID)) {
>         if (auto* resourceLoadStatistics = networkSession->resourceLoadStatistics())
>-            resourceLoadStatistics->setSubresourceUniqueRedirectTo(subresource, hostNameRedirectedTo, WTFMove(completionHandler));
>+            resourceLoadStatistics->setSubresourceUniqueRedirectTo(subresourceDomain, domainRedirectedTo, WTFMove(completionHandler));
>         else
>             completionHandler();
>     } else {
>@@ -854,11 +854,11 @@ void NetworkProcess::setSubresourceUniqueRedirectTo(PAL::SessionID sessionID, St
>     }
> }
> 
>-void NetworkProcess::setSubresourceUniqueRedirectFrom(PAL::SessionID sessionID, String subresource, String hostNameRedirectedFrom, CompletionHandler<void()>&& completionHandler)
>+void NetworkProcess::setSubresourceUniqueRedirectFrom(PAL::SessionID sessionID, const RegistrableDomain& subresourceDomain, const RegistrableDomain& domainRedirectedFrom, CompletionHandler<void()>&& completionHandler)
> {
>     if (auto* networkSession = this->networkSession(sessionID)) {
>         if (auto* resourceLoadStatistics = networkSession->resourceLoadStatistics())
>-            resourceLoadStatistics->setSubresourceUniqueRedirectFrom(subresource, hostNameRedirectedFrom, WTFMove(completionHandler));
>+            resourceLoadStatistics->setSubresourceUniqueRedirectFrom(subresourceDomain, domainRedirectedFrom, WTFMove(completionHandler));
>         else
>             completionHandler();
>     } else {
>@@ -867,11 +867,11 @@ void NetworkProcess::setSubresourceUniqueRedirectFrom(PAL::SessionID sessionID,
>     }
> }
> 
>-void NetworkProcess::isRegisteredAsSubresourceUnder(PAL::SessionID sessionID, const String& subresource, const String& topFrame, CompletionHandler<void(bool)>&& completionHandler)
>+void NetworkProcess::isRegisteredAsSubresourceUnder(PAL::SessionID sessionID, const RegistrableDomain& subresourceDomain, const RegistrableDomain& topFrameDomain, CompletionHandler<void(bool)>&& completionHandler)
> {
>     if (auto* networkSession = this->networkSession(sessionID)) {
>         if (auto* resourceLoadStatistics = networkSession->resourceLoadStatistics())
>-            resourceLoadStatistics->isRegisteredAsSubresourceUnder(subresource, topFrame, WTFMove(completionHandler));
>+            resourceLoadStatistics->isRegisteredAsSubresourceUnder(subresourceDomain, topFrameDomain, WTFMove(completionHandler));
>         else
>             completionHandler(false);
>     } else {
>@@ -880,11 +880,11 @@ void NetworkProcess::isRegisteredAsSubresourceUnder(PAL::SessionID sessionID, co
>     }
> }
> 
>-void NetworkProcess::setTopFrameUniqueRedirectTo(PAL::SessionID sessionID, String topFrameHostName, String hostNameRedirectedTo, CompletionHandler<void()>&& completionHandler)
>+void NetworkProcess::setTopFrameUniqueRedirectTo(PAL::SessionID sessionID, const RegistrableDomain& topFrameDomain, const RegistrableDomain& domainRedirectedTo, CompletionHandler<void()>&& completionHandler)
> {
>     if (auto* networkSession = this->networkSession(sessionID)) {
>         if (auto* resourceLoadStatistics = networkSession->resourceLoadStatistics())
>-            resourceLoadStatistics->setTopFrameUniqueRedirectTo(topFrameHostName, hostNameRedirectedTo, WTFMove(completionHandler));
>+            resourceLoadStatistics->setTopFrameUniqueRedirectTo(topFrameDomain, domainRedirectedTo, WTFMove(completionHandler));
>         else
>             completionHandler();
>     } else {
>@@ -893,11 +893,11 @@ void NetworkProcess::setTopFrameUniqueRedirectTo(PAL::SessionID sessionID, Strin
>     }
> }
> 
>-void NetworkProcess::setTopFrameUniqueRedirectFrom(PAL::SessionID sessionID, String topFrameHostName, String hostNameRedirectedFrom, CompletionHandler<void()>&& completionHandler)
>+void NetworkProcess::setTopFrameUniqueRedirectFrom(PAL::SessionID sessionID, const RegistrableDomain& topFrameDomain, const RegistrableDomain& domainRedirectedFrom, CompletionHandler<void()>&& completionHandler)
> {
>     if (auto* networkSession = this->networkSession(sessionID)) {
>         if (auto* resourceLoadStatistics = networkSession->resourceLoadStatistics())
>-            resourceLoadStatistics->setTopFrameUniqueRedirectFrom(topFrameHostName, hostNameRedirectedFrom, WTFMove(completionHandler));
>+            resourceLoadStatistics->setTopFrameUniqueRedirectFrom(topFrameDomain, domainRedirectedFrom, WTFMove(completionHandler));
>         else
>             completionHandler();
>     } else {
>@@ -907,11 +907,11 @@ void NetworkProcess::setTopFrameUniqueRedirectFrom(PAL::SessionID sessionID, Str
> }
>     
>     
>-void NetworkProcess::setLastSeen(PAL::SessionID sessionID, const String& resourceDomain, Seconds seconds, CompletionHandler<void()>&& completionHandler)
>+void NetworkProcess::setLastSeen(PAL::SessionID sessionID, const RegistrableDomain& domain, Seconds seconds, CompletionHandler<void()>&& completionHandler)
> {
>     if (auto* networkSession = this->networkSession(sessionID)) {
>         if (auto* resourceLoadStatistics = networkSession->resourceLoadStatistics())
>-            resourceLoadStatistics->setLastSeen(resourceDomain, seconds, WTFMove(completionHandler));
>+            resourceLoadStatistics->setLastSeen(domain, seconds, WTFMove(completionHandler));
>         else
>             completionHandler();
>     } else {
>@@ -920,11 +920,11 @@ void NetworkProcess::setLastSeen(PAL::SessionID sessionID, const String& resourc
>     }
> }
> 
>-void NetworkProcess::hasStorageAccessForFrame(PAL::SessionID sessionID, const String& resourceDomain, const String& firstPartyDomain, uint64_t frameID, uint64_t pageID, CompletionHandler<void(bool)>&& completionHandler)
>+void NetworkProcess::hasStorageAccessForFrame(PAL::SessionID sessionID, const RegistrableDomain& subFrameDomain, const RegistrableDomain& topFrameDomain, uint64_t frameID, uint64_t pageID, CompletionHandler<void(bool)>&& completionHandler)
> {
>     bool hasStorageAccess = false;
>     if (auto* networkStorageSession = storageSession(sessionID))
>-        hasStorageAccess = networkStorageSession->hasStorageAccess(resourceDomain, firstPartyDomain, frameID, pageID);
>+        hasStorageAccess = networkStorageSession->hasStorageAccess(subFrameDomain, topFrameDomain, frameID, pageID);
>     else
>         ASSERT_NOT_REACHED();
> 
>@@ -941,11 +941,11 @@ void NetworkProcess::getAllStorageAccessEntries(PAL::SessionID sessionID, Comple
>     }
> }
> 
>-void NetworkProcess::hasStorageAccess(PAL::SessionID sessionID, const String& resourceDomain, const String& firstPartyDomain, Optional<uint64_t> frameID, uint64_t pageID, CompletionHandler<void(bool)>&& completionHandler)
>+void NetworkProcess::hasStorageAccess(PAL::SessionID sessionID, const RegistrableDomain& subFrameDomain, const RegistrableDomain& topFrameDomain, 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));
>+            resourceLoadStatistics->hasStorageAccess(subFrameDomain, topFrameDomain, frameID, pageID, WTFMove(completionHandler));
>         else
>             completionHandler(false);
>     } else {
>@@ -954,11 +954,11 @@ void NetworkProcess::hasStorageAccess(PAL::SessionID sessionID, const String& re
>     }
> }
> 
>-void NetworkProcess::requestStorageAccess(PAL::SessionID sessionID, const String& resourceDomain, const String& firstPartyDomain, Optional<uint64_t> frameID, uint64_t pageID, bool promptEnabled, CompletionHandler<void(StorageAccessStatus)>&& completionHandler)
>+void NetworkProcess::requestStorageAccess(PAL::SessionID sessionID, const RegistrableDomain& subFrameDomain, const RegistrableDomain& topFrameDomain, Optional<uint64_t> frameID, uint64_t pageID, bool promptEnabled, CompletionHandler<void(StorageAccessStatus)>&& completionHandler)
> {
>     if (auto* networkSession = this->networkSession(sessionID)) {
>         if (auto* resourceLoadStatistics = networkSession->resourceLoadStatistics())
>-            resourceLoadStatistics->requestStorageAccess(resourceDomain, firstPartyDomain, frameID.value(), pageID, promptEnabled, WTFMove(completionHandler));
>+            resourceLoadStatistics->requestStorageAccess(subFrameDomain, topFrameDomain, frameID.value(), pageID, promptEnabled, WTFMove(completionHandler));
>         else
>             completionHandler(StorageAccessStatus::CannotRequestAccess);
>     } else {
>@@ -967,11 +967,11 @@ void NetworkProcess::requestStorageAccess(PAL::SessionID sessionID, const String
>     }
> }
> 
>-void NetworkProcess::requestStorageAccessGranted(PAL::SessionID sessionID, const String& subFrameHost, const String& topFrameHost, uint64_t frameID, uint64_t pageID, bool promptEnabled, CompletionHandler<void(bool)>&& completionHandler)
>+void NetworkProcess::requestStorageAccessGranted(PAL::SessionID sessionID, const RegistrableDomain& subFrameDomain, const RegistrableDomain& topFrameDomain, uint64_t frameID, uint64_t pageID, bool promptEnabled, CompletionHandler<void(bool)>&& completionHandler)
> {
>     if (auto* networkSession = this->networkSession(sessionID)) {
>         if (auto* resourceLoadStatistics = networkSession->resourceLoadStatistics())
>-            resourceLoadStatistics->requestStorageAccessGranted(subFrameHost, topFrameHost, frameID, pageID, promptEnabled, WTFMove(completionHandler));
>+            resourceLoadStatistics->requestStorageAccessGranted(subFrameDomain, topFrameDomain, frameID, pageID, promptEnabled, WTFMove(completionHandler));
>         else
>             completionHandler(false);
>     } else {
>@@ -980,11 +980,17 @@ void NetworkProcess::requestStorageAccessGranted(PAL::SessionID sessionID, const
>     }
> }
> 
>-void NetworkProcess::grantStorageAccess(PAL::SessionID sessionID, const String& resourceDomain, const String& firstPartyDomain, Optional<uint64_t> frameID, uint64_t pageID, bool userWasPrompted, CompletionHandler<void(bool)>&& completionHandler)
>+void NetworkProcess::grantStorageAccess(PAL::SessionID sessionID, const RegistrableDomain& subFrameDomain, const RegistrableDomain& topFrameDomain, Optional<uint64_t> frameID, uint64_t pageID, bool userWasPrompted, CompletionHandler<void(bool)>&& completionHandler)
> {
>+    // FIXME: We should not accept an optional frame ID since we call frameID.value() unconditionally.
>+    if (!frameID) {
>+        completionHandler(false);
>+        return;
>+    }
>+
>     if (auto* networkSession = this->networkSession(sessionID)) {
>         if (auto* resourceLoadStatistics = networkSession->resourceLoadStatistics())
>-            resourceLoadStatistics->grantStorageAccess(resourceDomain, firstPartyDomain, frameID.value(), pageID, userWasPrompted, WTFMove(completionHandler));
>+            resourceLoadStatistics->grantStorageAccess(subFrameDomain, topFrameDomain, frameID.value(), pageID, userWasPrompted, WTFMove(completionHandler));
>         else
>             completionHandler(false);
>     } else {
>@@ -993,20 +999,20 @@ void NetworkProcess::grantStorageAccess(PAL::SessionID sessionID, const String&
>     }
> }
> 
>-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)
>+void NetworkProcess::logFrameNavigation(PAL::SessionID sessionID, const RegistrableDomain& targetDomain, const RegistrableDomain& topFrameDomain, const RegistrableDomain& sourceDomain, bool isRedirect, bool isMainFrame)
> {
>     if (auto* networkSession = this->networkSession(sessionID)) {
>         if (auto* resourceLoadStatistics = networkSession->resourceLoadStatistics())
>-            resourceLoadStatistics->logFrameNavigation(targetPrimaryDomain, mainFramePrimaryDomain, sourcePrimaryDomain, targetHost, mainFrameHost, isRedirect, isMainFrame);
>+            resourceLoadStatistics->logFrameNavigation(targetDomain, topFrameDomain, sourceDomain, isRedirect, isMainFrame);
>     } else
>         ASSERT_NOT_REACHED();
> }
> 
>-void NetworkProcess::logUserInteraction(PAL::SessionID sessionID, const String& targetPrimaryDomain, CompletionHandler<void()>&& completionHandler)
>+void NetworkProcess::logUserInteraction(PAL::SessionID sessionID, const RegistrableDomain& domain, CompletionHandler<void()>&& completionHandler)
> {
>     if (auto* networkSession = this->networkSession(sessionID)) {
>         if (auto* resourceLoadStatistics = networkSession->resourceLoadStatistics())
>-            resourceLoadStatistics->logUserInteraction(targetPrimaryDomain, WTFMove(completionHandler));
>+            resourceLoadStatistics->logUserInteraction(domain, WTFMove(completionHandler));
>         else
>             completionHandler();
>     } else {
>@@ -1015,11 +1021,11 @@ void NetworkProcess::logUserInteraction(PAL::SessionID sessionID, const String&
>     }
> }
> 
>-void NetworkProcess::hadUserInteraction(PAL::SessionID sessionID, const String& resourceDomain, CompletionHandler<void(bool)>&& completionHandler)
>+void NetworkProcess::hadUserInteraction(PAL::SessionID sessionID, const RegistrableDomain& domain, CompletionHandler<void(bool)>&& completionHandler)
> {
>     if (auto* networkSession = this->networkSession(sessionID)) {
>         if (auto* resourceLoadStatistics = networkSession->resourceLoadStatistics())
>-            resourceLoadStatistics->hasHadUserInteraction(resourceDomain, WTFMove(completionHandler));
>+            resourceLoadStatistics->hasHadUserInteraction(domain, WTFMove(completionHandler));
>         else
>             completionHandler(false);
>     } else {
>@@ -1028,11 +1034,11 @@ void NetworkProcess::hadUserInteraction(PAL::SessionID sessionID, const String&
>     }
> }
> 
>-void NetworkProcess::clearUserInteraction(PAL::SessionID sessionID, const String& resourceDomain, CompletionHandler<void()>&& completionHandler)
>+void NetworkProcess::clearUserInteraction(PAL::SessionID sessionID, const RegistrableDomain& domain, CompletionHandler<void()>&& completionHandler)
> {
>     if (auto* networkSession = this->networkSession(sessionID)) {
>         if (auto* resourceLoadStatistics = networkSession->resourceLoadStatistics())
>-            resourceLoadStatistics->clearUserInteraction(resourceDomain, WTFMove(completionHandler));
>+            resourceLoadStatistics->clearUserInteraction(domain, WTFMove(completionHandler));
>         else
>             completionHandler();
>     } else {
>@@ -1050,7 +1056,7 @@ void NetworkProcess::removeAllStorageAccess(PAL::SessionID sessionID, Completion
>     completionHandler();
> }
> 
>-void NetworkProcess::removePrevalentDomains(PAL::SessionID sessionID, const Vector<String>& domains)
>+void NetworkProcess::removePrevalentDomains(PAL::SessionID sessionID, const Vector<RegistrableDomain>& domains)
> {
>     if (auto* networkStorageSession = storageSession(sessionID))
>         networkStorageSession->removePrevalentDomains(domains);
>@@ -1415,29 +1421,29 @@ void NetworkProcess::deleteWebsiteDataForOrigins(PAL::SessionID sessionID, Optio
> }
> 
> #if ENABLE(RESOURCE_LOAD_STATISTICS)
>-static Vector<String> filterForTopLevelDomains(const Vector<String>& topLevelDomains, const HashSet<String>& foundValues)
>+static Vector<String> filterForRegistrableDomains(const Vector<RegistrableDomain>& registrableDomains, const HashSet<String>& foundValues)
> {
>     Vector<String> result;
>-    for (const auto& hostname : topLevelDomains) {
>-        if (foundValues.contains(hostname))
>-            result.append(hostname);
>+    for (const auto& domain : registrableDomains) {
>+        if (foundValues.contains(domain.string()))
>+            result.append(domain.string());
>     }
>     
>     return result;
> }
> 
>-static Vector<WebsiteData::Entry> filterForTopLevelDomains(const Vector<String>& topLevelDomains, const Vector<WebsiteData::Entry>& foundValues)
>+static Vector<WebsiteData::Entry> filterForRegistrableDomains(const Vector<RegistrableDomain>& registrableDomains, const Vector<WebsiteData::Entry>& foundValues)
> {
>     Vector<WebsiteData::Entry> result;
>     for (const auto& value : foundValues) {
>-        if (topLevelDomains.contains(value.origin.host))
>+        if (registrableDomains.contains(RegistrableDomain { 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)
>+void NetworkProcess::deleteWebsiteDataForRegistrableDomainsInAllPersistentDataStores(PAL::SessionID sessionID, OptionSet<WebsiteDataType> websiteDataTypes, Vector<RegistrableDomain>&& domains, bool shouldNotifyPage, CompletionHandler<void(const HashSet<String>&)>&& completionHandler)
> {
>     OptionSet<WebsiteDataFetchOption> fetchOptions = WebsiteDataFetchOption::DoNotCreateProcesses;
> 
>@@ -1468,12 +1474,12 @@ void NetworkProcess::deleteWebsiteDataForTopPrivatelyControlledDomainsInAllPersi
>         WebsiteData m_websiteData;
>     };
>     
>-    auto callbackAggregator = adoptRef(*new CallbackAggregator([this, completionHandler = WTFMove(completionHandler), shouldNotifyPage] (const HashSet<String>& originsWithData) mutable {
>+    auto callbackAggregator = adoptRef(*new CallbackAggregator([this, completionHandler = WTFMove(completionHandler), shouldNotifyPage] (const HashSet<String>& domainsWithData) mutable {
>         if (shouldNotifyPage)
>-            parentProcessConnection()->send(Messages::NetworkProcessProxy::NotifyWebsiteDataDeletionForTopPrivatelyOwnedDomainsFinished(), 0);
>+            parentProcessConnection()->send(Messages::NetworkProcessProxy::NotifyWebsiteDataDeletionForRegistrableDomainsFinished(), 0);
>         
>-        RunLoop::main().dispatch([completionHandler = WTFMove(completionHandler), originsWithData = crossThreadCopy(originsWithData)] () mutable {
>-            completionHandler(originsWithData);
>+        RunLoop::main().dispatch([completionHandler = WTFMove(completionHandler), domainsWithData = crossThreadCopy(domainsWithData)] () mutable {
>+            completionHandler(domainsWithData);
>         });
>     }));
> 
>@@ -1483,7 +1489,7 @@ void NetworkProcess::deleteWebsiteDataForTopPrivatelyControlledDomainsInAllPersi
>     if (websiteDataTypes.contains(WebsiteDataType::Cookies)) {
>         if (auto* networkStorageSession = storageSession(sessionID)) {
>             networkStorageSession->getHostnamesWithCookies(websiteDataStore.hostNamesWithCookies);
>-            hostnamesWithCookiesToDelete = filterForTopLevelDomains(topPrivatelyControlledDomains, websiteDataStore.hostNamesWithCookies);
>+            hostnamesWithCookiesToDelete = filterForRegistrableDomains(domains, websiteDataStore.hostNamesWithCookies);
>             networkStorageSession->deleteCookiesForHostnames(hostnamesWithCookiesToDelete);
>         }
>     }
>@@ -1493,7 +1499,7 @@ void NetworkProcess::deleteWebsiteDataForTopPrivatelyControlledDomainsInAllPersi
>     if (websiteDataTypes.contains(WebsiteDataType::HSTSCache)) {
>         if (auto* networkStorageSession = storageSession(sessionID)) {
>             getHostNamesWithHSTSCache(*networkStorageSession, websiteDataStore.hostNamesWithHSTSCache);
>-            hostnamesWithHSTSToDelete = filterForTopLevelDomains(topPrivatelyControlledDomains, websiteDataStore.hostNamesWithHSTSCache);
>+            hostnamesWithHSTSToDelete = filterForRegistrableDomains(domains, websiteDataStore.hostNamesWithHSTSCache);
>             deleteHSTSCacheForHostNames(*networkStorageSession, hostnamesWithHSTSToDelete);
>         }
>     }
>@@ -1508,9 +1514,9 @@ void NetworkProcess::deleteWebsiteDataForTopPrivatelyControlledDomainsInAllPersi
>     */
>     
>     if (websiteDataTypes.contains(WebsiteDataType::DOMCache)) {
>-        CacheStorage::Engine::fetchEntries(*this, sessionID, fetchOptions.contains(WebsiteDataFetchOption::ComputeSizes), [this, topPrivatelyControlledDomains, sessionID, callbackAggregator = callbackAggregator.copyRef()](auto entries) mutable {
>+        CacheStorage::Engine::fetchEntries(*this, sessionID, fetchOptions.contains(WebsiteDataFetchOption::ComputeSizes), [this, domains, sessionID, callbackAggregator = callbackAggregator.copyRef()](auto entries) mutable {
>             
>-            auto entriesToDelete = filterForTopLevelDomains(topPrivatelyControlledDomains, entries);
>+            auto entriesToDelete = filterForRegistrableDomains(domains, entries);
> 
>             callbackAggregator->m_websiteData.entries.appendVector(entriesToDelete);
>             
>@@ -1523,11 +1529,11 @@ void NetworkProcess::deleteWebsiteDataForTopPrivatelyControlledDomainsInAllPersi
>     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)] {
>+        postStorageTask(CrossThreadTask([this, sessionID, callbackAggregator = callbackAggregator.copyRef(), path = WTFMove(path), domains]() mutable {
>+            RunLoop::main().dispatch([this, sessionID, domains = crossThreadCopy(domains), callbackAggregator = callbackAggregator.copyRef(), securityOrigins = indexedDatabaseOrigins(path)] {
>                 Vector<SecurityOriginData> entriesToDelete;
>                 for (const auto& securityOrigin : securityOrigins) {
>-                    if (!topPrivatelyControlledDomains.contains(securityOrigin.host))
>+                    if (!domains.contains(RegistrableDomain { securityOrigin.host }))
>                         continue;
> 
>                     entriesToDelete.append(securityOrigin);
>@@ -1543,9 +1549,9 @@ void NetworkProcess::deleteWebsiteDataForTopPrivatelyControlledDomainsInAllPersi
> #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 {
>+        swServerForSession(sessionID).getOriginsWithRegistrations([this, sessionID, domains, callbackAggregator = callbackAggregator.copyRef()](const HashSet<SecurityOriginData>& securityOrigins) mutable {
>             for (auto& securityOrigin : securityOrigins) {
>-                if (!topPrivatelyControlledDomains.contains(securityOrigin.host))
>+                if (!domains.contains(RegistrableDomain { securityOrigin.host }))
>                     continue;
>                 callbackAggregator->m_websiteData.entries.append({ securityOrigin, WebsiteDataType::ServiceWorkerRegistrations, 0 });
>                 swServerForSession(sessionID).clear(securityOrigin, [callbackAggregator = callbackAggregator.copyRef()] { });
>@@ -1555,11 +1561,11 @@ void NetworkProcess::deleteWebsiteDataForTopPrivatelyControlledDomainsInAllPersi
> #endif
>     
>     if (websiteDataTypes.contains(WebsiteDataType::DiskCache)) {
>-        fetchDiskCacheEntries(cache(), sessionID, fetchOptions, [this, topPrivatelyControlledDomains, callbackAggregator = callbackAggregator.copyRef()](auto entries) mutable {
>+        fetchDiskCacheEntries(cache(), sessionID, fetchOptions, [this, domains, callbackAggregator = callbackAggregator.copyRef()](auto entries) mutable {
> 
>             Vector<SecurityOriginData> entriesToDelete;
>             for (auto& entry : entries) {
>-                if (!topPrivatelyControlledDomains.contains(entry.origin.host))
>+                if (!domains.contains(RegistrableDomain { entry.origin.host }))
>                     continue;
>                 entriesToDelete.append(entry.origin);
>                 callbackAggregator->m_websiteData.entries.append(entry);
>@@ -1569,12 +1575,12 @@ void NetworkProcess::deleteWebsiteDataForTopPrivatelyControlledDomainsInAllPersi
>     }
> }
> 
>-void NetworkProcess::topPrivatelyControlledDomainsWithWebsiteData(PAL::SessionID sessionID, OptionSet<WebsiteDataType> websiteDataTypes, bool shouldNotifyPage, CompletionHandler<void(HashSet<String>&&)>&& completionHandler)
>+void NetworkProcess::registrableDomainsWithWebsiteData(PAL::SessionID sessionID, OptionSet<WebsiteDataType> websiteDataTypes, bool shouldNotifyPage, CompletionHandler<void(HashSet<RegistrableDomain>&&)>&& completionHandler)
> {
>     OptionSet<WebsiteDataFetchOption> fetchOptions = WebsiteDataFetchOption::DoNotCreateProcesses;
>     
>     struct CallbackAggregator final : public ThreadSafeRefCounted<CallbackAggregator> {
>-        explicit CallbackAggregator(CompletionHandler<void(HashSet<String>&&)>&& completionHandler)
>+        explicit CallbackAggregator(CompletionHandler<void(HashSet<RegistrableDomain>&&)>&& completionHandler)
>             : m_completionHandler(WTFMove(completionHandler))
>         {
>         }
>@@ -1582,30 +1588,30 @@ void NetworkProcess::topPrivatelyControlledDomainsWithWebsiteData(PAL::SessionID
>         ~CallbackAggregator()
>         {
>             RunLoop::main().dispatch([completionHandler = WTFMove(m_completionHandler), websiteData = WTFMove(m_websiteData)] () mutable {
>-                HashSet<String> origins;
>+                HashSet<RegistrableDomain> domains;
>                 for (const auto& hostnameWithCookies : websiteData.hostNamesWithCookies)
>-                    origins.add(hostnameWithCookies);
>-                
>+                    domains.add(RegistrableDomain { hostnameWithCookies });
>+
>                 for (const auto& hostnameWithHSTS : websiteData.hostNamesWithHSTSCache)
>-                    origins.add(hostnameWithHSTS);
>-                
>+                    domains.add(RegistrableDomain { hostnameWithHSTS });
>+
>                 for (const auto& entry : websiteData.entries)
>-                    origins.add(entry.origin.host);
>-                
>-                completionHandler(WTFMove(origins));
>+                    domains.add(RegistrableDomain { entry.origin.host });
>+
>+                completionHandler(WTFMove(domains));
>             });
>         }
>         
>-        CompletionHandler<void(HashSet<String>&&)> m_completionHandler;
>+        CompletionHandler<void(HashSet<RegistrableDomain>&&)> m_completionHandler;
>         WebsiteData m_websiteData;
>     };
>     
>-    auto callbackAggregator = adoptRef(*new CallbackAggregator([this, completionHandler = WTFMove(completionHandler), shouldNotifyPage] (HashSet<String>&& originsWithData) mutable {
>+    auto callbackAggregator = adoptRef(*new CallbackAggregator([this, completionHandler = WTFMove(completionHandler), shouldNotifyPage] (HashSet<RegistrableDomain>&& domainsWithData) mutable {
>         if (shouldNotifyPage)
>-            parentProcessConnection()->send(Messages::NetworkProcessProxy::NotifyWebsiteDataScanForTopPrivatelyControlledDomainsFinished(), 0);
>+            parentProcessConnection()->send(Messages::NetworkProcessProxy::NotifyWebsiteDataScanForRegistrableDomainsFinished(), 0);
> 
>-        RunLoop::main().dispatch([completionHandler = WTFMove(completionHandler), originsWithData = crossThreadCopy(originsWithData)] () mutable {
>-            completionHandler(WTFMove(originsWithData));
>+        RunLoop::main().dispatch([completionHandler = WTFMove(completionHandler), domainsWithData = crossThreadCopy(domainsWithData)] () mutable {
>+            completionHandler(WTFMove(domainsWithData));
>         });
>     }));
>     
>diff --git a/Source/WebKit/NetworkProcess/NetworkProcess.h b/Source/WebKit/NetworkProcess/NetworkProcess.h
>index 3991bcd1baeb82eb8b7e4abe542d363c30f84d7a..0ab289436bc72d38e45ed4c78bde26b12dec1222 100644
>--- a/Source/WebKit/NetworkProcess/NetworkProcess.h
>+++ b/Source/WebKit/NetworkProcess/NetworkProcess.h
>@@ -37,6 +37,7 @@
> #include <WebCore/FetchIdentifier.h>
> #include <WebCore/IDBKeyData.h>
> #include <WebCore/IDBServer.h>
>+#include <WebCore/RegistrableDomain.h>
> #include <WebCore/ServiceWorkerIdentifier.h>
> #include <WebCore/ServiceWorkerTypes.h>
> #include <memory>
>@@ -110,6 +111,21 @@ class NetworkProcess : public AuxiliaryProcess, private DownloadManager::Client,
> {
>     WTF_MAKE_NONCOPYABLE(NetworkProcess);
> public:
>+    using RegistrableDomain = WebCore::RegistrableDomain;
>+    using TopFrameDomain = WebCore::RegistrableDomain;
>+    using SubFrameDomain = WebCore::RegistrableDomain;
>+    using SubResourceDomain = WebCore::RegistrableDomain;
>+    using RedirectDomain = WebCore::RegistrableDomain;
>+    using RedirectedFromDomain = WebCore::RegistrableDomain;
>+    using RedirectedToDomain = WebCore::RegistrableDomain;
>+    using NavigatedFromDomain = WebCore::RegistrableDomain;
>+    using NavigatedToDomain = WebCore::RegistrableDomain;
>+    using DomainInNeedOfStorageAccess = WebCore::RegistrableDomain;
>+    using OpenerDomain = WebCore::RegistrableDomain;
>+    using OpenerPageID = uint64_t;
>+    using PageID = uint64_t;
>+    using FrameID = uint64_t;
>+
>     NetworkProcess(AuxiliaryProcessInitializationParameters&&);
>     ~NetworkProcess();
>     static constexpr ProcessType processType = ProcessType::Network;
>@@ -180,35 +196,35 @@ 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 clearPrevalentResource(PAL::SessionID, const RegistrableDomain&, CompletionHandler<void()>&&);
>+    void clearUserInteraction(PAL::SessionID, const RegistrableDomain&, CompletionHandler<void()>&&);
>+    void deleteWebsiteDataForRegistrableDomainsInAllPersistentDataStores(PAL::SessionID, OptionSet<WebsiteDataType>, Vector<RegistrableDomain>&&, bool shouldNotifyPage, CompletionHandler<void(const HashSet<String>&)>&&);
>     void dumpResourceLoadStatistics(PAL::SessionID, CompletionHandler<void(String)>&&);
>-    void updatePrevalentDomainsToBlockCookiesFor(PAL::SessionID, const Vector<String>& domainsToBlock, CompletionHandler<void()>&&);
>-    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 updatePrevalentDomainsToBlockCookiesFor(PAL::SessionID, const Vector<RegistrableDomain>& domainsToBlock, CompletionHandler<void()>&&);
>+    void isGrandfathered(PAL::SessionID, const RegistrableDomain&, CompletionHandler<void(bool)>&&);
>+    void isPrevalentResource(PAL::SessionID, const RegistrableDomain&, CompletionHandler<void(bool)>&&);
>+    void isVeryPrevalentResource(PAL::SessionID, const RegistrableDomain&, CompletionHandler<void(bool)>&&);
>     void setAgeCapForClientSideCookies(PAL::SessionID, Optional<Seconds>, CompletionHandler<void()>&&);
>-    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 isRegisteredAsRedirectingTo(PAL::SessionID, const RedirectedFromDomain&, const RedirectedToDomain&, CompletionHandler<void(bool)>&&);
>+    void isRegisteredAsSubFrameUnder(PAL::SessionID, const SubFrameDomain&, const TopFrameDomain&, CompletionHandler<void(bool)>&&);
>+    void isRegisteredAsSubresourceUnder(PAL::SessionID, const SubResourceDomain&, const TopFrameDomain&, CompletionHandler<void(bool)>&&);
>+    void setGrandfathered(PAL::SessionID, const RegistrableDomain&, 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 setPrevalentResource(PAL::SessionID, const RegistrableDomain&, CompletionHandler<void()>&&);
>+    void setPrevalentResourceForDebugMode(PAL::SessionID, const RegistrableDomain&, CompletionHandler<void()>&&);
>+    void setVeryPrevalentResource(PAL::SessionID, const RegistrableDomain&, 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, CompletionHandler<void(bool)>&&);
>+    void hadUserInteraction(PAL::SessionID, const RegistrableDomain&, CompletionHandler<void(bool)>&&);
>+    void hasStorageAccessForFrame(PAL::SessionID, const SubFrameDomain&, const TopFrameDomain&, FrameID, PageID, CompletionHandler<void(bool)>&&);
>     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, bool userWasPrompted, CompletionHandler<void(bool)>&&);
>-    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, CompletionHandler<void()>&&);
>+    void grantStorageAccess(PAL::SessionID, const SubFrameDomain&, const TopFrameDomain&, Optional<FrameID>, PageID, bool userWasPrompted, CompletionHandler<void(bool)>&&);
>+    void hasStorageAccess(PAL::SessionID, const SubFrameDomain&, const TopFrameDomain&, Optional<FrameID>, PageID, CompletionHandler<void(bool)>&&);
>+    void logFrameNavigation(PAL::SessionID, const NavigatedToDomain&, const TopFrameDomain&, const NavigatedFromDomain&, bool isRedirect, bool isMainFrame);
>+    void logUserInteraction(PAL::SessionID, const TopFrameDomain&, CompletionHandler<void()>&&);
>     void removeAllStorageAccess(PAL::SessionID, CompletionHandler<void()>&&);
>-    void removePrevalentDomains(PAL::SessionID, const Vector<String>& domains);
>-    void requestStorageAccess(PAL::SessionID, const String& resourceDomain, const String& firstPartyDomain, Optional<uint64_t> frameID, uint64_t pageID, bool promptEnabled, CompletionHandler<void(StorageAccessStatus)>&&);
>-    void requestStorageAccessGranted(PAL::SessionID, const String& subFrameHost, const String& topFrameHost, uint64_t frameID, uint64_t pageID, bool promptEnabled, CompletionHandler<void(bool)>&&);
>+    void removePrevalentDomains(PAL::SessionID, const Vector<RegistrableDomain>&);
>+    void requestStorageAccess(PAL::SessionID, const SubFrameDomain&, const TopFrameDomain&, Optional<FrameID>, PageID, bool promptEnabled, CompletionHandler<void(StorageAccessStatus)>&&);
>+    void requestStorageAccessGranted(PAL::SessionID, const SubFrameDomain&, const TopFrameDomain&, FrameID, PageID, bool promptEnabled, CompletionHandler<void(bool)>&&);
>     void resetCacheMaxAgeCapForPrevalentResources(PAL::SessionID, CompletionHandler<void()>&&);
>     void resetParametersToDefaultValues(PAL::SessionID, CompletionHandler<void()>&&);
>     void scheduleClearInMemoryAndPersistent(PAL::SessionID, Optional<WallTime> modifiedSince, ShouldGrandfatherStatistics, CompletionHandler<void()>&&);
>@@ -217,21 +233,21 @@ public:
>     void submitTelemetry(PAL::SessionID, CompletionHandler<void()>&&);
>     void setCacheMaxAgeCapForPrevalentResources(PAL::SessionID, Seconds, CompletionHandler<void()>&&);
>     void setGrandfatheringTime(PAL::SessionID, Seconds, CompletionHandler<void()>&&);
>-    void setLastSeen(PAL::SessionID, const String& resourceDomain, Seconds, CompletionHandler<void()>&&);
>+    void setLastSeen(PAL::SessionID, const RegistrableDomain&, 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 setSubframeUnderTopFrameOrigin(PAL::SessionID, const SubFrameDomain&, const TopFrameDomain&, CompletionHandler<void()>&&);
>+    void setSubresourceUnderTopFrameOrigin(PAL::SessionID, const SubResourceDomain&, const TopFrameDomain&, CompletionHandler<void()>&&);
>+    void setSubresourceUniqueRedirectTo(PAL::SessionID, const SubResourceDomain&, const RedirectedToDomain&, CompletionHandler<void()>&&);
>+    void setSubresourceUniqueRedirectFrom(PAL::SessionID, const SubResourceDomain&, const RedirectedFromDomain&, 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>&&)>&&);
>+    void setTopFrameUniqueRedirectTo(PAL::SessionID, const TopFrameDomain&, const RedirectedToDomain&, CompletionHandler<void()>&&);
>+    void setTopFrameUniqueRedirectFrom(PAL::SessionID, const TopFrameDomain&, const RedirectedFromDomain&, CompletionHandler<void()>&&);
>+    void registrableDomainsWithWebsiteData(PAL::SessionID, OptionSet<WebsiteDataType>, bool shouldNotifyPage, CompletionHandler<void(HashSet<RegistrableDomain>&&)>&&);
> #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 1f6b22bc19db840f0bb9b3fff69d1e132cc5dd6e..83fc1c92312438dec1b282c97b29c1ec286cae6c 100644
>--- a/Source/WebKit/NetworkProcess/NetworkProcess.messages.in
>+++ b/Source/WebKit/NetworkProcess/NetworkProcess.messages.in
>@@ -83,38 +83,38 @@ 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
>+    ClearPrevalentResource(PAL::SessionID sessionID, WebCore::RegistrableDomain resourceDomain) -> () Async
>+    ClearUserInteraction(PAL::SessionID sessionID, WebCore::RegistrableDomain resourceDomain) -> () Async
>     DumpResourceLoadStatistics(PAL::SessionID sessionID) -> (String dumpedStatistics) Async
>     SetResourceLoadStatisticsEnabled(bool enabled)
>-    UpdatePrevalentDomainsToBlockCookiesFor(PAL::SessionID sessionID, Vector<String> domainsToBlock) -> () Async
>-    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
>+    UpdatePrevalentDomainsToBlockCookiesFor(PAL::SessionID sessionID, Vector<WebCore::RegistrableDomain> domainsToBlock) -> () Async
>+    IsGrandfathered(PAL::SessionID sessionID, WebCore::RegistrableDomain targetDomain) -> (bool isGrandfathered) Async
>+    IsPrevalentResource(PAL::SessionID sessionID, WebCore::RegistrableDomain targetDomain) -> (bool isPrevalent) Async
>+    IsVeryPrevalentResource(PAL::SessionID sessionID, WebCore::RegistrableDomain targetDomain) -> (bool isVeryPrevalent) Async
>     SetAgeCapForClientSideCookies(PAL::SessionID sessionID, Optional<Seconds> seconds) -> () Async
>-    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) -> (bool hasStorageAccess) Async
>-    HasStorageAccess(PAL::SessionID sessionID, String resourceDomain, String firstPartyDomain, Optional<uint64_t> frameID, uint64_t pageID) -> (bool hasStorageAccess) Async
>+    SetLastSeen(PAL::SessionID sessionID, WebCore::RegistrableDomain resourceDomain, Seconds seconds) -> () Async
>+    SetPrevalentResource(PAL::SessionID sessionID, WebCore::RegistrableDomain resourceDomain) -> () Async
>+    SetPrevalentResourceForDebugMode(PAL::SessionID sessionID, WebCore::RegistrableDomain resourceDomain) -> () Async
>+    HadUserInteraction(PAL::SessionID sessionID, WebCore::RegistrableDomain resourceDomain) -> (bool hadUserInteraction) Async
>+    HasStorageAccessForFrame(PAL::SessionID sessionID, WebCore::RegistrableDomain subFrameDomain, WebCore::RegistrableDomain topFrameDomain, uint64_t frameID, uint64_t pageID) -> (bool hasStorageAccess) Async
>+    HasStorageAccess(PAL::SessionID sessionID, WebCore::RegistrableDomain resourceDomain, WebCore::RegistrableDomain topFrameDomain, Optional<uint64_t> frameID, uint64_t pageID) -> (bool hasStorageAccess) Async
>     GetAllStorageAccessEntries(PAL::SessionID sessionID) -> (Vector<String> domains) Async
>-    GrantStorageAccess(PAL::SessionID sessionID, String resourceDomain, String firstPartyDomain, Optional<uint64_t> frameID, uint64_t pageID, bool userWasPrompted) -> (bool accessGranted) Async
>-    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) -> () Async
>+    GrantStorageAccess(PAL::SessionID sessionID, WebCore::RegistrableDomain subFrameDomain, WebCore::RegistrableDomain topFrameDomain, Optional<uint64_t> frameID, uint64_t pageID, bool userWasPrompted) -> (bool accessGranted) Async
>+    IsRegisteredAsRedirectingTo(PAL::SessionID sessionID, WebCore::RegistrableDomain redirectedFromDomain, WebCore::RegistrableDomain redirectedToDomain) -> (bool isRedirectingTo) Async
>+    IsRegisteredAsSubFrameUnder(PAL::SessionID sessionID, WebCore::RegistrableDomain subFrameDomain, WebCore::RegistrableDomain topFrameDomain) -> (bool isSubframeUnder) Async
>+    IsRegisteredAsSubresourceUnder(PAL::SessionID sessionID, WebCore::RegistrableDomain subresourceDomain, WebCore::RegistrableDomain topFrameDomain) -> (bool isSubresourceUnder) Async
>+    LogFrameNavigation(PAL::SessionID sessionID, WebCore::RegistrableDomain targetDomain, WebCore::RegistrableDomain topFrameDomain, WebCore::RegistrableDomain sourceDomain, bool isRedirect, bool isMainFrame)
>+    LogUserInteraction(PAL::SessionID sessionID, WebCore::RegistrableDomain topFrameDomain) -> () Async
>     RemoveAllStorageAccess(PAL::SessionID sessionID) -> () Async
>-    RemovePrevalentDomains(PAL::SessionID sessionID, Vector<String> domainsWithInteraction)
>-    RequestStorageAccess(PAL::SessionID sessionID, String resourceDomain, String firstPartyDomain, Optional<uint64_t> frameID, uint64_t pageID, bool promptEnabled) -> (enum:uint8_t WebKit::StorageAccessStatus storageAccessStatus) Async
>+    RemovePrevalentDomains(PAL::SessionID sessionID, Vector<WebCore::RegistrableDomain> domainsWithInteraction)
>+    RequestStorageAccess(PAL::SessionID sessionID, WebCore::RegistrableDomain resourceDomain, WebCore::RegistrableDomain topFrameDomain, Optional<uint64_t> frameID, uint64_t pageID, bool promptEnabled) -> (enum:uint8_t WebKit::StorageAccessStatus storageAccessStatus) Async
>     ResetParametersToDefaultValues(PAL::SessionID sessionID) -> () Async
>     ScheduleClearInMemoryAndPersistent(PAL::SessionID sessionID, Optional<WallTime> modifiedSince, enum:bool WebKit::ShouldGrandfatherStatistics shouldGrandfather) -> () Async
>     ScheduleCookieBlockingUpdate(PAL::SessionID sessionID) -> () Async
>     ScheduleStatisticsAndDataRecordsProcessing(PAL::SessionID sessionID) -> () Async
>     SubmitTelemetry(PAL::SessionID sessionID) -> () Async
>     SetCacheMaxAgeCapForPrevalentResources(PAL::SessionID sessionID, Seconds seconds) -> () Async
>-    SetGrandfathered(PAL::SessionID sessionID, String resourceDomain, bool isGrandfathered) -> () Async
>+    SetGrandfathered(PAL::SessionID sessionID, WebCore::RegistrableDomain 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
>@@ -123,14 +123,14 @@ messages -> NetworkProcess LegacyReceiver {
>     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
>+    SetVeryPrevalentResource(PAL::SessionID sessionID, WebCore::RegistrableDomain resourceDomain) -> () Async
>+    SetSubframeUnderTopFrameOrigin(PAL::SessionID sessionID, WebCore::RegistrableDomain subFrameDomain, WebCore::RegistrableDomain topFrameDomain) -> () Async
>+    SetSubresourceUnderTopFrameOrigin(PAL::SessionID sessionID, WebCore::RegistrableDomain subresourceDomain, WebCore::RegistrableDomain topFrameDomain) -> () Async
>+    SetSubresourceUniqueRedirectTo(PAL::SessionID sessionID, WebCore::RegistrableDomain subresourceDomain, WebCore::RegistrableDomain redirectedToDomain) -> () Async
>+    SetSubresourceUniqueRedirectFrom(PAL::SessionID sessionID, WebCore::RegistrableDomain subresourceDomain, WebCore::RegistrableDomain redirectedFromDomain) -> () 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
>+    SetTopFrameUniqueRedirectTo(PAL::SessionID sessionID, WebCore::RegistrableDomain topFrameDomain, WebCore::RegistrableDomain redirectedToDomain) -> () Async
>+    SetTopFrameUniqueRedirectFrom(PAL::SessionID sessionID, WebCore::RegistrableDomain topFrameDomain, WebCore::RegistrableDomain redirectedFromDomain) -> () Async
>     ResetCacheMaxAgeCapForPrevalentResources(PAL::SessionID sessionID) -> () Async
> #endif
> 
>diff --git a/Source/WebKit/NetworkProcess/NetworkResourceLoader.cpp b/Source/WebKit/NetworkProcess/NetworkResourceLoader.cpp
>index 9f0d20270985dca9675aa8a6fcd2bd2c470ac8f0..cfa99b175f3539ad364feb9149c779c95fbfbd1e 100644
>--- a/Source/WebKit/NetworkProcess/NetworkResourceLoader.cpp
>+++ b/Source/WebKit/NetworkProcess/NetworkResourceLoader.cpp
>@@ -48,6 +48,7 @@
> #include <WebCore/HTTPParsers.h>
> #include <WebCore/NetworkLoadMetrics.h>
> #include <WebCore/NetworkStorageSession.h>
>+#include <WebCore/RegistrableDomain.h>
> #include <WebCore/SameSiteInfo.h>
> #include <WebCore/SecurityOrigin.h>
> #include <WebCore/SharedBuffer.h>
>@@ -979,7 +980,7 @@ static void logCookieInformationInternal(NetworkConnectionToWebProcess& connecti
>     auto escapedFrameID = escapeIDForJSON(frameID);
>     auto escapedPageID = escapeIDForJSON(pageID);
>     auto escapedIdentifier = escapeIDForJSON(identifier);
>-    bool hasStorageAccess = (frameID && pageID) ? networkStorageSession.hasStorageAccess(url.string(), firstParty.string(), frameID.value(), pageID.value()) : false;
>+    bool hasStorageAccess = (frameID && pageID) ? networkStorageSession.hasStorageAccess(WebCore::RegistrableDomain { url }, WebCore::RegistrableDomain { firstParty }, frameID.value(), pageID.value()) : false;
> 
> #define LOCAL_LOG_IF_ALLOWED(fmt, ...) RELEASE_LOG_IF(networkStorageSession.sessionID().isAlwaysOnLoggingAllowed(), Network, "%p - %s::" fmt, loggedObject, label.utf8().data(), ##__VA_ARGS__)
> #define LOCAL_LOG(str, ...) \
>diff --git a/Source/WebKit/NetworkProcess/NetworkSession.cpp b/Source/WebKit/NetworkProcess/NetworkSession.cpp
>index 26bd6f0a90ff1a9256c0858e5417a5e48a0fb4ad..d7192436d5179489b70cd2f878cbfef1732962c8 100644
>--- a/Source/WebKit/NetworkProcess/NetworkSession.cpp
>+++ b/Source/WebKit/NetworkProcess/NetworkSession.cpp
>@@ -117,14 +117,14 @@ void NetworkSession::notifyPageStatisticsTelemetryFinished(unsigned totalPrevale
>     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)
>+void NetworkSession::deleteWebsiteDataForRegistrableDomainsInAllPersistentDataStores(OptionSet<WebsiteDataType> dataTypes, Vector<RegistrableDomain>&& domains, bool shouldNotifyPage, CompletionHandler<void(const HashSet<String>&)>&& completionHandler)
> {
>-    m_networkProcess->deleteWebsiteDataForTopPrivatelyControlledDomainsInAllPersistentDataStores(m_sessionID, dataTypes, WTFMove(topPrivatelyControlledDomains), shouldNotifyPage, WTFMove(completionHandler));
>+    m_networkProcess->deleteWebsiteDataForRegistrableDomainsInAllPersistentDataStores(m_sessionID, dataTypes, WTFMove(domains), shouldNotifyPage, WTFMove(completionHandler));
> }
> 
>-void NetworkSession::topPrivatelyControlledDomainsWithWebsiteData(OptionSet<WebsiteDataType> dataTypes, bool shouldNotifyPage, CompletionHandler<void(HashSet<String>&&)>&& completionHandler)
>+void NetworkSession::registrableDomainsWithWebsiteData(OptionSet<WebsiteDataType> dataTypes, bool shouldNotifyPage, CompletionHandler<void(HashSet<RegistrableDomain>&&)>&& completionHandler)
> {
>-    m_networkProcess->topPrivatelyControlledDomainsWithWebsiteData(m_sessionID, dataTypes, shouldNotifyPage, WTFMove(completionHandler));
>+    m_networkProcess->registrableDomainsWithWebsiteData(m_sessionID, dataTypes, shouldNotifyPage, WTFMove(completionHandler));
> }
> #endif
> 
>diff --git a/Source/WebKit/NetworkProcess/NetworkSession.h b/Source/WebKit/NetworkProcess/NetworkSession.h
>index 822f043c1244ffb7590cb6a355195acbbfd3b600..63f44a33f6ccaee486a54e01031eac3cf5671a40 100644
>--- a/Source/WebKit/NetworkProcess/NetworkSession.h
>+++ b/Source/WebKit/NetworkProcess/NetworkSession.h
>@@ -25,6 +25,7 @@
> 
> #pragma once
> 
>+#include <WebCore/RegistrableDomain.h>
> #include <pal/SessionID.h>
> #include <wtf/HashSet.h>
> #include <wtf/Ref.h>
>@@ -71,8 +72,8 @@ public:
>     WebResourceLoadStatisticsStore* resourceLoadStatistics() const { return m_resourceLoadStatistics.get(); }
>     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 deleteWebsiteDataForRegistrableDomainsInAllPersistentDataStores(OptionSet<WebsiteDataType>, Vector<WebCore::RegistrableDomain>&&, bool shouldNotifyPage, CompletionHandler<void(const HashSet<String>&)>&&);
>+    void registrableDomainsWithWebsiteData(OptionSet<WebsiteDataType>, bool shouldNotifyPage, CompletionHandler<void(HashSet<WebCore::RegistrableDomain>&&)>&&);
>     void logDiagnosticMessageWithValue(const String& message, const String& description, unsigned value, unsigned significantFigures, WebCore::ShouldSample);
>     void notifyPageStatisticsTelemetryFinished(unsigned totalPrevalentResources, unsigned totalPrevalentResourcesWithUserInteraction, unsigned top3SubframeUnderTopFrameOrigins);
> #endif
>diff --git a/Source/WebKit/Shared/WebCoreArgumentCoders.cpp b/Source/WebKit/Shared/WebCoreArgumentCoders.cpp
>index 54d199e25d84b25183fd9bf9f02cb95b5ac8ca77..6c01a25b39e27656fa5900a32a547be139e4070c 100644
>--- a/Source/WebKit/Shared/WebCoreArgumentCoders.cpp
>+++ b/Source/WebKit/Shared/WebCoreArgumentCoders.cpp
>@@ -62,6 +62,7 @@
> #include <WebCore/ProtectionSpace.h>
> #include <WebCore/RectEdges.h>
> #include <WebCore/Region.h>
>+#include <WebCore/RegistrableDomain.h>
> #include <WebCore/ResourceError.h>
> #include <WebCore/ResourceLoadStatistics.h>
> #include <WebCore/ResourceRequest.h>
>@@ -2671,7 +2672,7 @@ bool ArgumentCoder<ExceptionDetails>::decode(IPC::Decoder& decoder, ExceptionDet
> 
> void ArgumentCoder<ResourceLoadStatistics>::encode(Encoder& encoder, const WebCore::ResourceLoadStatistics& statistics)
> {
>-    encoder << statistics.highLevelDomain;
>+    encoder << statistics.registrableDomain;
>     
>     encoder << statistics.lastSeen.secondsSinceEpoch().value();
>     
>@@ -2715,9 +2716,12 @@ void ArgumentCoder<ResourceLoadStatistics>::encode(Encoder& encoder, const WebCo
> Optional<ResourceLoadStatistics> ArgumentCoder<ResourceLoadStatistics>::decode(Decoder& decoder)
> {
>     ResourceLoadStatistics statistics;
>-    if (!decoder.decode(statistics.highLevelDomain))
>+    Optional<RegistrableDomain> registrableDomain;
>+    decoder >> registrableDomain;
>+    if (!registrableDomain)
>         return WTF::nullopt;
>-    
>+    statistics.registrableDomain = *registrableDomain;
>+
>     double lastSeenTimeAsDouble;
>     if (!decoder.decode(lastSeenTimeAsDouble))
>         return WTF::nullopt;
>diff --git a/Source/WebKit/UIProcess/Cocoa/ResourceLoadStatisticsMemoryStoreCocoa.mm b/Source/WebKit/UIProcess/Cocoa/ResourceLoadStatisticsMemoryStoreCocoa.mm
>index 18ba8336efa5d17ad50df96703709f53d8a6b1ba..3b48e17c1c811a82532084e7baa862a591547181 100644
>--- a/Source/WebKit/UIProcess/Cocoa/ResourceLoadStatisticsMemoryStoreCocoa.mm
>+++ b/Source/WebKit/UIProcess/Cocoa/ResourceLoadStatisticsMemoryStoreCocoa.mm
>@@ -28,6 +28,7 @@
> 
> #if ENABLE(RESOURCE_LOAD_STATISTICS)
> 
>+#import <WebCore/RegistrableDomain.h>
> #import <wtf/text/WTFString.h>
> 
> namespace WebKit {
>@@ -52,7 +53,7 @@ void ResourceLoadStatisticsMemoryStore::registerUserDefaultsIfNeeded()
>         setResourceLoadStatisticsDebugMode([[NSUserDefaults standardUserDefaults] boolForKey:@"ItpDebugMode"]);
>         auto* debugManualPrevalentResource = [[NSUserDefaults standardUserDefaults] stringForKey:@"ResourceLoadStatisticsManualPrevalentResource"];
>         if (debugManualPrevalentResource)
>-            setPrevalentResourceForDebugMode(debugManualPrevalentResource);
>+            setPrevalentResourceForDebugMode(RegistrableDomain { debugManualPrevalentResource });
> 
>         Seconds cacheMaxAgeCapForPrevalentResources([[NSUserDefaults standardUserDefaults] doubleForKey:@"ResourceLoadStatisticsCacheMaxAgeCap"]);
>         if (cacheMaxAgeCapForPrevalentResources > 0_s && cacheMaxAgeCapForPrevalentResources <= 24_h * 365)
>diff --git a/Source/WebKit/UIProcess/Network/NetworkProcessProxy.cpp b/Source/WebKit/UIProcess/Network/NetworkProcessProxy.cpp
>index 7ea9e4e32c72c6980c7ec087aa268205f30dcc2f..dc1e68f9a6e19e72d8207b5c86740ba4a8c4a8f3 100644
>--- a/Source/WebKit/UIProcess/Network/NetworkProcessProxy.cpp
>+++ b/Source/WebKit/UIProcess/Network/NetworkProcessProxy.cpp
>@@ -49,6 +49,7 @@
> #include "WebsiteData.h"
> #include "WebsiteDataStoreClient.h"
> #include <WebCore/ClientOrigin.h>
>+#include <WebCore/RegistrableDomain.h>
> #include <wtf/CompletionHandler.h>
> 
> #if ENABLE(SEC_ITEM_SHIM)
>@@ -414,7 +415,12 @@ void NetworkProcessProxy::updatePrevalentDomainsToBlockCookiesFor(PAL::SessionID
>         return;
>     }
> 
>-    sendWithAsyncReply(Messages::NetworkProcess::UpdatePrevalentDomainsToBlockCookiesFor(sessionID, domainsToBlock), WTFMove(completionHandler));
>+    Vector<RegistrableDomain> registrableDomainsToBlock;
>+    registrableDomainsToBlock.reserveInitialCapacity(domainsToBlock.size());
>+    for (auto& domainString : domainsToBlock)
>+        registrableDomainsToBlock.uncheckedAppend(RegistrableDomain { domainString });
>+
>+    sendWithAsyncReply(Messages::NetworkProcess::UpdatePrevalentDomainsToBlockCookiesFor(sessionID, registrableDomainsToBlock), WTFMove(completionHandler));
> }
> 
> void NetworkProcessProxy::isPrevalentResource(PAL::SessionID sessionID, const String& resourceDomain, CompletionHandler<void(bool)>&& completionHandler)
>@@ -424,7 +430,7 @@ void NetworkProcessProxy::isPrevalentResource(PAL::SessionID sessionID, const St
>         return;
>     }
> 
>-    sendWithAsyncReply(Messages::NetworkProcess::IsPrevalentResource(sessionID, resourceDomain), WTFMove(completionHandler));
>+    sendWithAsyncReply(Messages::NetworkProcess::IsPrevalentResource(sessionID, RegistrableDomain { resourceDomain }), WTFMove(completionHandler));
> }
> 
> void NetworkProcessProxy::isVeryPrevalentResource(PAL::SessionID sessionID, const String& resourceDomain, CompletionHandler<void(bool)>&& completionHandler)
>@@ -434,7 +440,7 @@ void NetworkProcessProxy::isVeryPrevalentResource(PAL::SessionID sessionID, cons
>         return;
>     }
> 
>-    sendWithAsyncReply(Messages::NetworkProcess::IsVeryPrevalentResource(sessionID, resourceDomain), WTFMove(completionHandler));
>+    sendWithAsyncReply(Messages::NetworkProcess::IsVeryPrevalentResource(sessionID, RegistrableDomain { resourceDomain }), WTFMove(completionHandler));
> }
> 
> void NetworkProcessProxy::setPrevalentResource(PAL::SessionID sessionID, const String& resourceDomain, CompletionHandler<void()>&& completionHandler)
>@@ -444,7 +450,7 @@ void NetworkProcessProxy::setPrevalentResource(PAL::SessionID sessionID, const S
>         return;
>     }
> 
>-    sendWithAsyncReply(Messages::NetworkProcess::SetPrevalentResource(sessionID, resourceDomain), WTFMove(completionHandler));
>+    sendWithAsyncReply(Messages::NetworkProcess::SetPrevalentResource(sessionID, RegistrableDomain { resourceDomain }), WTFMove(completionHandler));
> }
> 
> void NetworkProcessProxy::setPrevalentResourceForDebugMode(PAL::SessionID sessionID, const String& resourceDomain, CompletionHandler<void()>&& completionHandler)
>@@ -454,7 +460,7 @@ void NetworkProcessProxy::setPrevalentResourceForDebugMode(PAL::SessionID sessio
>         return;
>     }
> 
>-    sendWithAsyncReply(Messages::NetworkProcess::SetPrevalentResourceForDebugMode(sessionID, resourceDomain), WTFMove(completionHandler));
>+    sendWithAsyncReply(Messages::NetworkProcess::SetPrevalentResourceForDebugMode(sessionID, RegistrableDomain { resourceDomain }), WTFMove(completionHandler));
> }
> 
> void NetworkProcessProxy::setVeryPrevalentResource(PAL::SessionID sessionID, const String& resourceDomain, CompletionHandler<void()>&& completionHandler)
>@@ -464,7 +470,7 @@ void NetworkProcessProxy::setVeryPrevalentResource(PAL::SessionID sessionID, con
>         return;
>     }
> 
>-    sendWithAsyncReply(Messages::NetworkProcess::SetVeryPrevalentResource(sessionID, resourceDomain), WTFMove(completionHandler));
>+    sendWithAsyncReply(Messages::NetworkProcess::SetVeryPrevalentResource(sessionID, RegistrableDomain { resourceDomain }), WTFMove(completionHandler));
> }
> 
> void NetworkProcessProxy::setLastSeen(PAL::SessionID sessionID, const String& resourceDomain, Seconds lastSeen, CompletionHandler<void()>&& completionHandler)
>@@ -474,7 +480,7 @@ void NetworkProcessProxy::setLastSeen(PAL::SessionID sessionID, const String& re
>         return;
>     }
>     
>-    sendWithAsyncReply(Messages::NetworkProcess::SetLastSeen(sessionID, resourceDomain, lastSeen), WTFMove(completionHandler));
>+    sendWithAsyncReply(Messages::NetworkProcess::SetLastSeen(sessionID, RegistrableDomain { resourceDomain }, lastSeen), WTFMove(completionHandler));
> }
> 
> void NetworkProcessProxy::clearPrevalentResource(PAL::SessionID sessionID, const String& resourceDomain, CompletionHandler<void()>&& completionHandler)
>@@ -484,7 +490,7 @@ void NetworkProcessProxy::clearPrevalentResource(PAL::SessionID sessionID, const
>         return;
>     }
>     
>-    sendWithAsyncReply(Messages::NetworkProcess::ClearPrevalentResource(sessionID, resourceDomain), WTFMove(completionHandler));
>+    sendWithAsyncReply(Messages::NetworkProcess::ClearPrevalentResource(sessionID, RegistrableDomain { resourceDomain }), WTFMove(completionHandler));
> }
>     
> void NetworkProcessProxy::scheduleCookieBlockingUpdate(PAL::SessionID sessionID, CompletionHandler<void()>&& completionHandler)
>@@ -524,7 +530,7 @@ void NetworkProcessProxy::logUserInteraction(PAL::SessionID sessionID, const Str
>         return;
>     }
> 
>-    sendWithAsyncReply(Messages::NetworkProcess::LogUserInteraction(sessionID, resourceDomain), WTFMove(completionHandler));
>+    sendWithAsyncReply(Messages::NetworkProcess::LogUserInteraction(sessionID, RegistrableDomain { resourceDomain }), WTFMove(completionHandler));
> }
> 
> void NetworkProcessProxy::hasHadUserInteraction(PAL::SessionID sessionID, const String& resourceDomain, CompletionHandler<void(bool)>&& completionHandler)
>@@ -534,7 +540,7 @@ void NetworkProcessProxy::hasHadUserInteraction(PAL::SessionID sessionID, const
>         return;
>     }
>     
>-    sendWithAsyncReply(Messages::NetworkProcess::HadUserInteraction(sessionID, resourceDomain), WTFMove(completionHandler));
>+    sendWithAsyncReply(Messages::NetworkProcess::HadUserInteraction(sessionID, RegistrableDomain { resourceDomain }), WTFMove(completionHandler));
> }
> 
> void NetworkProcessProxy::clearUserInteraction(PAL::SessionID sessionID, const String& resourceDomain, CompletionHandler<void()>&& completionHandler)
>@@ -544,7 +550,7 @@ void NetworkProcessProxy::clearUserInteraction(PAL::SessionID sessionID, const S
>         return;
>     }
>     
>-    sendWithAsyncReply(Messages::NetworkProcess::ClearUserInteraction(sessionID, resourceDomain), WTFMove(completionHandler));
>+    sendWithAsyncReply(Messages::NetworkProcess::ClearUserInteraction(sessionID, RegistrableDomain { resourceDomain }), WTFMove(completionHandler));
> }
> 
> void NetworkProcessProxy::setAgeCapForClientSideCookies(PAL::SessionID sessionID, Optional<Seconds> seconds, CompletionHandler<void()>&& completionHandler)
>@@ -594,7 +600,7 @@ void NetworkProcessProxy::setSubframeUnderTopFrameOrigin(PAL::SessionID sessionI
>         return;
>     }
>     
>-    sendWithAsyncReply(Messages::NetworkProcess::SetSubframeUnderTopFrameOrigin(sessionID, subframe, topFrame), WTFMove(completionHandler));
>+    sendWithAsyncReply(Messages::NetworkProcess::SetSubframeUnderTopFrameOrigin(sessionID, RegistrableDomain { subframe }, RegistrableDomain { topFrame }), WTFMove(completionHandler));
> }
> 
> void NetworkProcessProxy::isRegisteredAsRedirectingTo(PAL::SessionID sessionID, const String& redirectedFrom, const String& redirectedTo, CompletionHandler<void(bool)>&& completionHandler)
>@@ -604,7 +610,7 @@ void NetworkProcessProxy::isRegisteredAsRedirectingTo(PAL::SessionID sessionID,
>         return;
>     }
>     
>-    sendWithAsyncReply(Messages::NetworkProcess::IsRegisteredAsRedirectingTo(sessionID, redirectedFrom, redirectedTo), WTFMove(completionHandler));
>+    sendWithAsyncReply(Messages::NetworkProcess::IsRegisteredAsRedirectingTo(sessionID, RegistrableDomain { redirectedFrom }, RegistrableDomain { redirectedTo }), WTFMove(completionHandler));
> }
> 
> void NetworkProcessProxy::isRegisteredAsSubFrameUnder(PAL::SessionID sessionID, const String& subFrame, const String& topFrame, CompletionHandler<void(bool)>&& completionHandler)
>@@ -614,7 +620,7 @@ void NetworkProcessProxy::isRegisteredAsSubFrameUnder(PAL::SessionID sessionID,
>         return;
>     }
>     
>-    sendWithAsyncReply(Messages::NetworkProcess::IsRegisteredAsSubFrameUnder(sessionID, subFrame, topFrame), WTFMove(completionHandler));
>+    sendWithAsyncReply(Messages::NetworkProcess::IsRegisteredAsSubFrameUnder(sessionID, RegistrableDomain { subFrame }, RegistrableDomain { topFrame }), WTFMove(completionHandler));
> }
> 
> void NetworkProcessProxy::setSubresourceUnderTopFrameOrigin(PAL::SessionID sessionID, const String& subresource, const String& topFrame, CompletionHandler<void()>&& completionHandler)
>@@ -624,7 +630,7 @@ void NetworkProcessProxy::setSubresourceUnderTopFrameOrigin(PAL::SessionID sessi
>         return;
>     }
>     
>-    sendWithAsyncReply(Messages::NetworkProcess::SetSubresourceUnderTopFrameOrigin(sessionID, subresource, topFrame), WTFMove(completionHandler));
>+    sendWithAsyncReply(Messages::NetworkProcess::SetSubresourceUnderTopFrameOrigin(sessionID, RegistrableDomain { subresource }, RegistrableDomain { topFrame }), WTFMove(completionHandler));
> }
> 
> void NetworkProcessProxy::isRegisteredAsSubresourceUnder(PAL::SessionID sessionID, const String& subresource, const String& topFrame, CompletionHandler<void(bool)>&& completionHandler)
>@@ -634,7 +640,7 @@ void NetworkProcessProxy::isRegisteredAsSubresourceUnder(PAL::SessionID sessionI
>         return;
>     }
>     
>-    sendWithAsyncReply(Messages::NetworkProcess::IsRegisteredAsSubresourceUnder(sessionID, subresource, topFrame), WTFMove(completionHandler));
>+    sendWithAsyncReply(Messages::NetworkProcess::IsRegisteredAsSubresourceUnder(sessionID, RegistrableDomain { subresource }, RegistrableDomain { topFrame }), WTFMove(completionHandler));
> }
> 
> void NetworkProcessProxy::setSubresourceUniqueRedirectTo(PAL::SessionID sessionID, const String& subresource, const String& hostNameRedirectedTo, CompletionHandler<void()>&& completionHandler)
>@@ -644,7 +650,7 @@ void NetworkProcessProxy::setSubresourceUniqueRedirectTo(PAL::SessionID sessionI
>         return;
>     }
>     
>-    sendWithAsyncReply(Messages::NetworkProcess::SetSubresourceUniqueRedirectTo(sessionID, subresource, hostNameRedirectedTo), WTFMove(completionHandler));
>+    sendWithAsyncReply(Messages::NetworkProcess::SetSubresourceUniqueRedirectTo(sessionID, RegistrableDomain { subresource }, RegistrableDomain { hostNameRedirectedTo }), WTFMove(completionHandler));
> }
> 
> void NetworkProcessProxy::setSubresourceUniqueRedirectFrom(PAL::SessionID sessionID, const String& subresource, const String& hostNameRedirectedFrom, CompletionHandler<void()>&& completionHandler)
>@@ -654,7 +660,7 @@ void NetworkProcessProxy::setSubresourceUniqueRedirectFrom(PAL::SessionID sessio
>         return;
>     }
>     
>-    sendWithAsyncReply(Messages::NetworkProcess::SetSubresourceUniqueRedirectFrom(sessionID, subresource, hostNameRedirectedFrom), WTFMove(completionHandler));
>+    sendWithAsyncReply(Messages::NetworkProcess::SetSubresourceUniqueRedirectFrom(sessionID, RegistrableDomain { subresource }, RegistrableDomain { hostNameRedirectedFrom }), WTFMove(completionHandler));
> }
> 
> void NetworkProcessProxy::setTopFrameUniqueRedirectTo(PAL::SessionID sessionID, const String& topFrameHostName, const String& hostNameRedirectedTo, CompletionHandler<void()>&& completionHandler)
>@@ -664,7 +670,7 @@ void NetworkProcessProxy::setTopFrameUniqueRedirectTo(PAL::SessionID sessionID,
>         return;
>     }
>     
>-    sendWithAsyncReply(Messages::NetworkProcess::SetTopFrameUniqueRedirectTo(sessionID, topFrameHostName, hostNameRedirectedTo), WTFMove(completionHandler));
>+    sendWithAsyncReply(Messages::NetworkProcess::SetTopFrameUniqueRedirectTo(sessionID, RegistrableDomain { topFrameHostName }, RegistrableDomain { hostNameRedirectedTo }), WTFMove(completionHandler));
> }
> 
> void NetworkProcessProxy::setTopFrameUniqueRedirectFrom(PAL::SessionID sessionID, const String& topFrameHostName, const String& hostNameRedirectedFrom, CompletionHandler<void()>&& completionHandler)
>@@ -674,7 +680,7 @@ void NetworkProcessProxy::setTopFrameUniqueRedirectFrom(PAL::SessionID sessionID
>         return;
>     }
>     
>-    sendWithAsyncReply(Messages::NetworkProcess::SetTopFrameUniqueRedirectFrom(sessionID, topFrameHostName, hostNameRedirectedFrom), WTFMove(completionHandler));
>+    sendWithAsyncReply(Messages::NetworkProcess::SetTopFrameUniqueRedirectFrom(sessionID, RegistrableDomain { topFrameHostName }, RegistrableDomain { hostNameRedirectedFrom }), WTFMove(completionHandler));
> }
> 
> void NetworkProcessProxy::isGrandfathered(PAL::SessionID sessionID, const String& resourceDomain, CompletionHandler<void(bool)>&& completionHandler)
>@@ -684,7 +690,7 @@ void NetworkProcessProxy::isGrandfathered(PAL::SessionID sessionID, const String
>         return;
>     }
>     
>-    sendWithAsyncReply(Messages::NetworkProcess::IsGrandfathered(sessionID, resourceDomain), WTFMove(completionHandler));
>+    sendWithAsyncReply(Messages::NetworkProcess::IsGrandfathered(sessionID, RegistrableDomain { resourceDomain }), WTFMove(completionHandler));
> }
> 
> void NetworkProcessProxy::setGrandfathered(PAL::SessionID sessionID, const String& resourceDomain, bool isGrandfathered, CompletionHandler<void()>&& completionHandler)
>@@ -694,7 +700,7 @@ void NetworkProcessProxy::setGrandfathered(PAL::SessionID sessionID, const Strin
>         return;
>     }
>     
>-    sendWithAsyncReply(Messages::NetworkProcess::SetGrandfathered(sessionID, resourceDomain, isGrandfathered), WTFMove(completionHandler));
>+    sendWithAsyncReply(Messages::NetworkProcess::SetGrandfathered(sessionID, RegistrableDomain { resourceDomain }, isGrandfathered), WTFMove(completionHandler));
> }
> 
> void NetworkProcessProxy::hasStorageAccessForFrame(PAL::SessionID sessionID, const String& resourceDomain, const String& firstPartyDomain, uint64_t frameID, uint64_t pageID, CompletionHandler<void(bool)>&& completionHandler)
>@@ -704,7 +710,7 @@ void NetworkProcessProxy::hasStorageAccessForFrame(PAL::SessionID sessionID, con
>         return;
>     }
> 
>-    sendWithAsyncReply(Messages::NetworkProcess::HasStorageAccessForFrame(sessionID, resourceDomain, firstPartyDomain, frameID, pageID), WTFMove(completionHandler));
>+    sendWithAsyncReply(Messages::NetworkProcess::HasStorageAccessForFrame(sessionID, RegistrableDomain { resourceDomain }, RegistrableDomain { firstPartyDomain }, frameID, pageID), WTFMove(completionHandler));
> }
> 
> void NetworkProcessProxy::hasStorageAccess(PAL::SessionID sessionID, const String& resourceDomain, const String& firstPartyDomain, Optional<uint64_t> frameID, uint64_t pageID, CompletionHandler<void(bool)>&& completionHandler)
>@@ -714,7 +720,7 @@ void NetworkProcessProxy::hasStorageAccess(PAL::SessionID sessionID, const Strin
>         return;
>     }
>     
>-    sendWithAsyncReply(Messages::NetworkProcess::HasStorageAccess(sessionID, resourceDomain, firstPartyDomain, frameID, pageID), WTFMove(completionHandler));
>+    sendWithAsyncReply(Messages::NetworkProcess::HasStorageAccess(sessionID, RegistrableDomain { resourceDomain }, RegistrableDomain { 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)
>@@ -724,7 +730,7 @@ void NetworkProcessProxy::requestStorageAccess(PAL::SessionID sessionID, const S
>         return;
>     }
> 
>-    sendWithAsyncReply(Messages::NetworkProcess::RequestStorageAccess(sessionID, resourceDomain, firstPartyDomain, frameID, pageID, promptEnabled), WTFMove(completionHandler));
>+    sendWithAsyncReply(Messages::NetworkProcess::RequestStorageAccess(sessionID, RegistrableDomain { resourceDomain }, RegistrableDomain { firstPartyDomain }, frameID, pageID, promptEnabled), WTFMove(completionHandler));
> }
> 
> void NetworkProcessProxy::requestStorageAccessConfirm(uint64_t pageID, uint64_t frameID, const String& subFrameHost, const String& topFrameHost, CompletionHandler<void(bool)>&& completionHandler)
>@@ -745,7 +751,13 @@ void NetworkProcessProxy::grantStorageAccess(PAL::SessionID sessionID, const Str
>         return;
>     }
> 
>-    sendWithAsyncReply(Messages::NetworkProcess::GrantStorageAccess(sessionID, resourceDomain, firstPartyDomain, frameID.value(), pageID, userWasPrompted), WTFMove(completionHandler));
>+    // FIXME: We should not accept an optional frame ID since we call frameID.value() unconditionally.
>+    if (!frameID) {
>+        completionHandler(false);
>+        return;
>+    }
>+
>+    sendWithAsyncReply(Messages::NetworkProcess::GrantStorageAccess(sessionID, RegistrableDomain { resourceDomain }, RegistrableDomain { firstPartyDomain }, frameID.value(), pageID, userWasPrompted), WTFMove(completionHandler));
> }
> 
> void NetworkProcessProxy::removeAllStorageAccess(PAL::SessionID sessionID, CompletionHandler<void()>&& completionHandler)
>@@ -899,14 +911,14 @@ void NetworkProcessProxy::notifyResourceLoadStatisticsProcessed()
>     WebProcessProxy::notifyPageStatisticsAndDataRecordsProcessed();
> }
> 
>-void NetworkProcessProxy::notifyWebsiteDataDeletionForTopPrivatelyOwnedDomainsFinished()
>+void NetworkProcessProxy::notifyWebsiteDataDeletionForRegistrableDomainsFinished()
> {
>-    WebProcessProxy::notifyWebsiteDataDeletionForTopPrivatelyOwnedDomainsFinished();
>+    WebProcessProxy::notifyWebsiteDataDeletionForRegistrableDomainsFinished();
> }
> 
>-void NetworkProcessProxy::notifyWebsiteDataScanForTopPrivatelyControlledDomainsFinished()
>+void NetworkProcessProxy::notifyWebsiteDataScanForRegistrableDomainsFinished()
> {
>-    WebProcessProxy::notifyWebsiteDataScanForTopPrivatelyControlledDomainsFinished();
>+    WebProcessProxy::notifyWebsiteDataScanForRegistrableDomainsFinished();
> }
> 
> void NetworkProcessProxy::notifyResourceLoadStatisticsTelemetryFinished(unsigned totalPrevalentResources, unsigned totalPrevalentResourcesWithUserInteraction, unsigned top3SubframeUnderTopFrameOrigins)
>diff --git a/Source/WebKit/UIProcess/Network/NetworkProcessProxy.h b/Source/WebKit/UIProcess/Network/NetworkProcessProxy.h
>index b07e6db72eb2172f8225c34a2ea29675a6f443ff..19e256ab0657042e7b45bf22655678201ce940b3 100644
>--- a/Source/WebKit/UIProcess/Network/NetworkProcessProxy.h
>+++ b/Source/WebKit/UIProcess/Network/NetworkProcessProxy.h
>@@ -189,8 +189,8 @@ private:
> #if ENABLE(RESOURCE_LOAD_STATISTICS)
>     void logTestingEvent(PAL::SessionID, const String& event);
>     void notifyResourceLoadStatisticsProcessed();
>-    void notifyWebsiteDataDeletionForTopPrivatelyOwnedDomainsFinished();
>-    void notifyWebsiteDataScanForTopPrivatelyControlledDomainsFinished();
>+    void notifyWebsiteDataDeletionForRegistrableDomainsFinished();
>+    void notifyWebsiteDataScanForRegistrableDomainsFinished();
>     void notifyResourceLoadStatisticsTelemetryFinished(unsigned totalPrevalentResources, unsigned totalPrevalentResourcesWithUserInteraction, unsigned top3SubframeUnderTopFrameOrigins);
> #endif
>     void retrieveCacheStorageParameters(PAL::SessionID);
>diff --git a/Source/WebKit/UIProcess/Network/NetworkProcessProxy.messages.in b/Source/WebKit/UIProcess/Network/NetworkProcessProxy.messages.in
>index f3ed36dab922c13cab57f7b24b7aa63e98178904..8564ddcd8dee3c34c93e350816bc106eebad58b2 100644
>--- a/Source/WebKit/UIProcess/Network/NetworkProcessProxy.messages.in
>+++ b/Source/WebKit/UIProcess/Network/NetworkProcessProxy.messages.in
>@@ -43,8 +43,8 @@ messages -> NetworkProcessProxy LegacyReceiver {
> #if ENABLE(RESOURCE_LOAD_STATISTICS)
>     LogTestingEvent(PAL::SessionID sessionID, String event)
>     NotifyResourceLoadStatisticsProcessed()
>-    NotifyWebsiteDataDeletionForTopPrivatelyOwnedDomainsFinished()
>-    NotifyWebsiteDataScanForTopPrivatelyControlledDomainsFinished()
>+    NotifyWebsiteDataDeletionForRegistrableDomainsFinished()
>+    NotifyWebsiteDataScanForRegistrableDomainsFinished()
>     NotifyResourceLoadStatisticsTelemetryFinished(unsigned totalPrevalentResources, unsigned totalPrevalentResourcesWithUserInteraction, unsigned top3SubframeUnderTopFrameOrigins)
>     RequestStorageAccessConfirm(uint64_t pageID, uint64_t frameID, String subFrameHost, String topFrameHost) -> (bool userDidGrantAccess) Async
> #endif
>diff --git a/Source/WebKit/UIProcess/WebPageProxy.cpp b/Source/WebKit/UIProcess/WebPageProxy.cpp
>index 4a01bf25df27247f1e4494c85950207adc7c7e2c..4520c3dac4a7c6c015b082fa2eb087d97ebe1962 100644
>--- a/Source/WebKit/UIProcess/WebPageProxy.cpp
>+++ b/Source/WebKit/UIProcess/WebPageProxy.cpp
>@@ -4619,12 +4619,8 @@ void WebPageProxy::logFrameNavigation(const WebFrameProxy& frame, const URL& pag
>     
>     if (targetHost.isEmpty() || mainFrameHost.isEmpty() || targetHost == sourceURL.host())
>         return;
>-    
>-    auto targetPrimaryDomain = ResourceLoadStatistics::primaryDomain(targetURL);
>-    auto mainFramePrimaryDomain = ResourceLoadStatistics::primaryDomain(pageURL);
>-    auto sourcePrimaryDomain = ResourceLoadStatistics::primaryDomain(sourceURL);
> 
>-    m_process->processPool().sendToNetworkingProcess(Messages::NetworkProcess::LogFrameNavigation(m_websiteDataStore->sessionID(), targetPrimaryDomain, mainFramePrimaryDomain, sourcePrimaryDomain, targetHost.toString(), mainFrameHost.toString(), isRedirect, frame.isMainFrame()));
>+    m_process->processPool().sendToNetworkingProcess(Messages::NetworkProcess::LogFrameNavigation(m_websiteDataStore->sessionID(), RegistrableDomain { targetURL }, RegistrableDomain { pageURL }, RegistrableDomain { sourceURL }, isRedirect, frame.isMainFrame()));
> }
> #endif
> 
>@@ -8357,7 +8353,9 @@ void WebPageProxy::loadSynchronousURLSchemeTask(URLSchemeTaskParameters&& parame
> #if ENABLE(RESOURCE_LOAD_STATISTICS)
> void WebPageProxy::requestStorageAccessConfirm(const String& subFrameHost, const String& topFrameHost, uint64_t frameID, CompletionHandler<void(bool)>&& completionHandler)
> {
>-    m_uiClient->requestStorageAccessConfirm(*this, m_process->webFrame(frameID), ResourceLoadStatistics::primaryDomain(subFrameHost), ResourceLoadStatistics::primaryDomain(topFrameHost), WTFMove(completionHandler));
>+    RegistrableDomain subFrameRegistrableDomain { subFrameHost };
>+    RegistrableDomain topFrameRegistrableDomain { topFrameHost };
>+    m_uiClient->requestStorageAccessConfirm(*this, m_process->webFrame(frameID), subFrameRegistrableDomain.string(), topFrameRegistrableDomain.string(), WTFMove(completionHandler));
> }
> #endif
> 
>diff --git a/Source/WebKit/UIProcess/WebProcessProxy.cpp b/Source/WebKit/UIProcess/WebProcessProxy.cpp
>index 5033e57d0c78647fe1d11c3f0e3af0e8de8266cb..17465ed4b35029122db8185fc980899ade8dc825 100644
>--- a/Source/WebKit/UIProcess/WebProcessProxy.cpp
>+++ b/Source/WebKit/UIProcess/WebProcessProxy.cpp
>@@ -319,19 +319,19 @@ WebPageProxy* WebProcessProxy::webPage(uint64_t pageID)
> void WebProcessProxy::notifyPageStatisticsAndDataRecordsProcessed()
> {
>     for (auto& page : globalPageMap())
>-        page.value->postMessageToInjectedBundle("WebsiteDataScanForTopPrivatelyControlledDomainsFinished", nullptr);
>+        page.value->postMessageToInjectedBundle("WebsiteDataScanForRegistrableDomainsFinished", nullptr);
> }
> 
>-void WebProcessProxy::notifyWebsiteDataScanForTopPrivatelyControlledDomainsFinished()
>+void WebProcessProxy::notifyWebsiteDataScanForRegistrableDomainsFinished()
> {
>     for (auto& page : globalPageMap())
>-        page.value->postMessageToInjectedBundle("WebsiteDataScanForTopPrivatelyControlledDomainsFinished", nullptr);
>+        page.value->postMessageToInjectedBundle("WebsiteDataScanForRegistrableDomainsFinished", nullptr);
> }
> 
>-void WebProcessProxy::notifyWebsiteDataDeletionForTopPrivatelyOwnedDomainsFinished()
>+void WebProcessProxy::notifyWebsiteDataDeletionForRegistrableDomainsFinished()
> {
>     for (auto& page : globalPageMap())
>-        page.value->postMessageToInjectedBundle("WebsiteDataDeletionForTopPrivatelyOwnedDomainsFinished", nullptr);
>+        page.value->postMessageToInjectedBundle("WebsiteDataDeletionForRegistrableDomainsFinished", nullptr);
> }
> 
> void WebProcessProxy::notifyPageStatisticsTelemetryFinished(API::Object* messageBody)
>diff --git a/Source/WebKit/UIProcess/WebProcessProxy.h b/Source/WebKit/UIProcess/WebProcessProxy.h
>index 94c98d2692483bcb0b87118b2b5e9ad86dcdde9a..06b48a8ede8bc0f268cc89e244827f5c2fba0db9 100644
>--- a/Source/WebKit/UIProcess/WebProcessProxy.h
>+++ b/Source/WebKit/UIProcess/WebProcessProxy.h
>@@ -177,8 +177,8 @@ public:
>     static void notifyPageStatisticsAndDataRecordsProcessed();
>     static void notifyPageStatisticsTelemetryFinished(API::Object* messageBody);
> 
>-    static void notifyWebsiteDataDeletionForTopPrivatelyOwnedDomainsFinished();
>-    static void notifyWebsiteDataScanForTopPrivatelyControlledDomainsFinished();
>+    static void notifyWebsiteDataDeletionForRegistrableDomainsFinished();
>+    static void notifyWebsiteDataScanForRegistrableDomainsFinished();
> #endif
> 
>     void enableSuddenTermination();
>diff --git a/Source/WebKit/UIProcess/WebResourceLoadStatisticsStore.messages.in b/Source/WebKit/UIProcess/WebResourceLoadStatisticsStore.messages.in
>index aa7dc906c0a339eb629ecc8643205927b71357b3..39b4e6f380dea11435a61aec312f0edac4e45895 100644
>--- a/Source/WebKit/UIProcess/WebResourceLoadStatisticsStore.messages.in
>+++ b/Source/WebKit/UIProcess/WebResourceLoadStatisticsStore.messages.in
>@@ -23,7 +23,7 @@
> #if ENABLE(RESOURCE_LOAD_STATISTICS)
> 
> messages -> WebResourceLoadStatisticsStore {
>-    RequestStorageAccessUnderOpener(String domainReceivingUserInteraction, uint64_t openerPageID, String openerDomain)
>+    RequestStorageAccessUnderOpener(WebCore::RegistrableDomain domainReceivingUserInteraction, uint64_t openerPageID, WebCore::RegistrableDomain openerDomain)
>     ResourceLoadStatisticsUpdated(Vector<WebCore::ResourceLoadStatistics> origins)
> }
> 
>diff --git a/Source/WebKit/UIProcess/WebsiteData/WebsiteDataStore.cpp b/Source/WebKit/UIProcess/WebsiteData/WebsiteDataStore.cpp
>index ede93fddcf9ad2797c77bb7bff1b862a98565345..94bd327cf9f978789822e6f8a956843dfd696043 100644
>--- a/Source/WebKit/UIProcess/WebsiteData/WebsiteDataStore.cpp
>+++ b/Source/WebKit/UIProcess/WebsiteData/WebsiteDataStore.cpp
>@@ -48,6 +48,7 @@
> #include <WebCore/DatabaseTracker.h>
> #include <WebCore/HTMLMediaElement.h>
> #include <WebCore/OriginLock.h>
>+#include <WebCore/RegistrableDomain.h>
> #include <WebCore/SecurityOrigin.h>
> #include <WebCore/SecurityOriginData.h>
> #include <wtf/CallbackAggregator.h>
>@@ -619,30 +620,6 @@ 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 {
>-        ASSERT(!RunLoop::isMain());
>-
>-        Vector<WebsiteDataRecord> matchingDataRecords;
>-        HashSet<String> domainsWithMatchingDataRecords;
>-        for (auto&& dataRecord : existingDataRecords) {
>-            for (auto& topPrivatelyControlledDomain : topPrivatelyControlledDomains) {
>-                if (dataRecord.matchesTopPrivatelyControlledDomain(topPrivatelyControlledDomain)) {
>-                    matchingDataRecords.append(WTFMove(dataRecord));
>-                    domainsWithMatchingDataRecords.add(topPrivatelyControlledDomain.isolatedCopy());
>-                    break;
>-                }
>-            }
>-        }
>-        RunLoop::main().dispatch([completionHandler = WTFMove(completionHandler), matchingDataRecords = WTFMove(matchingDataRecords), domainsWithMatchingDataRecords = WTFMove(domainsWithMatchingDataRecords)] () mutable {
>-            completionHandler(WTFMove(matchingDataRecords), WTFMove(domainsWithMatchingDataRecords));
>-        });
>-    });
>-}
>-#endif
>-
> static ProcessAccessType computeNetworkProcessAccessTypeForDataRemoval(OptionSet<WebsiteDataType> dataTypes, bool isNonPersistentStore)
> {
>     ProcessAccessType processAccessType = ProcessAccessType::None;
>@@ -1299,7 +1276,7 @@ void WebsiteDataStore::isPrevalentResource(const URL& url, CompletionHandler<voi
> 
>     for (auto& processPool : processPools()) {
>         if (auto* process = processPool->networkProcess()) {
>-            process->isPrevalentResource(m_sessionID, WebCore::ResourceLoadStatistics::primaryDomain(url), WTFMove(completionHandler));
>+            process->isPrevalentResource(m_sessionID, url.host().toString(), WTFMove(completionHandler));
>             RELEASE_ASSERT(processPools().size() == 1);
>             break;
>         }
>@@ -1318,7 +1295,7 @@ void WebsiteDataStore::setPrevalentResource(const URL& url, CompletionHandler<vo
>     auto callbackAggregator = CallbackAggregator::create(WTFMove(completionHandler));
> 
>     for (auto& processPool : processPools()) {
>-        processPool->ensureNetworkProcess().setPrevalentResource(m_sessionID, WebCore::ResourceLoadStatistics::primaryDomain(url), [processPool, callbackAggregator = callbackAggregator.copyRef()] { });
>+        processPool->ensureNetworkProcess().setPrevalentResource(m_sessionID, url.host().toString(), [processPool, callbackAggregator = callbackAggregator.copyRef()] { });
>     }
> }
> 
>@@ -1335,7 +1312,7 @@ void WebsiteDataStore::setPrevalentResourceForDebugMode(const URL& url, Completi
>     
>     for (auto& processPool : processPools()) {
>         if (auto* process = processPool->networkProcess())
>-            process->setPrevalentResourceForDebugMode(m_sessionID, WebCore::ResourceLoadStatistics::primaryDomain(url), [processPool, callbackAggregator = callbackAggregator.copyRef()] { });
>+            process->setPrevalentResourceForDebugMode(m_sessionID, url.host().toString(), [processPool, callbackAggregator = callbackAggregator.copyRef()] { });
>     }
> }
> 
>@@ -1350,7 +1327,7 @@ void WebsiteDataStore::isVeryPrevalentResource(const URL& url, CompletionHandler
>     
>     for (auto& processPool : processPools()) {
>         if (auto* process = processPool->networkProcess()) {
>-            process->isVeryPrevalentResource(m_sessionID, WebCore::ResourceLoadStatistics::primaryDomain(url), WTFMove(completionHandler));
>+            process->isVeryPrevalentResource(m_sessionID, url.host().toString(), WTFMove(completionHandler));
>             ASSERT(processPools().size() == 1);
>             break;
>         }
>@@ -1370,7 +1347,7 @@ void WebsiteDataStore::setVeryPrevalentResource(const URL& url, CompletionHandle
>     
>     for (auto& processPool : processPools()) {
>         if (auto* process = processPool->networkProcess())
>-            process->setVeryPrevalentResource(m_sessionID, WebCore::ResourceLoadStatistics::primaryDomain(url), [processPool, callbackAggregator = callbackAggregator.copyRef()] { });
>+            process->setVeryPrevalentResource(m_sessionID, url.host().toString(), [processPool, callbackAggregator = callbackAggregator.copyRef()] { });
>     }
> }
> 
>@@ -1384,11 +1361,11 @@ void WebsiteDataStore::setShouldClassifyResourcesBeforeDataRecordsRemoval(bool v
>         processPool->ensureNetworkProcess().setShouldClassifyResourcesBeforeDataRecordsRemoval(m_sessionID, value, [processPool, callbackAggregator = callbackAggregator.copyRef()] { });
> }
> 
>-void WebsiteDataStore::setSubframeUnderTopFrameOrigin(const URL& subframe, const URL& topFrame, CompletionHandler<void()>&& completionHandler)
>+void WebsiteDataStore::setSubframeUnderTopFrameOrigin(const URL& subFrameURL, const URL& topFrameURL, CompletionHandler<void()>&& completionHandler)
> {
>     ASSERT(RunLoop::isMain());
>     
>-    if (subframe.protocolIsAbout() || subframe.isEmpty() || topFrame.protocolIsAbout() || topFrame.isEmpty()) {
>+    if (subFrameURL.protocolIsAbout() || subFrameURL.isEmpty() || topFrameURL.protocolIsAbout() || topFrameURL.isEmpty()) {
>         completionHandler();
>         return;
>     }
>@@ -1397,28 +1374,28 @@ void WebsiteDataStore::setSubframeUnderTopFrameOrigin(const URL& subframe, const
>     
>     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()] { });
>+            process->setSubframeUnderTopFrameOrigin(m_sessionID, subFrameURL.host().toString(), topFrameURL.host().toString(), [processPool, callbackAggregator = callbackAggregator.copyRef()] { });
>     }
> }
> 
>-void WebsiteDataStore::isRegisteredAsSubFrameUnder(const URL& subFrame, const URL& topFrame, CompletionHandler<void(bool)>&& completionHandler)
>+void WebsiteDataStore::isRegisteredAsSubFrameUnder(const URL& subFrameURL, const URL& topFrameURL, CompletionHandler<void(bool)>&& completionHandler)
> {
>     ASSERT(RunLoop::isMain());
> 
>     for (auto& processPool : processPools()) {
>         if (auto* process = processPool->networkProcess()) {
>-            process->isRegisteredAsSubFrameUnder(m_sessionID, WebCore::ResourceLoadStatistics::primaryDomain(subFrame), WebCore::ResourceLoadStatistics::primaryDomain(topFrame), WTFMove(completionHandler));
>+            process->isRegisteredAsSubFrameUnder(m_sessionID, subFrameURL.host().toString(), topFrameURL.host().toString(), WTFMove(completionHandler));
>             ASSERT(processPools().size() == 1);
>             break;
>         }
>     }
> }
> 
>-void WebsiteDataStore::setSubresourceUnderTopFrameOrigin(const URL& subresource, const URL& topFrame, CompletionHandler<void()>&& completionHandler)
>+void WebsiteDataStore::setSubresourceUnderTopFrameOrigin(const URL& subresourceURL, const URL& topFrameURL, CompletionHandler<void()>&& completionHandler)
> {
>     ASSERT(RunLoop::isMain());
>     
>-    if (subresource.protocolIsAbout() || subresource.isEmpty() || topFrame.protocolIsAbout() || topFrame.isEmpty()) {
>+    if (subresourceURL.protocolIsAbout() || subresourceURL.isEmpty() || topFrameURL.protocolIsAbout() || topFrameURL.isEmpty()) {
>         completionHandler();
>         return;
>     }
>@@ -1427,28 +1404,28 @@ void WebsiteDataStore::setSubresourceUnderTopFrameOrigin(const URL& subresource,
>     
>     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()] { });
>+            process->setSubresourceUnderTopFrameOrigin(m_sessionID, subresourceURL.host().toString(), topFrameURL.host().toString(), [processPool, callbackAggregator = callbackAggregator.copyRef()] { });
>     }
> }
> 
>-void WebsiteDataStore::isRegisteredAsSubresourceUnder(const URL& subresource, const URL& topFrame, CompletionHandler<void(bool)>&& completionHandler)
>+void WebsiteDataStore::isRegisteredAsSubresourceUnder(const URL& subresourceURL, const URL& topFrameURL, CompletionHandler<void(bool)>&& completionHandler)
> {
>     ASSERT(RunLoop::isMain());
>     
>     for (auto& processPool : processPools()) {
>         if (auto* process = processPool->networkProcess()) {
>-            process->isRegisteredAsSubresourceUnder(m_sessionID, WebCore::ResourceLoadStatistics::primaryDomain(subresource), WebCore::ResourceLoadStatistics::primaryDomain(topFrame), WTFMove(completionHandler));
>+            process->isRegisteredAsSubresourceUnder(m_sessionID, subresourceURL.host().toString(), topFrameURL.host().toString(), WTFMove(completionHandler));
>             ASSERT(processPools().size() == 1);
>             break;
>         }
>     }
> }
> 
>-void WebsiteDataStore::setSubresourceUniqueRedirectTo(const URL& subresource, const URL& hostNameRedirectedTo, CompletionHandler<void()>&& completionHandler)
>+void WebsiteDataStore::setSubresourceUniqueRedirectTo(const URL& subresourceURL, const URL& urlRedirectedTo, CompletionHandler<void()>&& completionHandler)
> {
>     ASSERT(RunLoop::isMain());
>     
>-    if (subresource.protocolIsAbout() || subresource.isEmpty() || hostNameRedirectedTo.protocolIsAbout() || hostNameRedirectedTo.isEmpty()) {
>+    if (subresourceURL.protocolIsAbout() || subresourceURL.isEmpty() || urlRedirectedTo.protocolIsAbout() || urlRedirectedTo.isEmpty()) {
>         completionHandler();
>         return;
>     }
>@@ -1457,15 +1434,15 @@ void WebsiteDataStore::setSubresourceUniqueRedirectTo(const URL& subresource, co
>     
>     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()] { });
>+            process->setSubresourceUniqueRedirectTo(m_sessionID, subresourceURL.host().toString(), urlRedirectedTo.host().toString(), [processPool, callbackAggregator = callbackAggregator.copyRef()] { });
>     }
> }
> 
>-void WebsiteDataStore::setSubresourceUniqueRedirectFrom(const URL& subresource, const URL& hostNameRedirectedFrom, CompletionHandler<void()>&& completionHandler)
>+void WebsiteDataStore::setSubresourceUniqueRedirectFrom(const URL& subresourceURL, const URL& urlRedirectedFrom, CompletionHandler<void()>&& completionHandler)
> {
>     ASSERT(RunLoop::isMain());
>     
>-    if (subresource.protocolIsAbout() || subresource.isEmpty() || hostNameRedirectedFrom.protocolIsAbout() || hostNameRedirectedFrom.isEmpty()) {
>+    if (subresourceURL.protocolIsAbout() || subresourceURL.isEmpty() || urlRedirectedFrom.protocolIsAbout() || urlRedirectedFrom.isEmpty()) {
>         completionHandler();
>         return;
>     }
>@@ -1474,15 +1451,15 @@ void WebsiteDataStore::setSubresourceUniqueRedirectFrom(const URL& subresource,
>     
>     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()] { });
>+            process->setSubresourceUniqueRedirectFrom(m_sessionID, subresourceURL.host().toString(), urlRedirectedFrom.host().toString(), [processPool, callbackAggregator = callbackAggregator.copyRef()] { });
>     }
> }
> 
>-void WebsiteDataStore::setTopFrameUniqueRedirectTo(const URL& topFrameHostName, const URL& hostNameRedirectedTo, CompletionHandler<void()>&& completionHandler)
>+void WebsiteDataStore::setTopFrameUniqueRedirectTo(const URL& topFrameURL, const URL& urlRedirectedTo, CompletionHandler<void()>&& completionHandler)
> {
>     ASSERT(RunLoop::isMain());
>     
>-    if (topFrameHostName.protocolIsAbout() || topFrameHostName.isEmpty() || hostNameRedirectedTo.protocolIsAbout() || hostNameRedirectedTo.isEmpty()) {
>+    if (topFrameURL.protocolIsAbout() || topFrameURL.isEmpty() || urlRedirectedTo.protocolIsAbout() || urlRedirectedTo.isEmpty()) {
>         completionHandler();
>         return;
>     }
>@@ -1491,15 +1468,15 @@ void WebsiteDataStore::setTopFrameUniqueRedirectTo(const URL& topFrameHostName,
>     
>     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()] { });
>+            process->setTopFrameUniqueRedirectTo(m_sessionID, topFrameURL.host().toString(), urlRedirectedTo.host().toString(), [processPool, callbackAggregator = callbackAggregator.copyRef()] { });
>     }
> }
> 
>-void WebsiteDataStore::setTopFrameUniqueRedirectFrom(const URL& topFrameHostName, const URL& hostNameRedirectedFrom, CompletionHandler<void()>&& completionHandler)
>+void WebsiteDataStore::setTopFrameUniqueRedirectFrom(const URL& topFrameURL, const URL& urlRedirectedFrom, CompletionHandler<void()>&& completionHandler)
> {
>     ASSERT(RunLoop::isMain());
>     
>-    if (topFrameHostName.protocolIsAbout() || topFrameHostName.isEmpty() || hostNameRedirectedFrom.protocolIsAbout() || hostNameRedirectedFrom.isEmpty()) {
>+    if (topFrameURL.protocolIsAbout() || topFrameURL.isEmpty() || urlRedirectedFrom.protocolIsAbout() || urlRedirectedFrom.isEmpty()) {
>         completionHandler();
>         return;
>     }
>@@ -1508,17 +1485,17 @@ void WebsiteDataStore::setTopFrameUniqueRedirectFrom(const URL& topFrameHostName
>     
>     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()] { });
>+            process->setTopFrameUniqueRedirectFrom(m_sessionID, topFrameURL.host().toString(), urlRedirectedFrom.host().toString(), [processPool, callbackAggregator = callbackAggregator.copyRef()] { });
>     }
> }
> 
>-void WebsiteDataStore::isRegisteredAsRedirectingTo(const URL& hostRedirectedFrom, const URL& hostRedirectedTo, CompletionHandler<void(bool)>&& completionHandler)
>+void WebsiteDataStore::isRegisteredAsRedirectingTo(const URL& urlRedirectedFrom, const URL& urlRedirectedTo, CompletionHandler<void(bool)>&& completionHandler)
> {
>     ASSERT(RunLoop::isMain());
>     
>     for (auto& processPool : processPools()) {
>         if (auto* process = processPool->networkProcess()) {
>-            process->isRegisteredAsRedirectingTo(m_sessionID, WebCore::ResourceLoadStatistics::primaryDomain(hostRedirectedFrom), WebCore::ResourceLoadStatistics::primaryDomain(hostRedirectedTo), WTFMove(completionHandler));
>+            process->isRegisteredAsRedirectingTo(m_sessionID, urlRedirectedFrom.host().toString(), urlRedirectedTo.host().toString(), WTFMove(completionHandler));
>             ASSERT(processPools().size() == 1);
>             break;
>         }
>@@ -1536,10 +1513,9 @@ void WebsiteDataStore::clearPrevalentResource(const URL& url, CompletionHandler<
> 
>     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()] { });
>+            process->clearPrevalentResource(m_sessionID, url.host().toString(), [processPool, callbackAggregator = callbackAggregator.copyRef()] { });
>     }
> }
> 
>@@ -1620,10 +1596,9 @@ void WebsiteDataStore::setLastSeen(const URL& url, Seconds seconds, CompletionHa
> 
>     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()] { });
>+            process->setLastSeen(m_sessionID, url.host().toString(), seconds, [processPool, callbackAggregator = callbackAggregator.copyRef()] { });
>     }
> }
> 
>@@ -1655,7 +1630,7 @@ void WebsiteDataStore::getAllStorageAccessEntries(uint64_t pageID, CompletionHan
>     networkProcess.getAllStorageAccessEntries(m_sessionID, WTFMove(completionHandler));
> }
> 
>-void WebsiteDataStore::hasStorageAccess(String&& subFrameHost, String&& topFrameHost, uint64_t frameID, uint64_t pageID, CompletionHandler<void(bool)>&& completionHandler)
>+void WebsiteDataStore::hasStorageAccess(const String& subFrameHost, const String& topFrameHost, uint64_t frameID, uint64_t pageID, CompletionHandler<void(bool)>&& completionHandler)
> {
>     if (!resourceLoadStatisticsEnabled()) {
>         completionHandler(false);
>@@ -1669,10 +1644,10 @@ void WebsiteDataStore::hasStorageAccess(String&& subFrameHost, String&& topFrame
>     }
> 
>     if (auto networkProcess = webPage->process().processPool().networkProcess())
>-        networkProcess->hasStorageAccess(m_sessionID, WebCore::ResourceLoadStatistics::primaryDomain(subFrameHost), WebCore::ResourceLoadStatistics::primaryDomain(topFrameHost), frameID, pageID, WTFMove(completionHandler));
>+        networkProcess->hasStorageAccess(m_sessionID, subFrameHost, topFrameHost, frameID, pageID, WTFMove(completionHandler));
> }
> 
>-void WebsiteDataStore::requestStorageAccess(String&& subFrameHost, String&& topFrameHost, uint64_t frameID, uint64_t pageID, bool promptEnabled, CompletionHandler<void(StorageAccessStatus)>&& completionHandler)
>+void WebsiteDataStore::requestStorageAccess(const String& subFrameHost, const String& topFrameHost, uint64_t frameID, uint64_t pageID, bool promptEnabled, CompletionHandler<void(StorageAccessStatus)>&& completionHandler)
> {
>     if (!resourceLoadStatisticsEnabled()) {
>         completionHandler(StorageAccessStatus::CannotRequestAccess);
>@@ -1686,7 +1661,7 @@ void WebsiteDataStore::requestStorageAccess(String&& subFrameHost, String&& topF
>     }
> 
>     if (auto networkProcess = webPage->process().processPool().networkProcess())
>-        networkProcess->requestStorageAccess(m_sessionID, WebCore::ResourceLoadStatistics::primaryDomain(subFrameHost), WebCore::ResourceLoadStatistics::primaryDomain(topFrameHost), frameID, pageID, promptEnabled, WTFMove(completionHandler));
>+        networkProcess->requestStorageAccess(m_sessionID, subFrameHost, 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)
>@@ -1703,7 +1678,7 @@ void WebsiteDataStore::grantStorageAccess(String&& subFrameHost, String&& topFra
>     }
> 
>     if (auto networkProcess = webPage->process().processPool().networkProcess())
>-        networkProcess->grantStorageAccess(m_sessionID, WebCore::ResourceLoadStatistics::primaryDomain(subFrameHost), WebCore::ResourceLoadStatistics::primaryDomain(topFrameHost), frameID, pageID, userWasPrompted, WTFMove(completionHandler));
>+        networkProcess->grantStorageAccess(m_sessionID, subFrameHost, topFrameHost, frameID, pageID, userWasPrompted, WTFMove(completionHandler));
> }
> 
> void WebsiteDataStore::setTimeToLiveUserInteraction(Seconds seconds, CompletionHandler<void()>&& completionHandler)
>@@ -1727,7 +1702,7 @@ void WebsiteDataStore::logUserInteraction(const URL& url, CompletionHandler<void
> 
>     for (auto& processPool : processPools()) {
>         if (auto* process = processPool->networkProcess())
>-            process->logUserInteraction(m_sessionID, WebCore::ResourceLoadStatistics::primaryDomain(url), [callbackAggregator = callbackAggregator.copyRef()] { });
>+            process->logUserInteraction(m_sessionID, url.host().toString(), [callbackAggregator = callbackAggregator.copyRef()] { });
>     }
> }
> 
>@@ -1742,7 +1717,7 @@ void WebsiteDataStore::hasHadUserInteraction(const URL& url, CompletionHandler<v
>     
>     for (auto& processPool : processPools()) {
>         if (auto* process = processPool->networkProcess()) {
>-            process->hasHadUserInteraction(m_sessionID, WebCore::ResourceLoadStatistics::primaryDomain(url), WTFMove(completionHandler));
>+            process->hasHadUserInteraction(m_sessionID, url.host().toString(), WTFMove(completionHandler));
>             ASSERT(processPools().size() == 1);
>             break;
>         }
>@@ -1762,7 +1737,7 @@ void WebsiteDataStore::clearUserInteraction(const URL& url, CompletionHandler<vo
> 
>     for (auto& processPool : processPools()) {
>         if (auto* process = processPool->networkProcess())
>-            process->clearUserInteraction(m_sessionID, WebCore::ResourceLoadStatistics::primaryDomain(url), [callbackAggregator = callbackAggregator.copyRef()] { });
>+            process->clearUserInteraction(m_sessionID, url.host().toString(), [callbackAggregator = callbackAggregator.copyRef()] { });
>     }
> }
> 
>@@ -1779,7 +1754,7 @@ void WebsiteDataStore::setGrandfathered(const URL& url, bool isGrandfathered, Co
>     
>     for (auto& processPool : processPools()) {
>         if (auto* process = processPool->networkProcess())
>-            process->setGrandfathered(m_sessionID, WebCore::ResourceLoadStatistics::primaryDomain(url), isGrandfathered, [callbackAggregator = callbackAggregator.copyRef()] { });
>+            process->setGrandfathered(m_sessionID, url.host().toString(), isGrandfathered, [callbackAggregator = callbackAggregator.copyRef()] { });
>     }
> }
> #endif // ENABLE(RESOURCE_LOAD_STATISTICS)
>diff --git a/Source/WebKit/UIProcess/WebsiteData/WebsiteDataStore.h b/Source/WebKit/UIProcess/WebsiteData/WebsiteDataStore.h
>index dcadc34efd99eeb966b06ac9edd6cefd2e7e8793..2b6d2770f88b228aa953e4256a8f6b6b1eaa07e8 100644
>--- a/Source/WebKit/UIProcess/WebsiteData/WebsiteDataStore.h
>+++ b/Source/WebKit/UIProcess/WebsiteData/WebsiteDataStore.h
>@@ -125,8 +125,6 @@ public:
>     void removeData(OptionSet<WebsiteDataType>, const Vector<WebsiteDataRecord>&, Function<void()>&& completionHandler);
> 
> #if ENABLE(RESOURCE_LOAD_STATISTICS)
>-    void fetchDataForTopPrivatelyControlledDomains(OptionSet<WebsiteDataType>, OptionSet<WebsiteDataFetchOption>, const Vector<String>& topPrivatelyControlledDomains, Function<void(Vector<WebsiteDataRecord>&&, HashSet<String>&&)>&& completionHandler);
>-
>     void clearPrevalentResource(const URL&, CompletionHandler<void()>&&);
>     void clearUserInteraction(const URL&, CompletionHandler<void()>&&);
>     void dumpResourceLoadStatistics(CompletionHandler<void(const String&)>&&);
>@@ -165,8 +163,8 @@ public:
>     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 hasStorageAccess(const String& subFrameHost, const String& topFrameHost, uint64_t frameID, uint64_t pageID, CompletionHandler<void(bool)>&&);
>+    void requestStorageAccess(const String& subFrameHost, const 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
>diff --git a/Source/WebKit/WebProcess/WebPage/WebPage.cpp b/Source/WebKit/WebProcess/WebPage/WebPage.cpp
>index 192eee4bd8fdb000e64cb9d6fc227052cd22dec4..3634e60147c074caccc5a4ba747ab8af74ac09c7 100644
>--- a/Source/WebKit/WebProcess/WebPage/WebPage.cpp
>+++ b/Source/WebKit/WebProcess/WebPage/WebPage.cpp
>@@ -194,6 +194,7 @@
> #include <WebCore/PrintContext.h>
> #include <WebCore/PromisedAttachmentInfo.h>
> #include <WebCore/Range.h>
>+#include <WebCore/RegistrableDomain.h>
> #include <WebCore/RemoteDOMWindow.h>
> #include <WebCore/RemoteFrame.h>
> #include <WebCore/RenderLayer.h>
>@@ -6401,13 +6402,13 @@ void WebPage::frameBecameRemote(uint64_t frameID, GlobalFrameIdentifier&& remote
> #if ENABLE(RESOURCE_LOAD_STATISTICS)
> void WebPage::hasStorageAccess(String&& subFrameHost, String&& topFrameHost, uint64_t frameID, CompletionHandler<void(bool)>&& completionHandler)
> {
>-    WebProcess::singleton().ensureNetworkProcessConnection().connection().sendWithAsyncReply(Messages::NetworkConnectionToWebProcess::HasStorageAccess(sessionID(), WebCore::ResourceLoadStatistics::primaryDomain(subFrameHost), WebCore::ResourceLoadStatistics::primaryDomain(topFrameHost), frameID, m_pageID), WTFMove(completionHandler));
>+    WebProcess::singleton().ensureNetworkProcessConnection().connection().sendWithAsyncReply(Messages::NetworkConnectionToWebProcess::HasStorageAccess(sessionID(), RegistrableDomain { subFrameHost }, RegistrableDomain { topFrameHost }, frameID, m_pageID), WTFMove(completionHandler));
> }
>     
> void WebPage::requestStorageAccess(String&& subFrameHost, String&& topFrameHost, uint64_t frameID, CompletionHandler<void(bool)>&& completionHandler)
> {
>     bool promptEnabled = RuntimeEnabledFeatures::sharedFeatures().storageAccessPromptsEnabled();
>-    WebProcess::singleton().ensureNetworkProcessConnection().connection().sendWithAsyncReply(Messages::NetworkConnectionToWebProcess::RequestStorageAccess(sessionID(), WebCore::ResourceLoadStatistics::primaryDomain(subFrameHost), WebCore::ResourceLoadStatistics::primaryDomain(topFrameHost), frameID, m_pageID, promptEnabled), WTFMove(completionHandler));
>+    WebProcess::singleton().ensureNetworkProcessConnection().connection().sendWithAsyncReply(Messages::NetworkConnectionToWebProcess::RequestStorageAccess(sessionID(), RegistrableDomain { subFrameHost }, RegistrableDomain { topFrameHost }, frameID, m_pageID, promptEnabled), WTFMove(completionHandler));
> }
> #endif
>     
>diff --git a/Source/WebKit/WebProcess/WebProcess.cpp b/Source/WebKit/WebProcess/WebProcess.cpp
>index 99e9afae49305c7b68db35c88ef3e737ba17775f..042ec4517965470f4be0dcdca4dfa04b7ae844ed 100644
>--- a/Source/WebKit/WebProcess/WebProcess.cpp
>+++ b/Source/WebKit/WebProcess/WebProcess.cpp
>@@ -106,6 +106,7 @@
> #include <WebCore/PlatformKeyboardEvent.h>
> #include <WebCore/PlatformMediaSessionManager.h>
> #include <WebCore/ProcessWarming.h>
>+#include <WebCore/RegistrableDomain.h>
> #include <WebCore/ResourceLoadObserver.h>
> #include <WebCore/ResourceLoadStatistics.h>
> #include <WebCore/RuntimeApplicationChecks.h>
>@@ -211,7 +212,7 @@ WebProcess::WebProcess()
>         m_networkProcessConnection->connection().send(Messages::NetworkConnectionToWebProcess::RequestResourceLoadStatisticsUpdate(), 0);
>     });
> 
>-    ResourceLoadObserver::shared().setRequestStorageAccessUnderOpenerCallback([this] (const String& domainInNeedOfStorageAccess, uint64_t openerPageID, const String& openerDomain) {
>+    ResourceLoadObserver::shared().setRequestStorageAccessUnderOpenerCallback([this] (const RegistrableDomain& domainInNeedOfStorageAccess, uint64_t openerPageID, const RegistrableDomain& openerDomain) {
>         parentProcessConnection()->send(Messages::WebResourceLoadStatisticsStore::RequestStorageAccessUnderOpener(domainInNeedOfStorageAccess, openerPageID, openerDomain), 0);
>     });
> #endif
>@@ -401,20 +402,20 @@ 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);
>+    ResourceLoadObserver::shared().setLogUserInteractionNotificationCallback([this] (PAL::SessionID sessionID, const RegistrableDomain& domain) {
>+        m_networkProcessConnection->connection().send(Messages::NetworkConnectionToWebProcess::LogUserInteraction(sessionID, domain), 0);
>     });
> 
>-    ResourceLoadObserver::shared().setLogWebSocketLoadingNotificationCallback([this] (PAL::SessionID sessionID, const String& targetPrimaryDomain, const String& mainFramePrimaryDomain, WallTime lastSeen) {
>-        m_networkProcessConnection->connection().send(Messages::NetworkConnectionToWebProcess::LogWebSocketLoading(sessionID, targetPrimaryDomain, mainFramePrimaryDomain, lastSeen), 0);
>+    ResourceLoadObserver::shared().setLogWebSocketLoadingNotificationCallback([this] (PAL::SessionID sessionID, const RegistrableDomain& targetDomain, const RegistrableDomain& topFrameDomain, WallTime lastSeen) {
>+        m_networkProcessConnection->connection().send(Messages::NetworkConnectionToWebProcess::LogWebSocketLoading(sessionID, targetDomain, topFrameDomain, lastSeen), 0);
>     });
>     
>-    ResourceLoadObserver::shared().setLogSubresourceLoadingNotificationCallback([this] (PAL::SessionID sessionID, const String& targetPrimaryDomain, const String& mainFramePrimaryDomain, WallTime lastSeen) {
>-        m_networkProcessConnection->connection().send(Messages::NetworkConnectionToWebProcess::LogSubresourceLoading(sessionID, targetPrimaryDomain, mainFramePrimaryDomain, lastSeen), 0);
>+    ResourceLoadObserver::shared().setLogSubresourceLoadingNotificationCallback([this] (PAL::SessionID sessionID, const RegistrableDomain& targetDomain, const RegistrableDomain& topFrameDomain, WallTime lastSeen) {
>+        m_networkProcessConnection->connection().send(Messages::NetworkConnectionToWebProcess::LogSubresourceLoading(sessionID, targetDomain, topFrameDomain, lastSeen), 0);
>     });
> 
>-    ResourceLoadObserver::shared().setLogSubresourceRedirectNotificationCallback([this] (PAL::SessionID sessionID, const String& sourcePrimaryDomain, const String& targetPrimaryDomain) {
>-        m_networkProcessConnection->connection().send(Messages::NetworkConnectionToWebProcess::LogSubresourceRedirect(sessionID, sourcePrimaryDomain, targetPrimaryDomain), 0);
>+    ResourceLoadObserver::shared().setLogSubresourceRedirectNotificationCallback([this] (PAL::SessionID sessionID, const RegistrableDomain& sourceDomain, const RegistrableDomain& targetDomain) {
>+        m_networkProcessConnection->connection().send(Messages::NetworkConnectionToWebProcess::LogSubresourceRedirect(sessionID, sourceDomain, targetDomain), 0);
>     });
> #endif
> 
>diff --git a/Tools/ChangeLog b/Tools/ChangeLog
>index 043bc494ddce5227dbb58e516ef1de4ee4754f4c..fc79a66dd6a1f6e00655f92ffb0226a5533cdfa9 100644
>--- a/Tools/ChangeLog
>+++ b/Tools/ChangeLog
>@@ -1,3 +1,24 @@
>+2019-02-22  John Wilander  <wilander@apple.com>
>+
>+        Introduce and adopt new class RegistrableDomain for eTLD+1
>+        https://bugs.webkit.org/show_bug.cgi?id=194791
>+        <rdar://problem/48179240>
>+
>+        Reviewed by NOBODY (OOPS!).
>+
>+        This patch adds an API test and replaces two instances of
>+        "TopPrivatelyOwnedDomains" with "RegistrableDomains" in message names.
>+
>+        * TestWebKitAPI/TestWebKitAPI.xcodeproj/project.pbxproj:
>+        * TestWebKitAPI/Tests/WebCore/AdClickAttribution.cpp:
>+        (TestWebKitAPI::TEST):
>+            Changed two strings to make sure the registrable domains are still considered
>+            invalid and pass the test.
>+        * TestWebKitAPI/Tests/WebCore/RegistrableDomain.cpp: Added.
>+        (TestWebKitAPI::TEST):
>+        * WebKitTestRunner/InjectedBundle/InjectedBundle.cpp:
>+        (WTR::InjectedBundle::didReceiveMessageToPage):
>+
> 2019-02-22  Chris Dumez  <cdumez@apple.com>
> 
>         Regression(PSON) Unable to preview password-protected documents on iCloud.com
>diff --git a/Tools/TestWebKitAPI/TestWebKitAPI.xcodeproj/project.pbxproj b/Tools/TestWebKitAPI/TestWebKitAPI.xcodeproj/project.pbxproj
>index ad6c5093c7a2c0d77af32b9c498145f72737d6e7..d8759bae1d34097d03b504e471ef52715b5149c3 100644
>--- a/Tools/TestWebKitAPI/TestWebKitAPI.xcodeproj/project.pbxproj
>+++ b/Tools/TestWebKitAPI/TestWebKitAPI.xcodeproj/project.pbxproj
>@@ -348,6 +348,7 @@
> 		63F668221F97F7F90032EE51 /* ApplicationManifest.mm in Sources */ = {isa = PBXBuildFile; fileRef = 63F668201F97C3AA0032EE51 /* ApplicationManifest.mm */; };
> 		6B0A07F721FA9C2B00D57391 /* AdClickAttribution.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 6B0A07F621FA9C2B00D57391 /* AdClickAttribution.cpp */; };
> 		6B306106218A372900F5A802 /* ClosingWebView.mm in Sources */ = {isa = PBXBuildFile; fileRef = 6B306105218A372900F5A802 /* ClosingWebView.mm */; };
>+		6B4E861C2220A5520022F389 /* RegistrableDomain.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 6B4E861B2220A5520022F389 /* RegistrableDomain.cpp */; };
> 		6B9ABE122086952F00D75DE6 /* HTTPParsers.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 6B9ABE112086952F00D75DE6 /* HTTPParsers.cpp */; };
> 		6BFD294C1D5E6C1D008EC968 /* HashCountedSet.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 7A38D7E51C752D5F004F157D /* HashCountedSet.cpp */; };
> 		725C3EF322058A5B007C36FC /* AdditionalSupportedImageTypes.html in Copy Resources */ = {isa = PBXBuildFile; fileRef = 725C3EF2220584BA007C36FC /* AdditionalSupportedImageTypes.html */; };
>@@ -1740,6 +1741,7 @@
> 		63F668201F97C3AA0032EE51 /* ApplicationManifest.mm */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.cpp.objcpp; path = ApplicationManifest.mm; sourceTree = "<group>"; };
> 		6B0A07F621FA9C2B00D57391 /* AdClickAttribution.cpp */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.cpp.cpp; path = AdClickAttribution.cpp; sourceTree = "<group>"; };
> 		6B306105218A372900F5A802 /* ClosingWebView.mm */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.cpp.objcpp; path = ClosingWebView.mm; sourceTree = "<group>"; };
>+		6B4E861B2220A5520022F389 /* RegistrableDomain.cpp */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.cpp.cpp; path = RegistrableDomain.cpp; sourceTree = "<group>"; };
> 		6B9ABE112086952F00D75DE6 /* HTTPParsers.cpp */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.cpp.cpp; path = HTTPParsers.cpp; sourceTree = "<group>"; };
> 		725C3EF2220584BA007C36FC /* AdditionalSupportedImageTypes.html */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text.html; path = AdditionalSupportedImageTypes.html; sourceTree = "<group>"; };
> 		751B05D51F8EAC1A0028A09E /* DatabaseTrackerTest.mm */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.cpp.objcpp; path = DatabaseTrackerTest.mm; sourceTree = "<group>"; };
>@@ -2739,6 +2741,7 @@
> 				CD225C071C45A69200140761 /* ParsedContentRange.cpp */,
> 				AA96CAB421C7DB4200FD2F97 /* ParsedContentType.cpp */,
> 				041A1E33216FFDBC00789E0A /* PublicSuffix.cpp */,
>+				6B4E861B2220A5520022F389 /* RegistrableDomain.cpp */,
> 				F418BE141F71B7DC001970E6 /* RoundedRectTests.cpp */,
> 				CDCFA7A91E45122F00C2433D /* SampleMap.cpp */,
> 				CE06DF9A1E1851F200E570C9 /* SecurityOrigin.cpp */,
>@@ -4220,6 +4223,7 @@
> 				7C83E0C11D0A652F00FEBCF3 /* ProvisionalURLNotChange.mm in Sources */,
> 				041A1E34216FFDBC00789E0A /* PublicSuffix.cpp in Sources */,
> 				7C83E0C21D0A653500FEBCF3 /* QuickLook.mm in Sources */,
>+				6B4E861C2220A5520022F389 /* RegistrableDomain.cpp in Sources */,
> 				7CCE7F0D1A411AE600447C4C /* ReloadPageAfterCrash.cpp in Sources */,
> 				7C83E0C31D0A653A00FEBCF3 /* RemoteObjectRegistry.mm in Sources */,
> 				7CCE7EC91A411A7E00447C4C /* RenderedImageFromDOMNode.mm in Sources */,
>diff --git a/Tools/TestWebKitAPI/Tests/WebCore/AdClickAttribution.cpp b/Tools/TestWebKitAPI/Tests/WebCore/AdClickAttribution.cpp
>index a9ca75d71ef380d52f48c5c01472d8af26083faf..2fae3f252a532fd8a6bdc65a4be969a9c1c0b77d 100644
>--- a/Tools/TestWebKitAPI/Tests/WebCore/AdClickAttribution.cpp
>+++ b/Tools/TestWebKitAPI/Tests/WebCore/AdClickAttribution.cpp
>@@ -100,7 +100,7 @@ TEST(AdClickAttribution, InvalidCampaignId)
> 
> TEST(AdClickAttribution, InvalidSourceHost)
> {
>-    AdClickAttribution attribution(AdClickAttribution::Campaign(max6BitValue), AdClickAttribution::Source("webkitorg"), AdClickAttribution::Destination("example.com"));
>+    AdClickAttribution attribution(AdClickAttribution::Campaign(max6BitValue), AdClickAttribution::Source(""), AdClickAttribution::Destination("example.com"));
>     attribution.setConversion(AdClickAttribution::Conversion(max6BitValue, AdClickAttribution::Priority(max6BitValue)));
> 
>     auto attributionURL = attribution.url();
>@@ -112,7 +112,7 @@ TEST(AdClickAttribution, InvalidSourceHost)
> 
> TEST(AdClickAttribution, InvalidDestinationHost)
> {
>-    AdClickAttribution attribution(AdClickAttribution::Campaign(max6BitValue + 1), AdClickAttribution::Source("webkit.org"), AdClickAttribution::Destination("examplecom"));
>+    AdClickAttribution attribution(AdClickAttribution::Campaign(max6BitValue + 1), AdClickAttribution::Source("webkit.org"), AdClickAttribution::Destination(""));
>     attribution.setConversion(AdClickAttribution::Conversion(max6BitValue, AdClickAttribution::Priority(max6BitValue)));
> 
>     auto attributionURL = attribution.url();
>diff --git a/Tools/TestWebKitAPI/Tests/WebCore/RegistrableDomain.cpp b/Tools/TestWebKitAPI/Tests/WebCore/RegistrableDomain.cpp
>new file mode 100644
>index 0000000000000000000000000000000000000000..bf6cd100721a14ef6c00a54cae3b45bf23e07000
>--- /dev/null
>+++ b/Tools/TestWebKitAPI/Tests/WebCore/RegistrableDomain.cpp
>@@ -0,0 +1,61 @@
>+/*
>+ * Copyright (C) 2019 Apple Inc. All rights reserved.
>+ *
>+ * Redistribution and use in source and binary forms, with or without
>+ * modification, are permitted provided that the following conditions
>+ * are met:
>+ * 1. Redistributions of source code must retain the above copyright
>+ *    notice, this list of conditions and the following disclaimer.
>+ * 2. Redistributions in binary form must reproduce the above copyright
>+ *    notice, this list of conditions and the following disclaimer in the
>+ *    documentation and/or other materials provided with the distribution.
>+ *
>+ * THIS SOFTWARE IS PROVIDED BY APPLE INC. AND ITS CONTRIBUTORS ``AS IS''
>+ * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO,
>+ * THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
>+ * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL APPLE INC. OR ITS CONTRIBUTORS
>+ * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
>+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
>+ * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
>+ * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
>+ * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
>+ * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF
>+ * THE POSSIBILITY OF SUCH DAMAGE.
>+ */
>+
>+#include "config.h"
>+
>+#include <WebCore/RegistrableDomain.h>
>+#include <wtf/URL.h>
>+
>+using namespace WebCore;
>+
>+namespace TestWebKitAPI {
>+
>+TEST(RegistrableDomain, MatchesURLs)
>+{
>+    URL webkitURL { URL(), "https://webkit.org" };
>+    URL webkitURLWithPath { URL(), "https://webkit.org/road/to/nowhere/" };
>+    URL webkitSubdomainURL { URL(), "https://sub.domain.webkit.org" };
>+    URL webkitSubdomainURLWithPath { URL(), "https://sub.domain.webkit.org/road/to/nowhere/" };
>+    RegistrableDomain webkitDomain { webkitURL };
>+
>+    ASSERT_TRUE(webkitDomain.matches(webkitURL));
>+    ASSERT_TRUE(webkitDomain.matches(webkitURLWithPath));
>+    ASSERT_TRUE(webkitDomain.matches(webkitSubdomainURL));
>+    ASSERT_TRUE(webkitDomain.matches(webkitSubdomainURLWithPath));
>+
>+    URL localhostURL { URL(), "http://localhost" };
>+    URL localhostURLWithPath { URL(), "http://localhost/road/to/nowhere/" };
>+    RegistrableDomain localhostDomain { localhostURL };
>+
>+    ASSERT_TRUE(localhostDomain.matches(localhostURL));
>+    ASSERT_TRUE(localhostDomain.matches(localhostURLWithPath));
>+
>+    ASSERT_FALSE(localhostDomain.matches(webkitURL));
>+    ASSERT_FALSE(localhostDomain.matches(webkitSubdomainURLWithPath));
>+    ASSERT_FALSE(webkitDomain.matches(localhostURL));
>+    ASSERT_FALSE(webkitDomain.matches(localhostURLWithPath));
>+}
>+
>+} // namespace TestWebKitAPI
>diff --git a/Tools/WebKitTestRunner/InjectedBundle/InjectedBundle.cpp b/Tools/WebKitTestRunner/InjectedBundle/InjectedBundle.cpp
>index e415f905130cc6f1809abce00c7804b69fcee089..70540f18b0afe766087ab62cef100265f5df1add 100644
>--- a/Tools/WebKitTestRunner/InjectedBundle/InjectedBundle.cpp
>+++ b/Tools/WebKitTestRunner/InjectedBundle/InjectedBundle.cpp
>@@ -416,12 +416,12 @@ void InjectedBundle::didReceiveMessageToPage(WKBundlePageRef page, WKStringRef m
>         return;
>     }
> 
>-    if (WKStringIsEqualToUTF8CString(messageName, "WebsiteDataDeletionForTopPrivatelyOwnedDomainsFinished")) {
>+    if (WKStringIsEqualToUTF8CString(messageName, "WebsiteDataDeletionForRegistrableDomainsFinished")) {
>         m_testRunner->statisticsDidModifyDataRecordsCallback();
>         return;
>     }
> 
>-    if (WKStringIsEqualToUTF8CString(messageName, "WebsiteDataScanForTopPrivatelyControlledDomainsFinished")) {
>+    if (WKStringIsEqualToUTF8CString(messageName, "WebsiteDataScanForRegistrableDomainsFinished")) {
>         m_testRunner->statisticsDidScanDataRecordsCallback();
>         return;
>     }

Actions: View | Formatted Diff | Diff

Attachments on bug 194791: 362683 | 362692 | 362696 | 362789 | 362920