Changeset 258932 in webkit


Ignore:
Timestamp:
Mar 24, 2020 1:14:06 PM (4 years ago)
Author:
Chris Dumez
Message:

Unreviewed, reverting r258928.

Broke the build

Reverted changeset:

"Refactor
ResourceLoadStatisticsStore::registrableDomainsToDeleteOrRestrictWebsiteDataFor()
to return a struct instead of a Vector of pairs"
https://bugs.webkit.org/show_bug.cgi?id=209463
https://trac.webkit.org/changeset/258928

Location:
trunk/Source/WebKit
Files:
13 edited

Legend:

Unmodified
Added
Removed
  • trunk/Source/WebKit/ChangeLog

    r258928 r258932  
     12020-03-24  Chris Dumez  <cdumez@apple.com>
     2
     3        Unreviewed, reverting r258928.
     4
     5        Broke the build
     6
     7        Reverted changeset:
     8
     9        "Refactor
     10        ResourceLoadStatisticsStore::registrableDomainsToDeleteOrRestrictWebsiteDataFor()
     11        to return a struct instead of a Vector of pairs"
     12        https://bugs.webkit.org/show_bug.cgi?id=209463
     13        https://trac.webkit.org/changeset/258928
     14
    1152020-03-24  John Wilander  <wilander@apple.com>
    216
  • trunk/Source/WebKit/NetworkProcess/Classifier/ResourceLoadStatisticsDatabaseStore.cpp

    r258928 r258932  
    23542354}
    23552355
    2356 RegistrableDomainsToDeleteOrRestrictWebsiteDataFor ResourceLoadStatisticsDatabaseStore::registrableDomainsToDeleteOrRestrictWebsiteDataFor()
     2356Vector<std::pair<RegistrableDomain, WebsiteDataToRemove>> ResourceLoadStatisticsDatabaseStore::registrableDomainsToRemoveWebsiteDataFor()
    23572357{
    23582358    ASSERT(!RunLoop::isMain());
     
    23682368    auto now = WallTime::now();
    23692369    auto oldestUserInteraction = now;
    2370     RegistrableDomainsToDeleteOrRestrictWebsiteDataFor toDeleteOrRestrictFor;
     2370    Vector<std::pair<RegistrableDomain, WebsiteDataToRemove>> domainsToRemoveWebsiteDataFor;
    23712371
    23722372    Vector<DomainData> domains = this->domains();
     
    23742374    for (auto& statistic : domains) {
    23752375        oldestUserInteraction = std::min(oldestUserInteraction, statistic.mostRecentUserInteractionTime);
    2376         if (shouldRemoveAllWebsiteDataFor(statistic, shouldCheckForGrandfathering)) {
    2377             toDeleteOrRestrictFor.domainsToDeleteAllCookiesFor.append(statistic.registrableDomain);
    2378             toDeleteOrRestrictFor.domainsToDeleteAllNonCookieWebsiteDataFor.append(statistic.registrableDomain);
    2379         } else if (shouldRemoveAllButCookiesFor(statistic, shouldCheckForGrandfathering)) {
    2380             toDeleteOrRestrictFor.domainsToDeleteAllNonCookieWebsiteDataFor.append(statistic.registrableDomain);
     2376        if (shouldRemoveAllWebsiteDataFor(statistic, shouldCheckForGrandfathering))
     2377            domainsToRemoveWebsiteDataFor.append(std::make_pair(statistic.registrableDomain, WebsiteDataToRemove::All));
     2378        else if (shouldRemoveAllButCookiesFor(statistic, shouldCheckForGrandfathering)) {
     2379            domainsToRemoveWebsiteDataFor.append(std::make_pair(statistic.registrableDomain, WebsiteDataToRemove::AllButCookies));
    23812380            setIsScheduledForAllButCookieDataRemoval(statistic.registrableDomain, false);
    23822381        }
     
    23862385
    23872386    // Give the user enough time to interact with websites until we remove non-cookie website data.
    2388     if (!parameters().isRunningTest && now - oldestUserInteraction > parameters().minimumTimeBetweenDataRecordsRemoval)
    2389         toDeleteOrRestrictFor.domainsToDeleteAllNonCookieWebsiteDataFor.clear();
     2387    if (!parameters().isRunningTest && now - oldestUserInteraction > parameters().minimumTimeBetweenDataRecordsRemoval) {
     2388        domainsToRemoveWebsiteDataFor.removeAllMatching([&] (auto& pair) {
     2389            return pair.second == WebsiteDataToRemove::AllButCookies;
     2390        });
     2391    }
    23902392
    23912393    clearGrandfathering(WTFMove(domainIDsToClearGrandfathering));
    23922394   
    2393     return toDeleteOrRestrictFor;
     2395    return domainsToRemoveWebsiteDataFor;
    23942396}
    23952397
  • trunk/Source/WebKit/NetworkProcess/Classifier/ResourceLoadStatisticsDatabaseStore.h

    r258928 r258932  
    216216    bool shouldRemoveAllWebsiteDataFor(const DomainData&, bool shouldCheckForGrandfathering);
    217217    bool shouldRemoveAllButCookiesFor(const DomainData&, bool shouldCheckForGrandfathering);
    218     RegistrableDomainsToDeleteOrRestrictWebsiteDataFor registrableDomainsToDeleteOrRestrictWebsiteDataFor() override;
     218    Vector<std::pair<RegistrableDomain, WebsiteDataToRemove>> registrableDomainsToRemoveWebsiteDataFor() override;
    219219    bool isDatabaseStore() const final { return true; }
    220220
  • trunk/Source/WebKit/NetworkProcess/Classifier/ResourceLoadStatisticsMemoryStore.cpp

    r258928 r258932  
    915915}
    916916
    917 RegistrableDomainsToDeleteOrRestrictWebsiteDataFor ResourceLoadStatisticsMemoryStore::registrableDomainsToDeleteOrRestrictWebsiteDataFor()
     917Vector<std::pair<RegistrableDomain, WebsiteDataToRemove>> ResourceLoadStatisticsMemoryStore::registrableDomainsToRemoveWebsiteDataFor()
    918918{
    919919    ASSERT(!RunLoop::isMain());
     
    927927    auto now = WallTime::now();
    928928    auto oldestUserInteraction = now;
    929     RegistrableDomainsToDeleteOrRestrictWebsiteDataFor toDeleteOrRestrictFor;
     929    Vector<std::pair<RegistrableDomain, WebsiteDataToRemove>> domainsToRemoveWebsiteDataFor;
    930930    for (auto& statistic : m_resourceStatisticsMap.values()) {
    931931        oldestUserInteraction = std::min(oldestUserInteraction, statistic.mostRecentUserInteractionTime);
    932         if (shouldRemoveAllWebsiteDataFor(statistic, shouldCheckForGrandfathering)) {
    933             toDeleteOrRestrictFor.domainsToDeleteAllCookiesFor.append(statistic.registrableDomain);
    934             toDeleteOrRestrictFor.domainsToDeleteAllNonCookieWebsiteDataFor.append(statistic.registrableDomain);
    935         } else if (shouldRemoveAllButCookiesFor(statistic, shouldCheckForGrandfathering)) {
    936             toDeleteOrRestrictFor.domainsToDeleteAllNonCookieWebsiteDataFor.append(statistic.registrableDomain);
     932        if (shouldRemoveAllWebsiteDataFor(statistic, shouldCheckForGrandfathering))
     933            domainsToRemoveWebsiteDataFor.append(std::make_pair(statistic.registrableDomain, WebsiteDataToRemove::All));
     934        else if (shouldRemoveAllButCookiesFor(statistic, shouldCheckForGrandfathering)) {
     935            domainsToRemoveWebsiteDataFor.append(std::make_pair(statistic.registrableDomain, WebsiteDataToRemove::AllButCookies));
    937936            statistic.gotLinkDecorationFromPrevalentResource = false;
    938937        }
     
    943942
    944943    // Give the user enough time to interact with websites until we remove non-cookie website data.
    945     if (!parameters().isRunningTest && now - oldestUserInteraction > parameters().minimumTimeBetweenDataRecordsRemoval)
    946         toDeleteOrRestrictFor.domainsToDeleteAllNonCookieWebsiteDataFor.clear();
    947 
    948     return toDeleteOrRestrictFor;
     944    if (!parameters().isRunningTest && now - oldestUserInteraction > parameters().minimumTimeBetweenDataRecordsRemoval) {
     945        domainsToRemoveWebsiteDataFor.removeAllMatching([&] (auto& pair) {
     946            return pair.second == WebsiteDataToRemove::AllButCookies;
     947        });
     948    }
     949
     950    return domainsToRemoveWebsiteDataFor;
    949951}
    950952
  • trunk/Source/WebKit/NetworkProcess/Classifier/ResourceLoadStatisticsMemoryStore.h

    r258928 r258932  
    131131    void pruneStatisticsIfNeeded() override;
    132132    ResourceLoadStatistics& ensureResourceStatisticsForRegistrableDomain(const RegistrableDomain&);
    133     RegistrableDomainsToDeleteOrRestrictWebsiteDataFor registrableDomainsToDeleteOrRestrictWebsiteDataFor() override;
     133    Vector<std::pair<RegistrableDomain, WebsiteDataToRemove>> registrableDomainsToRemoveWebsiteDataFor() override;
    134134    bool isMemoryStore() const final { return true; }
    135135
  • trunk/Source/WebKit/NetworkProcess/Classifier/ResourceLoadStatisticsStore.cpp

    r258928 r258932  
    6868}
    6969
    70 static String domainsToString(const RegistrableDomainsToDeleteOrRestrictWebsiteDataFor& domainsToRemoveOrRestrictWebsiteDataFor)
     70static String domainsToString(const Vector<std::pair<RegistrableDomain, WebsiteDataToRemove>>& domainsToRemoveWebsiteDataFor)
    7171{
    7272    StringBuilder builder;
    73     for (auto& domain : domainsToRemoveOrRestrictWebsiteDataFor.domainsToDeleteAllCookiesFor) {
     73    for (auto& pair : domainsToRemoveWebsiteDataFor) {
     74        auto& domain = pair.first;
     75        auto& dataToRemove = pair.second;
    7476        if (!builder.isEmpty())
    7577            builder.appendLiteral(", ");
    7678        builder.append(domain.string());
    77         builder.appendLiteral("(all data)");
    78     }
    79     for (auto& domain : domainsToRemoveOrRestrictWebsiteDataFor.domainsToDeleteAllButHttpOnlyCookiesFor) {
    80         if (!builder.isEmpty())
    81             builder.appendLiteral(", ");
    82         builder.append(domain.string());
    83         builder.appendLiteral("(all but HttpOnly cookies)");
    84     }
    85     for (auto& domain : domainsToRemoveOrRestrictWebsiteDataFor.domainsToDeleteAllNonCookieWebsiteDataFor) {
    86         if (!builder.isEmpty())
    87             builder.appendLiteral(", ");
    88         builder.append(domain.string());
    89         builder.appendLiteral("(all but cookies)");
     79        switch (dataToRemove) {
     80        case WebsiteDataToRemove::All:
     81            builder.appendLiteral("(all data)");
     82            break;
     83        case WebsiteDataToRemove::AllButHttpOnlyCookies:
     84            builder.appendLiteral("(all but HttpOnly cookies)");
     85            break;
     86        case WebsiteDataToRemove::AllButCookies:
     87            builder.appendLiteral("(all but cookies)");
     88            break;
     89        }
    9090    }
    9191    return builder.toString();
     
    200200#endif
    201201
    202     auto domainsToDeleteOrRestrictWebsiteDataFor = registrableDomainsToDeleteOrRestrictWebsiteDataFor();
    203     if (domainsToDeleteOrRestrictWebsiteDataFor.isEmpty()) {
     202    auto domainsToRemoveWebsiteDataFor = registrableDomainsToRemoveWebsiteDataFor();
     203    if (domainsToRemoveWebsiteDataFor.isEmpty()) {
    204204        completionHandler();
    205205        return;
    206206    }
    207207
    208     RELEASE_LOG_INFO_IF(m_debugLoggingEnabled, ITPDebug, "About to remove data records for %" PUBLIC_LOG_STRING ".", domainsToString(domainsToDeleteOrRestrictWebsiteDataFor).utf8().data());
     208    RELEASE_LOG_INFO_IF(m_debugLoggingEnabled, ITPDebug, "About to remove data records for %" PUBLIC_LOG_STRING ".", domainsToString(domainsToRemoveWebsiteDataFor).utf8().data());
    209209
    210210    setDataRecordsBeingRemoved(true);
    211211
    212     RunLoop::main().dispatch([store = makeRef(m_store), domainsToDeleteOrRestrictWebsiteDataFor = crossThreadCopy(domainsToDeleteOrRestrictWebsiteDataFor), completionHandler = WTFMove(completionHandler), weakThis = makeWeakPtr(*this), shouldNotifyPagesWhenDataRecordsWereScanned = m_parameters.shouldNotifyPagesWhenDataRecordsWereScanned, workQueue = m_workQueue.copyRef()] () mutable {
    213         store->deleteAndRestrictWebsiteDataForRegistrableDomains(WebResourceLoadStatisticsStore::monitoredDataTypes(), WTFMove(domainsToDeleteOrRestrictWebsiteDataFor), shouldNotifyPagesWhenDataRecordsWereScanned, [completionHandler = WTFMove(completionHandler), weakThis = WTFMove(weakThis), workQueue = workQueue.copyRef()](const HashSet<RegistrableDomain>& domainsWithDeletedWebsiteData) mutable {
     212    RunLoop::main().dispatch([store = makeRef(m_store), domainsToRemoveWebsiteDataFor = crossThreadCopy(domainsToRemoveWebsiteDataFor), completionHandler = WTFMove(completionHandler), weakThis = makeWeakPtr(*this), shouldNotifyPagesWhenDataRecordsWereScanned = m_parameters.shouldNotifyPagesWhenDataRecordsWereScanned, workQueue = m_workQueue.copyRef()] () mutable {
     213        store->deleteWebsiteDataForRegistrableDomains(WebResourceLoadStatisticsStore::monitoredDataTypes(), WTFMove(domainsToRemoveWebsiteDataFor), shouldNotifyPagesWhenDataRecordsWereScanned, [completionHandler = WTFMove(completionHandler), weakThis = WTFMove(weakThis), workQueue = workQueue.copyRef()](const HashSet<RegistrableDomain>& domainsWithDeletedWebsiteData) mutable {
    214214            workQueue->dispatch([domainsWithDeletedWebsiteData = crossThreadCopy(domainsWithDeletedWebsiteData), completionHandler = WTFMove(completionHandler), weakThis = WTFMove(weakThis)] () mutable {
    215215                if (!weakThis) {
  • trunk/Source/WebKit/NetworkProcess/Classifier/ResourceLoadStatisticsStore.h

    r258928 r258932  
    204204    void mergeOperatingDates(Vector<OperatingDate>&&);
    205205    virtual Vector<RegistrableDomain> ensurePrevalentResourcesForDebugMode() = 0;
    206     virtual RegistrableDomainsToDeleteOrRestrictWebsiteDataFor registrableDomainsToDeleteOrRestrictWebsiteDataFor() = 0;
     206    virtual Vector<std::pair<RegistrableDomain, WebsiteDataToRemove>> registrableDomainsToRemoveWebsiteDataFor() = 0;
    207207    virtual void pruneStatisticsIfNeeded() = 0;
    208208
  • trunk/Source/WebKit/NetworkProcess/Classifier/WebResourceLoadStatisticsStore.cpp

    r258928 r258932  
    12491249}
    12501250
    1251 void WebResourceLoadStatisticsStore::deleteAndRestrictWebsiteDataForRegistrableDomains(OptionSet<WebsiteDataType> dataTypes, RegistrableDomainsToDeleteOrRestrictWebsiteDataFor&& domainsToDeleteAndRestrictWebsiteDataFor, bool shouldNotifyPage, CompletionHandler<void(const HashSet<RegistrableDomain>&)>&& completionHandler)
     1251void WebResourceLoadStatisticsStore::deleteWebsiteDataForRegistrableDomains(OptionSet<WebsiteDataType> dataTypes, Vector<std::pair<RegistrableDomain, WebsiteDataToRemove>>&& domainsToRemoveWebsiteDataFor, bool shouldNotifyPage, CompletionHandler<void(const HashSet<RegistrableDomain>&)>&& completionHandler)
    12521252{
    12531253    ASSERT(RunLoop::isMain());
    12541254   
    12551255    if (m_networkSession) {
    1256         m_networkSession->deleteAndRestrictWebsiteDataForRegistrableDomains(dataTypes, WTFMove(domainsToDeleteAndRestrictWebsiteDataFor), shouldNotifyPage, WTFMove(completionHandler));
     1256        m_networkSession->deleteWebsiteDataForRegistrableDomains(dataTypes, WTFMove(domainsToRemoveWebsiteDataFor), shouldNotifyPage, WTFMove(completionHandler));
    12571257        return;
    12581258    }
  • trunk/Source/WebKit/NetworkProcess/Classifier/WebResourceLoadStatisticsStore.h

    r258928 r258932  
    7171enum class ShouldIncludeLocalhost : bool { No, Yes };
    7272enum class EnableResourceLoadStatisticsDebugMode : bool { No, Yes };
     73enum class WebsiteDataToRemove : uint8_t {
     74    All,
     75    AllButHttpOnlyCookies,
     76    AllButCookies
     77};
    7378struct RegistrableDomainsToBlockCookiesFor {
    7479    Vector<WebCore::RegistrableDomain> domainsToBlockAndDeleteCookiesFor;
     
    7681    Vector<WebCore::RegistrableDomain> domainsWithUserInteractionAsFirstParty;
    7782    RegistrableDomainsToBlockCookiesFor isolatedCopy() const { return { domainsToBlockAndDeleteCookiesFor.isolatedCopy(), domainsToBlockButKeepCookiesFor.isolatedCopy(), domainsWithUserInteractionAsFirstParty.isolatedCopy() }; }
    78 };
    79 struct RegistrableDomainsToDeleteOrRestrictWebsiteDataFor {
    80     Vector<WebCore::RegistrableDomain> domainsToDeleteAllCookiesFor;
    81     Vector<WebCore::RegistrableDomain> domainsToDeleteAllButHttpOnlyCookiesFor;
    82     Vector<WebCore::RegistrableDomain> domainsToDeleteAllNonCookieWebsiteDataFor;
    83     RegistrableDomainsToDeleteOrRestrictWebsiteDataFor isolatedCopy() const { return { domainsToDeleteAllCookiesFor.isolatedCopy(), domainsToDeleteAllButHttpOnlyCookiesFor.isolatedCopy(), domainsToDeleteAllNonCookieWebsiteDataFor.isolatedCopy() }; }
    84     bool isEmpty() const { return domainsToDeleteAllCookiesFor.isEmpty() && domainsToDeleteAllButHttpOnlyCookiesFor.isEmpty() && domainsToDeleteAllNonCookieWebsiteDataFor.isEmpty(); }
    8583};
    8684
     
    218216    void logCrossSiteLoadWithLinkDecoration(const NavigatedFromDomain&, const NavigatedToDomain&, CompletionHandler<void()>&&);
    219217    void clearUserInteraction(const TopFrameDomain&, CompletionHandler<void()>&&);
    220     void deleteAndRestrictWebsiteDataForRegistrableDomains(OptionSet<WebsiteDataType>, RegistrableDomainsToDeleteOrRestrictWebsiteDataFor&&, bool shouldNotifyPage, CompletionHandler<void(const HashSet<RegistrableDomain>&)>&&);
     218    void deleteWebsiteDataForRegistrableDomains(OptionSet<WebsiteDataType>, Vector<std::pair<RegistrableDomain, WebsiteDataToRemove>>&&, bool shouldNotifyPage, CompletionHandler<void(const HashSet<RegistrableDomain>&)>&&);
    221219    void registrableDomainsWithWebsiteData(OptionSet<WebsiteDataType>, bool shouldNotifyPage, CompletionHandler<void(HashSet<RegistrableDomain>&&)>&&);
    222220    StorageAccessWasGranted grantStorageAccess(const SubFrameDomain&, const TopFrameDomain&, Optional<WebCore::FrameIdentifier>, WebCore::PageIdentifier);
  • trunk/Source/WebKit/NetworkProcess/NetworkProcess.cpp

    r258928 r258932  
    17101710}
    17111711
    1712 void NetworkProcess::deleteAndRestrictWebsiteDataForRegistrableDomains(PAL::SessionID sessionID, OptionSet<WebsiteDataType> websiteDataTypes, RegistrableDomainsToDeleteOrRestrictWebsiteDataFor&& domains, bool shouldNotifyPage, CompletionHandler<void(const HashSet<RegistrableDomain>&)>&& completionHandler)
     1712void NetworkProcess::deleteWebsiteDataForRegistrableDomains(PAL::SessionID sessionID, OptionSet<WebsiteDataType> websiteDataTypes, Vector<std::pair<RegistrableDomain, WebsiteDataToRemove>>&& domains, bool shouldNotifyPage, CompletionHandler<void(const HashSet<RegistrableDomain>&)>&& completionHandler)
    17131713{
    17141714    OptionSet<WebsiteDataFetchOption> fetchOptions = WebsiteDataFetchOption::DoNotCreateProcesses;
     
    17421742    HashSet<String> hostNamesWithCookies;
    17431743    HashSet<String> hostNamesWithHSTSCache;
     1744
     1745    Vector<RegistrableDomain> domainsToDeleteCookiesFor;
     1746    Vector<RegistrableDomain> domainsToDeleteAllButHttpOnlyCookiesFor;
     1747    Vector<RegistrableDomain> domainsToDeleteAllButCookiesFor;
    17441748    Vector<String> hostnamesWithCookiesToDelete;
    1745     auto domainsToDeleteAllNonCookieWebsiteDataFor = domains.domainsToDeleteAllNonCookieWebsiteDataFor;
    17461749    if (websiteDataTypes.contains(WebsiteDataType::Cookies)) {
     1750        for (auto& pair : domains) {
     1751            auto& domain = pair.first;
     1752            auto& dataToRemove = pair.second;
     1753            domainsToDeleteAllButCookiesFor.append(domain);
     1754            switch (dataToRemove) {
     1755            case WebsiteDataToRemove::All:
     1756                domainsToDeleteCookiesFor.append(domain);
     1757                break;
     1758            case WebsiteDataToRemove::AllButHttpOnlyCookies:
     1759                domainsToDeleteAllButHttpOnlyCookiesFor.append(domain);
     1760                break;
     1761            case WebsiteDataToRemove::AllButCookies:
     1762                // Already added.
     1763                break;
     1764            }
     1765        }
    17471766        if (auto* networkStorageSession = storageSession(sessionID)) {
    17481767            networkStorageSession->getHostnamesWithCookies(hostNamesWithCookies);
    17491768
    1750             hostnamesWithCookiesToDelete = filterForRegistrableDomains(domains.domainsToDeleteAllCookiesFor, hostNamesWithCookies);
     1769            hostnamesWithCookiesToDelete = filterForRegistrableDomains(domainsToDeleteCookiesFor, hostNamesWithCookies);
    17511770            networkStorageSession->deleteCookiesForHostnames(hostnamesWithCookiesToDelete, WebCore::IncludeHttpOnlyCookies::Yes);
    17521771
     
    17541773                callbackAggregator->m_domains.add(RegistrableDomain::uncheckedCreateFromHost(host));
    17551774
    1756             hostnamesWithCookiesToDelete = filterForRegistrableDomains(domains.domainsToDeleteAllButHttpOnlyCookiesFor, hostNamesWithCookies);
     1775            hostnamesWithCookiesToDelete = filterForRegistrableDomains(domainsToDeleteAllButHttpOnlyCookiesFor, hostNamesWithCookies);
    17571776            networkStorageSession->deleteCookiesForHostnames(hostnamesWithCookiesToDelete, WebCore::IncludeHttpOnlyCookies::No);
    17581777
     
    17601779                callbackAggregator->m_domains.add(RegistrableDomain::uncheckedCreateFromHost(host));
    17611780        }
     1781    } else {
     1782        for (auto& domain : domains)
     1783            domainsToDeleteAllButCookiesFor.append(domain.first);
    17621784    }
    17631785
     
    17671789        if (auto* networkStorageSession = storageSession(sessionID)) {
    17681790            getHostNamesWithHSTSCache(*networkStorageSession, hostNamesWithHSTSCache);
    1769             hostnamesWithHSTSToDelete = filterForRegistrableDomains(domainsToDeleteAllNonCookieWebsiteDataFor, hostNamesWithHSTSCache);
     1791            hostnamesWithHSTSToDelete = filterForRegistrableDomains(domainsToDeleteAllButCookiesFor, hostNamesWithHSTSCache);
    17701792
    17711793            for (const auto& host : hostnamesWithHSTSToDelete)
     
    17921814        if (auto* session = storageSession(sessionID)) {
    17931815            auto origins = session->credentialStorage().originsWithCredentials();
    1794             auto originsToDelete = filterForRegistrableDomains(origins, domainsToDeleteAllNonCookieWebsiteDataFor, callbackAggregator->m_domains);
     1816            auto originsToDelete = filterForRegistrableDomains(origins, domainsToDeleteAllButCookiesFor, callbackAggregator->m_domains);
    17951817            for (auto& origin : originsToDelete)
    17961818                session->credentialStorage().removeCredentialsWithOrigin(origin);
     
    17981820
    17991821        auto origins = WebCore::CredentialStorage::originsWithSessionCredentials();
    1800         auto originsToDelete = filterForRegistrableDomains(origins, domainsToDeleteAllNonCookieWebsiteDataFor, callbackAggregator->m_domains);
     1822        auto originsToDelete = filterForRegistrableDomains(origins, domainsToDeleteAllButCookiesFor, callbackAggregator->m_domains);
    18011823        WebCore::CredentialStorage::removeSessionCredentialsWithOrigins(originsToDelete);
    18021824    }
    18031825   
    18041826    if (websiteDataTypes.contains(WebsiteDataType::DOMCache)) {
    1805         CacheStorage::Engine::fetchEntries(*this, sessionID, fetchOptions.contains(WebsiteDataFetchOption::ComputeSizes), [this, domainsToDeleteAllNonCookieWebsiteDataFor, sessionID, callbackAggregator = callbackAggregator.copyRef()](auto entries) mutable {
     1827        CacheStorage::Engine::fetchEntries(*this, sessionID, fetchOptions.contains(WebsiteDataFetchOption::ComputeSizes), [this, domainsToDeleteAllButCookiesFor, sessionID, callbackAggregator = callbackAggregator.copyRef()](auto entries) mutable {
    18061828           
    1807             auto entriesToDelete = filterForRegistrableDomains(domainsToDeleteAllNonCookieWebsiteDataFor, entries);
     1829            auto entriesToDelete = filterForRegistrableDomains(domainsToDeleteAllButCookiesFor, entries);
    18081830
    18091831            for (const auto& entry : entriesToDelete)
     
    18171839    if (m_storageManagerSet->contains(sessionID)) {
    18181840        if (websiteDataTypes.contains(WebsiteDataType::SessionStorage)) {
    1819             m_storageManagerSet->getSessionStorageOrigins(sessionID, [protectedThis = makeRef(*this), this, sessionID, callbackAggregator = callbackAggregator.copyRef(), domainsToDeleteAllNonCookieWebsiteDataFor](auto&& origins) {
    1820                 auto originsToDelete = filterForRegistrableDomains(origins, domainsToDeleteAllNonCookieWebsiteDataFor, callbackAggregator->m_domains);
     1841            m_storageManagerSet->getSessionStorageOrigins(sessionID, [protectedThis = makeRef(*this), this, sessionID, callbackAggregator = callbackAggregator.copyRef(), domainsToDeleteAllButCookiesFor](auto&& origins) {
     1842                auto originsToDelete = filterForRegistrableDomains(origins, domainsToDeleteAllButCookiesFor, callbackAggregator->m_domains);
    18211843                m_storageManagerSet->deleteSessionStorageForOrigins(sessionID, originsToDelete, [callbackAggregator = callbackAggregator.copyRef()] { });
    18221844            });
     
    18241846
    18251847        if (websiteDataTypes.contains(WebsiteDataType::LocalStorage)) {
    1826             m_storageManagerSet->getLocalStorageOrigins(sessionID, [protectedThis = makeRef(*this), this, sessionID, callbackAggregator = callbackAggregator.copyRef(), domainsToDeleteAllNonCookieWebsiteDataFor](auto&& origins) {
    1827                 auto originsToDelete = filterForRegistrableDomains(origins, domainsToDeleteAllNonCookieWebsiteDataFor, callbackAggregator->m_domains);
     1848            m_storageManagerSet->getLocalStorageOrigins(sessionID, [protectedThis = makeRef(*this), this, sessionID, callbackAggregator = callbackAggregator.copyRef(), domainsToDeleteAllButCookiesFor](auto&& origins) {
     1849                auto originsToDelete = filterForRegistrableDomains(origins, domainsToDeleteAllButCookiesFor, callbackAggregator->m_domains);
    18281850                m_storageManagerSet->deleteLocalStorageForOrigins(sessionID, originsToDelete, [callbackAggregator = callbackAggregator.copyRef()] { });
    18291851            });
     
    18351857    if (!path.isEmpty() && websiteDataTypes.contains(WebsiteDataType::IndexedDBDatabases)) {
    18361858        // FIXME: Pick the right database store based on the session ID.
    1837         postStorageTask(CrossThreadTask([this, sessionID, callbackAggregator = callbackAggregator.copyRef(), path = crossThreadCopy(path), domainsToDeleteAllNonCookieWebsiteDataFor = crossThreadCopy(domainsToDeleteAllNonCookieWebsiteDataFor)]() mutable {
    1838             RunLoop::main().dispatch([this, sessionID, domainsToDeleteAllNonCookieWebsiteDataFor = WTFMove(domainsToDeleteAllNonCookieWebsiteDataFor), callbackAggregator = callbackAggregator.copyRef(), securityOrigins = indexedDatabaseOrigins(path)] {
     1859        postStorageTask(CrossThreadTask([this, sessionID, callbackAggregator = callbackAggregator.copyRef(), path = crossThreadCopy(path), domainsToDeleteAllButCookiesFor = crossThreadCopy(domainsToDeleteAllButCookiesFor)]() mutable {
     1860            RunLoop::main().dispatch([this, sessionID, domainsToDeleteAllButCookiesFor = WTFMove(domainsToDeleteAllButCookiesFor), callbackAggregator = callbackAggregator.copyRef(), securityOrigins = indexedDatabaseOrigins(path)] {
    18391861                Vector<SecurityOriginData> entriesToDelete;
    18401862                for (const auto& securityOrigin : securityOrigins) {
    18411863                    auto domain = RegistrableDomain::uncheckedCreateFromHost(securityOrigin.host);
    1842                     if (!domainsToDeleteAllNonCookieWebsiteDataFor.contains(domain))
     1864                    if (!domainsToDeleteAllButCookiesFor.contains(domain))
    18431865                        continue;
    18441866
     
    18561878    path = m_serviceWorkerInfo.get(sessionID).databasePath;
    18571879    if (!path.isEmpty() && websiteDataTypes.contains(WebsiteDataType::ServiceWorkerRegistrations)) {
    1858         swServerForSession(sessionID).getOriginsWithRegistrations([this, sessionID, domainsToDeleteAllNonCookieWebsiteDataFor, callbackAggregator = callbackAggregator.copyRef()](const HashSet<SecurityOriginData>& securityOrigins) mutable {
     1880        swServerForSession(sessionID).getOriginsWithRegistrations([this, sessionID, domainsToDeleteAllButCookiesFor, callbackAggregator = callbackAggregator.copyRef()](const HashSet<SecurityOriginData>& securityOrigins) mutable {
    18591881            for (auto& securityOrigin : securityOrigins) {
    1860                 if (!domainsToDeleteAllNonCookieWebsiteDataFor.contains(RegistrableDomain::uncheckedCreateFromHost(securityOrigin.host)))
     1882                if (!domainsToDeleteAllButCookiesFor.contains(RegistrableDomain::uncheckedCreateFromHost(securityOrigin.host)))
    18611883                    continue;
    18621884                callbackAggregator->m_domains.add(RegistrableDomain::uncheckedCreateFromHost(securityOrigin.host));
     
    18681890
    18691891    if (websiteDataTypes.contains(WebsiteDataType::DiskCache)) {
    1870         forEachNetworkSession([sessionID, fetchOptions, &domainsToDeleteAllNonCookieWebsiteDataFor, &callbackAggregator](auto& session) {
    1871             fetchDiskCacheEntries(session.cache(), sessionID, fetchOptions, [domainsToDeleteAllNonCookieWebsiteDataFor, callbackAggregator = callbackAggregator.copyRef(), session = makeWeakPtr(&session)](auto entries) mutable {
     1892        forEachNetworkSession([sessionID, fetchOptions, &domainsToDeleteAllButCookiesFor, &callbackAggregator](auto& session) {
     1893            fetchDiskCacheEntries(session.cache(), sessionID, fetchOptions, [domainsToDeleteAllButCookiesFor, callbackAggregator = callbackAggregator.copyRef(), session = makeWeakPtr(&session)](auto entries) mutable {
    18721894                if (!session)
    18731895                    return;
     
    18751897                Vector<SecurityOriginData> entriesToDelete;
    18761898                for (auto& entry : entries) {
    1877                     if (!domainsToDeleteAllNonCookieWebsiteDataFor.contains(RegistrableDomain::uncheckedCreateFromHost(entry.origin.host)))
     1899                    if (!domainsToDeleteAllButCookiesFor.contains(RegistrableDomain::uncheckedCreateFromHost(entry.origin.host)))
    18781900                        continue;
    18791901                    entriesToDelete.append(entry.origin);
     
    18861908
    18871909    auto dataTypesForUIProcess = WebsiteData::filter(websiteDataTypes, WebsiteDataProcessType::UI);
    1888     if (!dataTypesForUIProcess.isEmpty() && !domainsToDeleteAllNonCookieWebsiteDataFor.isEmpty()) {
     1910    if (!dataTypesForUIProcess.isEmpty() && !domainsToDeleteAllButCookiesFor.isEmpty()) {
    18891911        CompletionHandler<void(const HashSet<RegistrableDomain>&)> completionHandler = [callbackAggregator = callbackAggregator.copyRef()] (const HashSet<RegistrableDomain>& domains) {
    18901912            for (auto& domain : domains)
    18911913                callbackAggregator->m_domains.add(domain);
    18921914        };
    1893         parentProcessConnection()->sendWithAsyncReply(Messages::NetworkProcessProxy::DeleteWebsiteDataInUIProcessForRegistrableDomains(sessionID, dataTypesForUIProcess, fetchOptions, domainsToDeleteAllNonCookieWebsiteDataFor), WTFMove(completionHandler));
     1915        parentProcessConnection()->sendWithAsyncReply(Messages::NetworkProcessProxy::DeleteWebsiteDataInUIProcessForRegistrableDomains(sessionID, dataTypesForUIProcess, fetchOptions, domainsToDeleteAllButCookiesFor), WTFMove(completionHandler));
    18941916    }
    18951917}
     
    18981920{
    18991921    OptionSet<WebsiteDataType> cookieType = WebsiteDataType::Cookies;
    1900     RegistrableDomainsToDeleteOrRestrictWebsiteDataFor toDeleteFor;
    1901     if (includeHttpOnlyCookies)
    1902         toDeleteFor.domainsToDeleteAllCookiesFor.append(domain);
    1903     else
    1904         toDeleteFor.domainsToDeleteAllButHttpOnlyCookiesFor.append(domain);
    1905 
    1906     deleteAndRestrictWebsiteDataForRegistrableDomains(sessionID, cookieType, WTFMove(toDeleteFor), true, [completionHandler = WTFMove(completionHandler)] (const HashSet<RegistrableDomain>& domainsDeletedFor) mutable {
     1922    Vector<std::pair<RegistrableDomain, WebsiteDataToRemove>> toDeleteFor = {
     1923        std::make_pair(domain, includeHttpOnlyCookies ? WebsiteDataToRemove::All : WebsiteDataToRemove::AllButHttpOnlyCookies)
     1924    };
     1925    deleteWebsiteDataForRegistrableDomains(sessionID, cookieType, WTFMove(toDeleteFor), true, [completionHandler = WTFMove(completionHandler)] (const HashSet<RegistrableDomain>& domainsDeletedFor) mutable {
    19071926        UNUSED_PARAM(domainsDeletedFor);
    19081927        completionHandler();
  • trunk/Source/WebKit/NetworkProcess/NetworkProcess.h

    r258928 r258932  
    206206    void clearPrevalentResource(PAL::SessionID, const RegistrableDomain&, CompletionHandler<void()>&&);
    207207    void clearUserInteraction(PAL::SessionID, const RegistrableDomain&, CompletionHandler<void()>&&);
    208     void deleteAndRestrictWebsiteDataForRegistrableDomains(PAL::SessionID, OptionSet<WebsiteDataType>, RegistrableDomainsToDeleteOrRestrictWebsiteDataFor&&, bool shouldNotifyPage, CompletionHandler<void(const HashSet<RegistrableDomain>&)>&&);
     208    void deleteWebsiteDataForRegistrableDomains(PAL::SessionID, OptionSet<WebsiteDataType>, Vector<std::pair<RegistrableDomain, WebsiteDataToRemove>>&&, bool shouldNotifyPage, CompletionHandler<void(const HashSet<RegistrableDomain>&)>&&);
    209209    void deleteCookiesForTesting(PAL::SessionID, RegistrableDomain, bool includeHttpOnlyCookies, CompletionHandler<void()>&&);
    210210    void dumpResourceLoadStatistics(PAL::SessionID, CompletionHandler<void(String)>&&);
  • trunk/Source/WebKit/NetworkProcess/NetworkSession.cpp

    r258928 r258932  
    214214}
    215215
    216 void NetworkSession::deleteAndRestrictWebsiteDataForRegistrableDomains(OptionSet<WebsiteDataType> dataTypes, RegistrableDomainsToDeleteOrRestrictWebsiteDataFor&& domains, bool shouldNotifyPage, CompletionHandler<void(const HashSet<RegistrableDomain>&)>&& completionHandler)
    217 {
    218     m_networkProcess->deleteAndRestrictWebsiteDataForRegistrableDomains(m_sessionID, dataTypes, WTFMove(domains), shouldNotifyPage, WTFMove(completionHandler));
     216void NetworkSession::deleteWebsiteDataForRegistrableDomains(OptionSet<WebsiteDataType> dataTypes, Vector<std::pair<RegistrableDomain, WebsiteDataToRemove>>&& domains, bool shouldNotifyPage, CompletionHandler<void(const HashSet<RegistrableDomain>&)>&& completionHandler)
     217{
     218    m_networkProcess->deleteWebsiteDataForRegistrableDomains(m_sessionID, dataTypes, WTFMove(domains), shouldNotifyPage, WTFMove(completionHandler));
    219219}
    220220
  • trunk/Source/WebKit/NetworkProcess/NetworkSession.h

    r258928 r258932  
    9494    bool isResourceLoadStatisticsEnabled() const;
    9595    void notifyResourceLoadStatisticsProcessed();
    96     void deleteAndRestrictWebsiteDataForRegistrableDomains(OptionSet<WebsiteDataType>, RegistrableDomainsToDeleteOrRestrictWebsiteDataFor&&, bool shouldNotifyPage, CompletionHandler<void(const HashSet<WebCore::RegistrableDomain>&)>&&);
     96    void deleteWebsiteDataForRegistrableDomains(OptionSet<WebsiteDataType>, Vector<std::pair<WebCore::RegistrableDomain, WebsiteDataToRemove>>&&, bool shouldNotifyPage, CompletionHandler<void(const HashSet<WebCore::RegistrableDomain>&)>&&);
    9797    void registrableDomainsWithWebsiteData(OptionSet<WebsiteDataType>, bool shouldNotifyPage, CompletionHandler<void(HashSet<WebCore::RegistrableDomain>&&)>&&);
    9898    void logDiagnosticMessageWithValue(const String& message, const String& description, unsigned value, unsigned significantFigures, WebCore::ShouldSample);
Note: See TracChangeset for help on using the changeset viewer.