Changeset 254556 in webkit


Ignore:
Timestamp:
Jan 14, 2020 7:10:56 PM (4 years ago)
Author:
Chris Dumez
Message:

document.cookie should not do a sync IPC to the network process for iframes that do not have storage access
​https://bugs.webkit.org/show_bug.cgi?id=206108

Reviewed by Geoff Garen and John Wilander.

Source/WebCore:

When ITP is enabled and ThirdPartyCookieBlockingMode::All mode is used (default in Safari), we can now detect
that a third-party iframe does not have cookie access completely on the WebContent process side, instead of
doing the check on the Network process side. The benefit is that this avoids doing a synchronous IPC every
time a third-party iframe which does not have storage access tries to access document.cookie in JavaScript.
Given that this should apply to a lot of iframes, this change is very beneficial to performance.

No new tests, covered by existing tests that are still passing.

  • loader/CookieJar.cpp:

(WebCore::CookieJar::cookies const):
(WebCore::CookieJar::setCookies):
(WebCore::CookieJar::cookieRequestHeaderFieldValue const):
(WebCore::CookieJar::getRawCookies const):

  • platform/network/CacheValidation.cpp:

(WebCore::cookieRequestHeaderFieldValue):

  • platform/network/NetworkStorageSession.h:
  • platform/network/cf/NetworkStorageSessionCFNetWin.cpp:

(WebCore::NetworkStorageSession::setCookiesFromDOM const):
(WebCore::NetworkStorageSession::cookiesForDOM const):
(WebCore::NetworkStorageSession::cookieRequestHeaderFieldValue const):
(WebCore::NetworkStorageSession::getRawCookies const):

  • platform/network/cocoa/NetworkStorageSessionCocoa.mm:

(WebCore::cookiesForURL):
(WebCore::cookiesForSession):
(WebCore::NetworkStorageSession::cookiesForDOM const):
(WebCore::NetworkStorageSession::cookieRequestHeaderFieldValue const):
(WebCore::NetworkStorageSession::setCookiesFromDOM const):
(WebCore::NetworkStorageSession::getRawCookies const):

  • platform/network/curl/NetworkStorageSessionCurl.cpp:

(WebCore::NetworkStorageSession::setCookiesFromDOM const):
(WebCore::NetworkStorageSession::cookiesForDOM const):
(WebCore::NetworkStorageSession::getRawCookies const):
(WebCore::NetworkStorageSession::cookieRequestHeaderFieldValue const):

  • platform/network/soup/NetworkStorageSessionSoup.cpp:

(WebCore::NetworkStorageSession::setCookiesFromDOM const):
(WebCore::NetworkStorageSession::getRawCookies const):
(WebCore::NetworkStorageSession::cookiesForDOM const):
(WebCore::NetworkStorageSession::cookieRequestHeaderFieldValue const):

Source/WebKit:

When ITP is enabled and ThirdPartyCookieBlockingMode::All mode is used (default in Safari), we can now detect
that a third-party iframe does not have cookie access completely on the WebContent process side, instead of
doing the check on the Network process side. The benefit is that this avoids doing a synchronous IPC every
time a third-party iframe which does not have storage access tries to access document.cookie in JavaScript.
Given that this should apply to a lot of iframes, this change is very beneficial to performance.

  • NetworkProcess/NetworkConnectionToWebProcess.cpp:

(WebKit::NetworkConnectionToWebProcess::cookiesForDOM):
(WebKit::NetworkConnectionToWebProcess::setCookiesFromDOM):
(WebKit::NetworkConnectionToWebProcess::cookieRequestHeaderFieldValue):
(WebKit::NetworkConnectionToWebProcess::getRawCookies):

  • NetworkProcess/NetworkConnectionToWebProcess.h:
  • NetworkProcess/NetworkConnectionToWebProcess.messages.in:
  • NetworkProcess/NetworkResourceLoader.cpp:

(WebKit::logCookieInformationInternal):

  • NetworkProcess/NetworkSessionCreationParameters.cpp:

(WebKit::NetworkSessionCreationParameters::encode const):
(WebKit::NetworkSessionCreationParameters::decode):

  • NetworkProcess/NetworkSessionCreationParameters.h:
  • Scripts/webkit/messages.py:
  • Shared/WebProcessDataStoreParameters.h:

(WebKit::WebProcessDataStoreParameters::encode const):
(WebKit::WebProcessDataStoreParameters::decode):

  • UIProcess/Network/NetworkProcessProxy.cpp:

(WebKit::NetworkProcessProxy::setShouldBlockThirdPartyCookiesForTesting):

  • UIProcess/WebProcessPool.cpp:

(WebKit::WebProcessPool::ensureNetworkProcess):
(WebKit::WebProcessPool::webProcessDataStoreParameters):

  • UIProcess/WebProcessProxy.cpp:

(WebKit::WebProcessProxy::setShouldBlockThirdPartyCookiesForTesting):

  • UIProcess/WebProcessProxy.h:
  • UIProcess/WebsiteData/Cocoa/WebsiteDataStoreCocoa.mm:

(WebKit::WebsiteDataStore::thirdPartyCookieBlockingMode const):
(WebKit::WebsiteDataStore::parameters):

  • UIProcess/WebsiteData/WebsiteDataStore.cpp:

(WebKit::WebsiteDataStore::thirdPartyCookieBlockingMode const):
(WebKit::WebsiteDataStore::setResourceLoadStatisticsShouldBlockThirdPartyCookiesForTesting):

  • UIProcess/WebsiteData/WebsiteDataStore.h:
  • WebProcess/WebCoreSupport/WebResourceLoadObserver.cpp:

(WebKit::WebResourceLoadObserver::requestStorageAccessUnderOpener):
(WebKit::WebResourceLoadObserver::logUserInteractionWithReducedTimeResolution):

  • WebProcess/WebCoreSupport/WebResourceLoadObserver.h:
  • WebProcess/WebPage/WebCookieJar.cpp:

(WebKit::shouldBlockCookies):
(WebKit::WebCookieJar::cookies const):
(WebKit::WebCookieJar::setCookies):
(WebKit::WebCookieJar::cookieRequestHeaderFieldValue const):
(WebKit::WebCookieJar::getRawCookies const):

  • WebProcess/WebPage/WebPage.cpp:

(WebKit::WebPage::addDomainWithPageLevelStorageAccess):
(WebKit::WebPage::hasPageLevelStorageAccess const):

  • WebProcess/WebPage/WebPage.h:
  • WebProcess/WebProcess.cpp:

(WebKit::WebProcess::setWebsiteDataStoreParameters):
(WebKit::WebProcess::setShouldBlockThirdPartyCookiesForTesting):

  • WebProcess/WebProcess.h:

(WebKit::WebProcess::thirdPartyCookieBlockingMode const):

  • WebProcess/WebProcess.messages.in:

Tools:

Make setStatisticsShouldBlockThirdPartyCookies IPC from the WebProcess to the UIProcess asynchronous
since this ends up sending an IPC back to the WebProcess now (which would deadlock).

  • WebKitTestRunner/InjectedBundle/TestRunner.cpp:

(WTR::TestRunner::setStatisticsShouldBlockThirdPartyCookies):

  • WebKitTestRunner/TestInvocation.cpp:

(WTR::TestInvocation::didReceiveMessageFromInjectedBundle):
(WTR::TestInvocation::didReceiveSynchronousMessageFromInjectedBundle):

Location:
trunk
Files:
35 edited

Legend:

Unmodified
Added
Removed

  • trunk/Source/WebCore/ChangeLog

    r254555 r254556  
     12020-01-14  Chris Dumez  <cdumez@apple.com>
     2
     3        document.cookie should not do a sync IPC to the network process for iframes that do not have storage access
     4        https://bugs.webkit.org/show_bug.cgi?id=206108
     5
     6        Reviewed by Geoff Garen and John Wilander.
     7
     8        When ITP is enabled and ThirdPartyCookieBlockingMode::All mode is used (default in Safari), we can now detect
     9        that a third-party iframe does not have cookie access completely on the WebContent process side, instead of
     10        doing the check on the Network process side. The benefit is that this avoids doing a synchronous IPC every
     11        time a third-party iframe which does not have storage access tries to access document.cookie in JavaScript.
     12        Given that this should apply to a lot of iframes, this change is very beneficial to performance.
     13
     14        No new tests, covered by existing tests that are still passing.
     15
     16        * loader/CookieJar.cpp:
     17        (WebCore::CookieJar::cookies const):
     18        (WebCore::CookieJar::setCookies):
     19        (WebCore::CookieJar::cookieRequestHeaderFieldValue const):
     20        (WebCore::CookieJar::getRawCookies const):
     21        * platform/network/CacheValidation.cpp:
     22        (WebCore::cookieRequestHeaderFieldValue):
     23        * platform/network/NetworkStorageSession.h:
     24        * platform/network/cf/NetworkStorageSessionCFNetWin.cpp:
     25        (WebCore::NetworkStorageSession::setCookiesFromDOM const):
     26        (WebCore::NetworkStorageSession::cookiesForDOM const):
     27        (WebCore::NetworkStorageSession::cookieRequestHeaderFieldValue const):
     28        (WebCore::NetworkStorageSession::getRawCookies const):
     29        * platform/network/cocoa/NetworkStorageSessionCocoa.mm:
     30        (WebCore::cookiesForURL):
     31        (WebCore::cookiesForSession):
     32        (WebCore::NetworkStorageSession::cookiesForDOM const):
     33        (WebCore::NetworkStorageSession::cookieRequestHeaderFieldValue const):
     34        (WebCore::NetworkStorageSession::setCookiesFromDOM const):
     35        (WebCore::NetworkStorageSession::getRawCookies const):
     36        * platform/network/curl/NetworkStorageSessionCurl.cpp:
     37        (WebCore::NetworkStorageSession::setCookiesFromDOM const):
     38        (WebCore::NetworkStorageSession::cookiesForDOM const):
     39        (WebCore::NetworkStorageSession::getRawCookies const):
     40        (WebCore::NetworkStorageSession::cookieRequestHeaderFieldValue const):
     41        * platform/network/soup/NetworkStorageSessionSoup.cpp:
     42        (WebCore::NetworkStorageSession::setCookiesFromDOM const):
     43        (WebCore::NetworkStorageSession::getRawCookies const):
     44        (WebCore::NetworkStorageSession::cookiesForDOM const):
     45        (WebCore::NetworkStorageSession::cookieRequestHeaderFieldValue const):
     46
    1472020-01-14  Peng Liu  <peng.liu6@apple.com>
    248

  • trunk/Source/WebCore/loader/CookieJar.cpp

    r250191 r254556  
    8181    std::pair<String, bool> result;
    8282    if (auto* session = m_storageSessionProvider->storageSession())
    83         result = session->cookiesForDOM(document.firstPartyForCookies(), sameSiteInfo(document), url, frameID, pageID, includeSecureCookies);
     83        result = session->cookiesForDOM(document.firstPartyForCookies(), sameSiteInfo(document), url, frameID, pageID, includeSecureCookies, ShouldAskITP::Yes);
    8484    else
    8585        ASSERT_NOT_REACHED();
    … …  
    115115
    116116    if (auto* session = m_storageSessionProvider->storageSession())
    117         session->setCookiesFromDOM(document.firstPartyForCookies(), sameSiteInfo(document), url, frameID, pageID, cookieString);
     117        session->setCookiesFromDOM(document.firstPartyForCookies(), sameSiteInfo(document), url, frameID, pageID, ShouldAskITP::Yes, cookieString);
    118118    else
    119119        ASSERT_NOT_REACHED();
    … …  
    132132{
    133133    if (auto* session = m_storageSessionProvider->storageSession()) {
    134         std::pair<String, bool> result = session->cookieRequestHeaderFieldValue(firstParty, sameSiteInfo, url, frameID, pageID, includeSecureCookies);
     134        std::pair<String, bool> result = session->cookieRequestHeaderFieldValue(firstParty, sameSiteInfo, url, frameID, pageID, includeSecureCookies, ShouldAskITP::Yes);
    135135        return { result.first, result.second ? SecureCookiesAccessed::Yes : SecureCookiesAccessed::No };
    136136    }
    … …  
    165165
    166166    if (auto* session = m_storageSessionProvider->storageSession())
    167         return session->getRawCookies(document.firstPartyForCookies(), sameSiteInfo(document), url, frameID, pageID, cookies);
     167        return session->getRawCookies(document.firstPartyForCookies(), sameSiteInfo(document), url, frameID, pageID, ShouldAskITP::Yes, cookies);
    168168
    169169    ASSERT_NOT_REACHED();

  • trunk/Source/WebCore/platform/network/CacheValidation.cpp

    r252397 r254556  
    341341static String cookieRequestHeaderFieldValue(const NetworkStorageSession& session, const ResourceRequest& request)
    342342{
    343     return session.cookieRequestHeaderFieldValue(request.firstPartyForCookies(), SameSiteInfo::create(request), request.url(), WTF::nullopt, WTF::nullopt, request.url().protocolIs("https") ? IncludeSecureCookies::Yes : IncludeSecureCookies::No).first;
     343    return session.cookieRequestHeaderFieldValue(request.firstPartyForCookies(), SameSiteInfo::create(request), request.url(), WTF::nullopt, WTF::nullopt, request.url().protocolIs("https") ? IncludeSecureCookies::Yes : IncludeSecureCookies::No, ShouldAskITP::Yes).first;
    344344}
    345345

  • trunk/Source/WebCore/platform/network/NetworkStorageSession.h

    r254374 r254556  
    7777enum class ThirdPartyCookieBlockingMode : uint8_t { All, AllOnSitesWithoutUserInteraction, OnlyAccordingToPerDomainPolicy };
    7878enum class FirstPartyWebsiteDataRemovalMode : uint8_t { AllButCookies, None, AllButCookiesLiveOnTestingTimeout, AllButCookiesReproTestingTimeout };
     79enum class ShouldAskITP : bool { No, Yes };
    7980
    8081class NetworkStorageSession {
    … …  
    128129    WEBCORE_EXPORT void setCookie(const Cookie&);
    129130    WEBCORE_EXPORT void setCookies(const Vector<Cookie>&, const URL&, const URL& mainDocumentURL);
    130     WEBCORE_EXPORT void setCookiesFromDOM(const URL& firstParty, const SameSiteInfo&, const URL&, Optional<FrameIdentifier>, Optional<PageIdentifier>, const String&) const;
     131    WEBCORE_EXPORT void setCookiesFromDOM(const URL& firstParty, const SameSiteInfo&, const URL&, Optional<FrameIdentifier>, Optional<PageIdentifier>, ShouldAskITP, const String&) const;
    131132    WEBCORE_EXPORT void deleteCookie(const Cookie&);
    132133    WEBCORE_EXPORT void deleteCookie(const URL&, const String&) const;
    … …  
    138139    WEBCORE_EXPORT Vector<Cookie> getCookies(const URL&);
    139140    WEBCORE_EXPORT void hasCookies(const RegistrableDomain&, CompletionHandler<void(bool)>&&) const;
    140     WEBCORE_EXPORT bool getRawCookies(const URL& firstParty, const SameSiteInfo&, const URL&, Optional<FrameIdentifier>, Optional<PageIdentifier>, Vector<Cookie>&) const;
     141    WEBCORE_EXPORT bool getRawCookies(const URL& firstParty, const SameSiteInfo&, const URL&, Optional<FrameIdentifier>, Optional<PageIdentifier>, ShouldAskITP, Vector<Cookie>&) const;
    141142    WEBCORE_EXPORT void flushCookieStore();
    142143    WEBCORE_EXPORT void getHostnamesWithCookies(HashSet<String>& hostnames);
    143     WEBCORE_EXPORT std::pair<String, bool> cookiesForDOM(const URL& firstParty, const SameSiteInfo&, const URL&, Optional<FrameIdentifier>, Optional<PageIdentifier>, IncludeSecureCookies) const;
    144     WEBCORE_EXPORT std::pair<String, bool> cookieRequestHeaderFieldValue(const URL& firstParty, const SameSiteInfo&, const URL&, Optional<FrameIdentifier>, Optional<PageIdentifier>, IncludeSecureCookies) const;
     144    WEBCORE_EXPORT std::pair<String, bool> cookiesForDOM(const URL& firstParty, const SameSiteInfo&, const URL&, Optional<FrameIdentifier>, Optional<PageIdentifier>, IncludeSecureCookies, ShouldAskITP) const;
     145    WEBCORE_EXPORT std::pair<String, bool> cookieRequestHeaderFieldValue(const URL& firstParty, const SameSiteInfo&, const URL&, Optional<FrameIdentifier>, Optional<PageIdentifier>, IncludeSecureCookies, ShouldAskITP) const;
    145146    WEBCORE_EXPORT std::pair<String, bool> cookieRequestHeaderFieldValue(const CookieRequestHeaderFieldProxy&) const;
    146147

  • trunk/Source/WebCore/platform/network/cf/NetworkStorageSessionCFNetWin.cpp

    r248713 r254556  
    190190}
    191191
    192 void NetworkStorageSession::setCookiesFromDOM(const URL& firstParty, const SameSiteInfo&, const URL& url, Optional<FrameIdentifier> frameID, Optional<PageIdentifier> pageID, const String& value) const
     192void NetworkStorageSession::setCookiesFromDOM(const URL& firstParty, const SameSiteInfo&, const URL& url, Optional<FrameIdentifier> frameID, Optional<PageIdentifier> pageID, ShouldAskITP, const String& value) const
    193193{
    194194    UNUSED_PARAM(frameID);
    … …  
    226226}
    227227
    228 std::pair<String, bool> NetworkStorageSession::cookiesForDOM(const URL& firstParty, const SameSiteInfo&, const URL& url, Optional<FrameIdentifier> frameID, Optional<PageIdentifier> pageID, IncludeSecureCookies includeSecureCookies) const
     228std::pair<String, bool> NetworkStorageSession::cookiesForDOM(const URL& firstParty, const SameSiteInfo&, const URL& url, Optional<FrameIdentifier> frameID, Optional<PageIdentifier> pageID, IncludeSecureCookies includeSecureCookies, ShouldAskITP) const
    229229{
    230230    UNUSED_PARAM(frameID);
    … …  
    241241}
    242242
    243 std::pair<String, bool> NetworkStorageSession::cookieRequestHeaderFieldValue(const URL& firstParty, const SameSiteInfo&, const URL& url, Optional<FrameIdentifier> frameID, Optional<PageIdentifier> pageID, IncludeSecureCookies includeSecureCookies) const
     243std::pair<String, bool> NetworkStorageSession::cookieRequestHeaderFieldValue(const URL& firstParty, const SameSiteInfo&, const URL& url, Optional<FrameIdentifier> frameID, Optional<PageIdentifier> pageID, IncludeSecureCookies includeSecureCookies, ShouldAskITP) const
    244244{
    245245    UNUSED_PARAM(frameID);
    … …  
    256256std::pair<String, bool> NetworkStorageSession::cookieRequestHeaderFieldValue(const CookieRequestHeaderFieldProxy& headerFieldProxy) const
    257257{
    258     return cookieRequestHeaderFieldValue(headerFieldProxy.firstParty, headerFieldProxy.sameSiteInfo, headerFieldProxy.url, headerFieldProxy.frameID, headerFieldProxy.pageID, headerFieldProxy.includeSecureCookies);
     258    return cookieRequestHeaderFieldValue(headerFieldProxy.firstParty, headerFieldProxy.sameSiteInfo, headerFieldProxy.url, headerFieldProxy.frameID, headerFieldProxy.pageID, headerFieldProxy.includeSecureCookies, ShouldAskITP::Yes);
    259259}
    260260
    … …  
    265265}
    266266
    267 bool NetworkStorageSession::getRawCookies(const URL& firstParty, const SameSiteInfo&, const URL& url, Optional<FrameIdentifier> frameID, Optional<PageIdentifier> pageID, Vector<Cookie>& rawCookies) const
     267bool NetworkStorageSession::getRawCookies(const URL& firstParty, const SameSiteInfo&, const URL& url, Optional<FrameIdentifier> frameID, Optional<PageIdentifier> pageID, ShouldAskITP, Vector<Cookie>& rawCookies) const
    268268{
    269269    UNUSED_PARAM(frameID);

  • trunk/Source/WebCore/platform/network/cocoa/NetworkStorageSessionCocoa.mm

    r250589 r254556  
    309309}
    310310
    311 static NSArray *cookiesForURL(const NetworkStorageSession& session, const URL& firstParty, const SameSiteInfo& sameSiteInfo, const URL& url, Optional<FrameIdentifier> frameID, Optional<PageIdentifier> pageID)
     311static NSArray *cookiesForURL(const NetworkStorageSession& session, const URL& firstParty, const SameSiteInfo& sameSiteInfo, const URL& url, Optional<FrameIdentifier> frameID, Optional<PageIdentifier> pageID, ShouldAskITP shouldAskITP)
    312312{
    313313#if ENABLE(RESOURCE_LOAD_STATISTICS)
    314     if (session.shouldBlockCookies(firstParty, url, frameID, pageID))
     314    if (shouldAskITP == ShouldAskITP::Yes && session.shouldBlockCookies(firstParty, url, frameID, pageID))
    315315        return nil;
    316316#else
    317317    UNUSED_PARAM(frameID);
    318318    UNUSED_PARAM(pageID);
     319    UNUSED_PARAM(shouldAskITP);
    319320#endif
    320321    return httpCookiesForURL(session.cookieStorage().get(), firstParty, sameSiteInfo, url);
    … …  
    322323
    323324enum IncludeHTTPOnlyOrNot { DoNotIncludeHTTPOnly, IncludeHTTPOnly };
    324 static std::pair<String, bool> cookiesForSession(const NetworkStorageSession& session, const URL& firstParty, const SameSiteInfo& sameSiteInfo, const URL& url, Optional<FrameIdentifier> frameID, Optional<PageIdentifier> pageID, IncludeHTTPOnlyOrNot includeHTTPOnly, IncludeSecureCookies includeSecureCookies)
    325 {
    326     ASSERT(hasProcessPrivilege(ProcessPrivilege::CanAccessRawCookies));
    327 
    328     BEGIN_BLOCK_OBJC_EXCEPTIONS;
    329 
    330     NSArray *cookies = cookiesForURL(session, firstParty, sameSiteInfo, url, frameID, pageID);
     325static std::pair<String, bool> cookiesForSession(const NetworkStorageSession& session, const URL& firstParty, const SameSiteInfo& sameSiteInfo, const URL& url, Optional<FrameIdentifier> frameID, Optional<PageIdentifier> pageID, IncludeHTTPOnlyOrNot includeHTTPOnly, IncludeSecureCookies includeSecureCookies, ShouldAskITP shouldAskITP = ShouldAskITP::Yes)
     326{
     327    ASSERT(hasProcessPrivilege(ProcessPrivilege::CanAccessRawCookies));
     328
     329    BEGIN_BLOCK_OBJC_EXCEPTIONS;
     330
     331    NSArray *cookies = cookiesForURL(session, firstParty, sameSiteInfo, url, frameID, pageID, shouldAskITP);
    331332    if (![cookies count])
    332333        return { String(), false }; // Return a null string, not an empty one that StringBuilder would create below.
    … …  
    378379}
    379380
    380 std::pair<String, bool> NetworkStorageSession::cookiesForDOM(const URL& firstParty, const SameSiteInfo& sameSiteInfo, const URL& url, Optional<FrameIdentifier> frameID, Optional<PageIdentifier> pageID, IncludeSecureCookies includeSecureCookies) const
    381 {
    382     return cookiesForSession(*this, firstParty, sameSiteInfo, url, frameID, pageID, DoNotIncludeHTTPOnly, includeSecureCookies);
    383 }
    384 
    385 std::pair<String, bool> NetworkStorageSession::cookieRequestHeaderFieldValue(const URL& firstParty, const SameSiteInfo& sameSiteInfo, const URL& url, Optional<FrameIdentifier> frameID, Optional<PageIdentifier> pageID, IncludeSecureCookies includeSecureCookies) const
    386 {
    387     return cookiesForSession(*this, firstParty, sameSiteInfo, url, frameID, pageID, IncludeHTTPOnly, includeSecureCookies);
     381std::pair<String, bool> NetworkStorageSession::cookiesForDOM(const URL& firstParty, const SameSiteInfo& sameSiteInfo, const URL& url, Optional<FrameIdentifier> frameID, Optional<PageIdentifier> pageID, IncludeSecureCookies includeSecureCookies, ShouldAskITP shouldAskITP) const
     382{
     383    return cookiesForSession(*this, firstParty, sameSiteInfo, url, frameID, pageID, DoNotIncludeHTTPOnly, includeSecureCookies, shouldAskITP);
     384}
     385
     386std::pair<String, bool> NetworkStorageSession::cookieRequestHeaderFieldValue(const URL& firstParty, const SameSiteInfo& sameSiteInfo, const URL& url, Optional<FrameIdentifier> frameID, Optional<PageIdentifier> pageID, IncludeSecureCookies includeSecureCookies, ShouldAskITP shouldAskITP) const
     387{
     388    return cookiesForSession(*this, firstParty, sameSiteInfo, url, frameID, pageID, IncludeHTTPOnly, includeSecureCookies, shouldAskITP);
    388389}
    389390
    … …  
    393394}
    394395
    395 void NetworkStorageSession::setCookiesFromDOM(const URL& firstParty, const SameSiteInfo& sameSiteInfo, const URL& url, Optional<FrameIdentifier> frameID, Optional<PageIdentifier> pageID, const String& cookieStr) const
    396 {
    397     ASSERT(hasProcessPrivilege(ProcessPrivilege::CanAccessRawCookies));
    398 
    399     BEGIN_BLOCK_OBJC_EXCEPTIONS;
     396void NetworkStorageSession::setCookiesFromDOM(const URL& firstParty, const SameSiteInfo& sameSiteInfo, const URL& url, Optional<FrameIdentifier> frameID, Optional<PageIdentifier> pageID, ShouldAskITP shouldAskITP, const String& cookieStr) const
     397{
     398    ASSERT(hasProcessPrivilege(ProcessPrivilege::CanAccessRawCookies));
     399
     400    BEGIN_BLOCK_OBJC_EXCEPTIONS;
     401
     402#if ENABLE(RESOURCE_LOAD_STATISTICS)
     403    if (shouldAskITP == ShouldAskITP::Yes && shouldBlockCookies(firstParty, url, frameID, pageID))
     404        return;
     405#else
     406    UNUSED_PARAM(frameID);
     407    UNUSED_PARAM(pageID);
     408    UNUSED_PARAM(shouldAskITP);
     409#endif
    400410
    401411    // <rdar://problem/5632883> On 10.5, NSHTTPCookieStorage would store an empty cookie,
    … …  
    424434    ASSERT([filteredCookies.get() count] <= 1);
    425435
    426 #if ENABLE(RESOURCE_LOAD_STATISTICS)
    427     if (shouldBlockCookies(firstParty, url, frameID, pageID))
    428         return;
    429 #else
    430     UNUSED_PARAM(frameID);
    431     UNUSED_PARAM(pageID);
    432 #endif
    433 
    434436    setHTTPCookiesForURL(cookieStorage().get(), filteredCookies.get(), cookieURL, firstParty, sameSiteInfo);
    435437
    … …  
    458460}
    459461
    460 bool NetworkStorageSession::getRawCookies(const URL& firstParty, const SameSiteInfo& sameSiteInfo, const URL& url, Optional<FrameIdentifier> frameID, Optional<PageIdentifier> pageID, Vector<Cookie>& rawCookies) const
     462bool NetworkStorageSession::getRawCookies(const URL& firstParty, const SameSiteInfo& sameSiteInfo, const URL& url, Optional<FrameIdentifier> frameID, Optional<PageIdentifier> pageID, ShouldAskITP shouldAskITP, Vector<Cookie>& rawCookies) const
    461463{
    462464    rawCookies.clear();
    463465    BEGIN_BLOCK_OBJC_EXCEPTIONS;
    464466
    465     NSArray *cookies = cookiesForURL(*this, firstParty, sameSiteInfo, url, frameID, pageID);
     467    NSArray *cookies = cookiesForURL(*this, firstParty, sameSiteInfo, url, frameID, pageID, shouldAskITP);
    466468    NSUInteger count = [cookies count];
    467469    rawCookies.reserveCapacity(count);

  • trunk/Source/WebCore/platform/network/curl/NetworkStorageSessionCurl.cpp

    r250589 r254556  
    8181}
    8282
    83 void NetworkStorageSession::setCookiesFromDOM(const URL& firstParty, const SameSiteInfo& sameSiteInfo, const URL& url, Optional<FrameIdentifier> frameID, Optional<PageIdentifier> pageID, const String& value) const
     83void NetworkStorageSession::setCookiesFromDOM(const URL& firstParty, const SameSiteInfo& sameSiteInfo, const URL& url, Optional<FrameIdentifier> frameID, Optional<PageIdentifier> pageID, ShouldAskITP, const String& value) const
    8484{
    8585    cookieStorage().setCookiesFromDOM(*this, firstParty, sameSiteInfo, url, frameID, pageID, value);
    … …  
    9191}
    9292
    93 std::pair<String, bool> NetworkStorageSession::cookiesForDOM(const URL& firstParty, const SameSiteInfo& sameSiteInfo, const URL& url, Optional<FrameIdentifier> frameID, Optional<PageIdentifier> pageID, IncludeSecureCookies includeSecureCookies) const
     93std::pair<String, bool> NetworkStorageSession::cookiesForDOM(const URL& firstParty, const SameSiteInfo& sameSiteInfo, const URL& url, Optional<FrameIdentifier> frameID, Optional<PageIdentifier> pageID, IncludeSecureCookies includeSecureCookies, ShouldAskITP) const
    9494{
    9595    return cookieStorage().cookiesForDOM(*this, firstParty, sameSiteInfo, url, frameID, pageID, includeSecureCookies);
    … …  
    161161}
    162162
    163 bool NetworkStorageSession::getRawCookies(const URL& firstParty, const SameSiteInfo& sameSiteInfo, const URL& url, Optional<FrameIdentifier> frameID, Optional<PageIdentifier> pageID, Vector<Cookie>& rawCookies) const
     163bool NetworkStorageSession::getRawCookies(const URL& firstParty, const SameSiteInfo& sameSiteInfo, const URL& url, Optional<FrameIdentifier> frameID, Optional<PageIdentifier> pageID, ShouldAskITP, Vector<Cookie>& rawCookies) const
    164164{
    165165    return cookieStorage().getRawCookies(*this, firstParty, sameSiteInfo, url, frameID, pageID, rawCookies);
    … …  
    171171}
    172172
    173 std::pair<String, bool> NetworkStorageSession::cookieRequestHeaderFieldValue(const URL& firstParty, const SameSiteInfo& sameSiteInfo, const URL& url, Optional<FrameIdentifier> frameID, Optional<PageIdentifier> pageID, IncludeSecureCookies includeSecureCookies) const
     173std::pair<String, bool> NetworkStorageSession::cookieRequestHeaderFieldValue(const URL& firstParty, const SameSiteInfo& sameSiteInfo, const URL& url, Optional<FrameIdentifier> frameID, Optional<PageIdentifier> pageID, IncludeSecureCookies includeSecureCookies, ShouldAskITP) const
    174174{
    175175    return cookieStorage().cookieRequestHeaderFieldValue(*this, firstParty, sameSiteInfo, url, frameID, pageID, includeSecureCookies);

  • trunk/Source/WebCore/platform/network/soup/NetworkStorageSessionSoup.cpp

    r253431 r254556  
    262262}
    263263
    264 void NetworkStorageSession::setCookiesFromDOM(const URL& firstParty, const SameSiteInfo&, const URL& url, Optional<FrameIdentifier> frameID, Optional<PageIdentifier> pageID, const String& value) const
     264void NetworkStorageSession::setCookiesFromDOM(const URL& firstParty, const SameSiteInfo&, const URL& url, Optional<FrameIdentifier> frameID, Optional<PageIdentifier> pageID, ShouldAskITP, const String& value) const
    265265{
    266266    UNUSED_PARAM(frameID);
    … …  
    433433}
    434434
    435 bool NetworkStorageSession::getRawCookies(const URL& firstParty, const SameSiteInfo&, const URL& url, Optional<FrameIdentifier> frameID, Optional<PageIdentifier> pageID, Vector<Cookie>& rawCookies) const
     435bool NetworkStorageSession::getRawCookies(const URL& firstParty, const SameSiteInfo&, const URL& url, Optional<FrameIdentifier> frameID, Optional<PageIdentifier> pageID, ShouldAskITP, Vector<Cookie>& rawCookies) const
    436436{
    437437    UNUSED_PARAM(firstParty);
    … …  
    503503}
    504504
    505 std::pair<String, bool> NetworkStorageSession::cookiesForDOM(const URL& firstParty, const SameSiteInfo&, const URL& url, Optional<FrameIdentifier> frameID, Optional<PageIdentifier> pageID, IncludeSecureCookies includeSecureCookies) const
     505std::pair<String, bool> NetworkStorageSession::cookiesForDOM(const URL& firstParty, const SameSiteInfo&, const URL& url, Optional<FrameIdentifier> frameID, Optional<PageIdentifier> pageID, IncludeSecureCookies includeSecureCookies, ShouldAskITP) const
    506506{
    507507    UNUSED_PARAM(firstParty);
    … …  
    511511}
    512512
    513 std::pair<String, bool> NetworkStorageSession::cookieRequestHeaderFieldValue(const URL& firstParty, const SameSiteInfo&, const URL& url, Optional<FrameIdentifier> frameID, Optional<PageIdentifier> pageID, IncludeSecureCookies includeSecureCookies) const
     513std::pair<String, bool> NetworkStorageSession::cookieRequestHeaderFieldValue(const URL& firstParty, const SameSiteInfo&, const URL& url, Optional<FrameIdentifier> frameID, Optional<PageIdentifier> pageID, IncludeSecureCookies includeSecureCookies, ShouldAskITP) const
    514514{
    515515    UNUSED_PARAM(firstParty);
    … …  
    522522std::pair<String, bool> NetworkStorageSession::cookieRequestHeaderFieldValue(const CookieRequestHeaderFieldProxy& headerFieldProxy) const
    523523{
    524     return cookieRequestHeaderFieldValue(headerFieldProxy.firstParty, headerFieldProxy.sameSiteInfo, headerFieldProxy.url, headerFieldProxy.frameID, headerFieldProxy.pageID, headerFieldProxy.includeSecureCookies);
     524    return cookieRequestHeaderFieldValue(headerFieldProxy.firstParty, headerFieldProxy.sameSiteInfo, headerFieldProxy.url, headerFieldProxy.frameID, headerFieldProxy.pageID, headerFieldProxy.includeSecureCookies, ShouldAskITP::Yes);
    525525}
    526526

  • trunk/Source/WebKit/ChangeLog

    r254555 r254556  
     12020-01-14  Chris Dumez  <cdumez@apple.com>
     2
     3        document.cookie should not do a sync IPC to the network process for iframes that do not have storage access
     4        https://bugs.webkit.org/show_bug.cgi?id=206108
     5
     6        Reviewed by Geoff Garen and John Wilander.
     7
     8        When ITP is enabled and ThirdPartyCookieBlockingMode::All mode is used (default in Safari), we can now detect
     9        that a third-party iframe does not have cookie access completely on the WebContent process side, instead of
     10        doing the check on the Network process side. The benefit is that this avoids doing a synchronous IPC every
     11        time a third-party iframe which does not have storage access tries to access document.cookie in JavaScript.
     12        Given that this should apply to a lot of iframes, this change is very beneficial to performance.
     13
     14        * NetworkProcess/NetworkConnectionToWebProcess.cpp:
     15        (WebKit::NetworkConnectionToWebProcess::cookiesForDOM):
     16        (WebKit::NetworkConnectionToWebProcess::setCookiesFromDOM):
     17        (WebKit::NetworkConnectionToWebProcess::cookieRequestHeaderFieldValue):
     18        (WebKit::NetworkConnectionToWebProcess::getRawCookies):
     19        * NetworkProcess/NetworkConnectionToWebProcess.h:
     20        * NetworkProcess/NetworkConnectionToWebProcess.messages.in:
     21        * NetworkProcess/NetworkResourceLoader.cpp:
     22        (WebKit::logCookieInformationInternal):
     23        * NetworkProcess/NetworkSessionCreationParameters.cpp:
     24        (WebKit::NetworkSessionCreationParameters::encode const):
     25        (WebKit::NetworkSessionCreationParameters::decode):
     26        * NetworkProcess/NetworkSessionCreationParameters.h:
     27        * Scripts/webkit/messages.py:
     28        * Shared/WebProcessDataStoreParameters.h:
     29        (WebKit::WebProcessDataStoreParameters::encode const):
     30        (WebKit::WebProcessDataStoreParameters::decode):
     31        * UIProcess/Network/NetworkProcessProxy.cpp:
     32        (WebKit::NetworkProcessProxy::setShouldBlockThirdPartyCookiesForTesting):
     33        * UIProcess/WebProcessPool.cpp:
     34        (WebKit::WebProcessPool::ensureNetworkProcess):
     35        (WebKit::WebProcessPool::webProcessDataStoreParameters):
     36        * UIProcess/WebProcessProxy.cpp:
     37        (WebKit::WebProcessProxy::setShouldBlockThirdPartyCookiesForTesting):
     38        * UIProcess/WebProcessProxy.h:
     39        * UIProcess/WebsiteData/Cocoa/WebsiteDataStoreCocoa.mm:
     40        (WebKit::WebsiteDataStore::thirdPartyCookieBlockingMode const):
     41        (WebKit::WebsiteDataStore::parameters):
     42        * UIProcess/WebsiteData/WebsiteDataStore.cpp:
     43        (WebKit::WebsiteDataStore::thirdPartyCookieBlockingMode const):
     44        (WebKit::WebsiteDataStore::setResourceLoadStatisticsShouldBlockThirdPartyCookiesForTesting):
     45        * UIProcess/WebsiteData/WebsiteDataStore.h:
     46        * WebProcess/WebCoreSupport/WebResourceLoadObserver.cpp:
     47        (WebKit::WebResourceLoadObserver::requestStorageAccessUnderOpener):
     48        (WebKit::WebResourceLoadObserver::logUserInteractionWithReducedTimeResolution):
     49        * WebProcess/WebCoreSupport/WebResourceLoadObserver.h:
     50        * WebProcess/WebPage/WebCookieJar.cpp:
     51        (WebKit::shouldBlockCookies):
     52        (WebKit::WebCookieJar::cookies const):
     53        (WebKit::WebCookieJar::setCookies):
     54        (WebKit::WebCookieJar::cookieRequestHeaderFieldValue const):
     55        (WebKit::WebCookieJar::getRawCookies const):
     56        * WebProcess/WebPage/WebPage.cpp:
     57        (WebKit::WebPage::addDomainWithPageLevelStorageAccess):
     58        (WebKit::WebPage::hasPageLevelStorageAccess const):
     59        * WebProcess/WebPage/WebPage.h:
     60        * WebProcess/WebProcess.cpp:
     61        (WebKit::WebProcess::setWebsiteDataStoreParameters):
     62        (WebKit::WebProcess::setShouldBlockThirdPartyCookiesForTesting):
     63        * WebProcess/WebProcess.h:
     64        (WebKit::WebProcess::thirdPartyCookieBlockingMode const):
     65        * WebProcess/WebProcess.messages.in:
     66
    1672020-01-14  Peng Liu  <peng.liu6@apple.com>
    268

  • trunk/Source/WebKit/NetworkProcess/NetworkConnectionToWebProcess.cpp

    r253740 r254556  
    565565}
    566566
    567 void NetworkConnectionToWebProcess::cookiesForDOM(const URL& firstParty, const SameSiteInfo& sameSiteInfo, const URL& url, Optional<FrameIdentifier> frameID, Optional<PageIdentifier> pageID, IncludeSecureCookies includeSecureCookies, CompletionHandler<void(String cookieString, bool secureCookiesAccessed)>&& completionHandler)
     567void NetworkConnectionToWebProcess::cookiesForDOM(const URL& firstParty, const SameSiteInfo& sameSiteInfo, const URL& url, FrameIdentifier frameID, PageIdentifier pageID, IncludeSecureCookies includeSecureCookies, ShouldAskITP shouldAskITP, CompletionHandler<void(String cookieString, bool secureCookiesAccessed)>&& completionHandler)
    568568{
    569569    auto* networkStorageSession = storageSession();
    570570    if (!networkStorageSession)
    571571        return completionHandler({ }, false);
    572     auto result = networkStorageSession->cookiesForDOM(firstParty, sameSiteInfo, url, frameID, pageID, includeSecureCookies);
     572    auto result = networkStorageSession->cookiesForDOM(firstParty, sameSiteInfo, url, frameID, pageID, includeSecureCookies, shouldAskITP);
    573573#if ENABLE(RESOURCE_LOAD_STATISTICS) && !RELEASE_LOG_DISABLED
    574574    if (auto* session = networkSession()) {
    … …  
    580580}
    581581
    582 void NetworkConnectionToWebProcess::setCookiesFromDOM(const URL& firstParty, const SameSiteInfo& sameSiteInfo, const URL& url, Optional<WebCore::FrameIdentifier> frameID, Optional<PageIdentifier> pageID, const String& cookieString)
     582void NetworkConnectionToWebProcess::setCookiesFromDOM(const URL& firstParty, const SameSiteInfo& sameSiteInfo, const URL& url, WebCore::FrameIdentifier frameID, PageIdentifier pageID, ShouldAskITP shouldAskITP, const String& cookieString)
    583583{
    584584    auto* networkStorageSession = storageSession();
    585585    if (!networkStorageSession)
    586586        return;
    587     networkStorageSession->setCookiesFromDOM(firstParty, sameSiteInfo, url, frameID, pageID, cookieString);
     587    networkStorageSession->setCookiesFromDOM(firstParty, sameSiteInfo, url, frameID, pageID, shouldAskITP, cookieString);
    588588#if ENABLE(RESOURCE_LOAD_STATISTICS) && !RELEASE_LOG_DISABLED
    589589    if (auto* session = networkSession()) {
    … …  
    602602}
    603603
    604 void NetworkConnectionToWebProcess::cookieRequestHeaderFieldValue(const URL& firstParty, const SameSiteInfo& sameSiteInfo, const URL& url, Optional<FrameIdentifier> frameID, Optional<PageIdentifier> pageID, IncludeSecureCookies includeSecureCookies, CompletionHandler<void(String, bool)>&& completionHandler)
     604void NetworkConnectionToWebProcess::cookieRequestHeaderFieldValue(const URL& firstParty, const SameSiteInfo& sameSiteInfo, const URL& url, Optional<FrameIdentifier> frameID, Optional<PageIdentifier> pageID, IncludeSecureCookies includeSecureCookies, ShouldAskITP shouldAskITP, CompletionHandler<void(String, bool)>&& completionHandler)
    605605{
    606606    auto* networkStorageSession = storageSession();
    607607    if (!networkStorageSession)
    608608        return completionHandler({ }, false);
    609     auto result = networkStorageSession->cookieRequestHeaderFieldValue(firstParty, sameSiteInfo, url, frameID, pageID, includeSecureCookies);
     609    auto result = networkStorageSession->cookieRequestHeaderFieldValue(firstParty, sameSiteInfo, url, frameID, pageID, includeSecureCookies, shouldAskITP);
    610610    completionHandler(WTFMove(result.first), result.second);
    611611}
    612612
    613 void NetworkConnectionToWebProcess::getRawCookies(const URL& firstParty, const SameSiteInfo& sameSiteInfo, const URL& url, Optional<FrameIdentifier> frameID, Optional<PageIdentifier> pageID, CompletionHandler<void(Vector<WebCore::Cookie>&&)>&& completionHandler)
     613void NetworkConnectionToWebProcess::getRawCookies(const URL& firstParty, const SameSiteInfo& sameSiteInfo, const URL& url, Optional<FrameIdentifier> frameID, Optional<PageIdentifier> pageID, ShouldAskITP shouldAskITP, CompletionHandler<void(Vector<WebCore::Cookie>&&)>&& completionHandler)
    614614{
    615615    auto* networkStorageSession = storageSession();
    … …  
    617617        return completionHandler({ });
    618618    Vector<WebCore::Cookie> result;
    619     networkStorageSession->getRawCookies(firstParty, sameSiteInfo, url, frameID, pageID, result);
     619    networkStorageSession->getRawCookies(firstParty, sameSiteInfo, url, frameID, pageID, shouldAskITP, result);
    620620    completionHandler(WTFMove(result));
    621621}

  • trunk/Source/WebKit/NetworkProcess/NetworkConnectionToWebProcess.h

    r253452 r254556  
    5959enum class StorageAccessPromptWasShown : bool;
    6060enum class StorageAccessWasGranted : bool;
     61enum class ShouldAskITP : bool;
    6162struct SameSiteInfo;
    6263
    … …  
    198199    void registerURLSchemesAsCORSEnabled(Vector<String>&& schemes);
    199200
    200     void cookiesForDOM(const URL& firstParty, const WebCore::SameSiteInfo&, const URL&, Optional<WebCore::FrameIdentifier>, Optional<WebCore::PageIdentifier>, WebCore::IncludeSecureCookies, CompletionHandler<void(String cookieString, bool secureCookiesAccessed)>&&);
    201     void setCookiesFromDOM(const URL& firstParty, const WebCore::SameSiteInfo&, const URL&, Optional<WebCore::FrameIdentifier>, Optional<WebCore::PageIdentifier>, const String&);
     201    void cookiesForDOM(const URL& firstParty, const WebCore::SameSiteInfo&, const URL&, WebCore::FrameIdentifier, WebCore::PageIdentifier, WebCore::IncludeSecureCookies, WebCore::ShouldAskITP, CompletionHandler<void(String cookieString, bool secureCookiesAccessed)>&&);
     202    void setCookiesFromDOM(const URL& firstParty, const WebCore::SameSiteInfo&, const URL&, WebCore::FrameIdentifier, WebCore::PageIdentifier, WebCore::ShouldAskITP, const String&);
    202203    void cookiesEnabled(CompletionHandler<void(bool)>&&);
    203     void cookieRequestHeaderFieldValue(const URL& firstParty, const WebCore::SameSiteInfo&, const URL&, Optional<WebCore::FrameIdentifier>, Optional<WebCore::PageIdentifier>, WebCore::IncludeSecureCookies, CompletionHandler<void(String cookieString, bool secureCookiesAccessed)>&&);
    204     void getRawCookies(const URL& firstParty, const WebCore::SameSiteInfo&, const URL&, Optional<WebCore::FrameIdentifier>, Optional<WebCore::PageIdentifier>, CompletionHandler<void(Vector<WebCore::Cookie>&&)>&&);
     204    void cookieRequestHeaderFieldValue(const URL& firstParty, const WebCore::SameSiteInfo&, const URL&, Optional<WebCore::FrameIdentifier>, Optional<WebCore::PageIdentifier>, WebCore::IncludeSecureCookies, WebCore::ShouldAskITP, CompletionHandler<void(String cookieString, bool secureCookiesAccessed)>&&);
     205    void getRawCookies(const URL& firstParty, const WebCore::SameSiteInfo&, const URL&, Optional<WebCore::FrameIdentifier>, Optional<WebCore::PageIdentifier>, WebCore::ShouldAskITP, CompletionHandler<void(Vector<WebCore::Cookie>&&)>&&);
    205206    void deleteCookie(const URL&, const String& cookieName);
    206207

  • trunk/Source/WebKit/NetworkProcess/NetworkConnectionToWebProcess.messages.in

    r253452 r254556  
    3535    ConvertMainResourceLoadToDownload(uint64_t mainResourceLoadIdentifier, WebKit::DownloadID downloadID, WebCore::ResourceRequest request, WebCore::ResourceResponse response)
    3636
    37     CookiesForDOM(URL firstParty, struct WebCore::SameSiteInfo sameSiteInfo, URL url, Optional<WebCore::FrameIdentifier> frameID, Optional<WebCore::PageIdentifier> pageID, enum:bool WebCore::IncludeSecureCookies includeSecureCookies) -> (String cookieString, bool didAccessSecureCookies) Synchronous
    38     SetCookiesFromDOM(URL firstParty, struct WebCore::SameSiteInfo sameSiteInfo, URL url, Optional<WebCore::FrameIdentifier> frameID, Optional<WebCore::PageIdentifier> pageID, String cookieString)
     37    CookiesForDOM(URL firstParty, struct WebCore::SameSiteInfo sameSiteInfo, URL url, WebCore::FrameIdentifier frameID, WebCore::PageIdentifier pageID, enum:bool WebCore::IncludeSecureCookies includeSecureCookies, enum:bool WebCore::ShouldAskITP shouldAskITP) -> (String cookieString, bool didAccessSecureCookies) Synchronous
     38    SetCookiesFromDOM(URL firstParty, struct WebCore::SameSiteInfo sameSiteInfo, URL url, WebCore::FrameIdentifier frameID, WebCore::PageIdentifier pageID, enum:bool WebCore::ShouldAskITP shouldAskITP, String cookieString)
    3939    CookiesEnabled() -> (bool enabled) Synchronous
    40     CookieRequestHeaderFieldValue(URL firstParty, struct WebCore::SameSiteInfo sameSiteInfo, URL url, Optional<WebCore::FrameIdentifier> frameID, Optional<WebCore::PageIdentifier> pageID, enum:bool WebCore::IncludeSecureCookies includeSecureCookies) -> (String cookieString, bool didAccessSecureCookies) Synchronous
    41     GetRawCookies(URL firstParty, struct WebCore::SameSiteInfo sameSiteInfo, URL url, Optional<WebCore::FrameIdentifier> frameID, Optional<WebCore::PageIdentifier> pageID) -> (Vector<WebCore::Cookie> cookies) Synchronous
     40    CookieRequestHeaderFieldValue(URL firstParty, struct WebCore::SameSiteInfo sameSiteInfo, URL url, Optional<WebCore::FrameIdentifier> frameID, Optional<WebCore::PageIdentifier> pageID, enum:bool WebCore::IncludeSecureCookies includeSecureCookies, enum:bool WebCore::ShouldAskITP shouldAskITP) -> (String cookieString, bool didAccessSecureCookies) Synchronous
     41    GetRawCookies(URL firstParty, struct WebCore::SameSiteInfo sameSiteInfo, URL url, Optional<WebCore::FrameIdentifier> frameID, Optional<WebCore::PageIdentifier> pageID, enum:bool WebCore::ShouldAskITP shouldAskITP) -> (Vector<WebCore::Cookie> cookies) Synchronous
    4242    DeleteCookie(URL url, String cookieName)
    4343

  • trunk/Source/WebKit/NetworkProcess/NetworkResourceLoader.cpp

    r254409 r254556  
    12261226
    12271227    Vector<WebCore::Cookie> cookies;
    1228     if (!networkStorageSession.getRawCookies(firstParty, sameSiteInfo, url, frameID, pageID, cookies))
     1228    if (!networkStorageSession.getRawCookies(firstParty, sameSiteInfo, url, frameID, pageID, ShouldAskITP::Yes, cookies))
    12291229        return;
    12301230

  • trunk/Source/WebKit/NetworkProcess/NetworkSessionCreationParameters.cpp

    r253277 r254556  
    6969    encoder << enableResourceLoadStatisticsDebugMode;
    7070    encoder << resourceLoadStatisticsManualPrevalentResource;
     71#if ENABLE(RESOURCE_LOAD_STATISTICS)
    7172    encoder << thirdPartyCookieBlockingMode;
     73#endif
    7274    encoder << firstPartyWebsiteDataRemovalMode;
    7375
    … …  
    203205        return WTF::nullopt;
    204206
     207#if ENABLE(RESOURCE_LOAD_STATISTICS)
    205208    Optional<WebCore::ThirdPartyCookieBlockingMode> thirdPartyCookieBlockingMode;
    206209    decoder >> thirdPartyCookieBlockingMode;
    207210    if (!thirdPartyCookieBlockingMode)
    208211        return WTF::nullopt;
     212#endif
    209213
    210214    Optional<WebCore::FirstPartyWebsiteDataRemovalMode> firstPartyWebsiteDataRemovalMode;
    … …  
    301305        , WTFMove(*shouldIncludeLocalhostInResourceLoadStatistics)
    302306        , WTFMove(*enableResourceLoadStatisticsDebugMode)
     307#if ENABLE(RESOURCE_LOAD_STATISTICS)
    303308        , WTFMove(*thirdPartyCookieBlockingMode)
     309#endif
    304310        , WTFMove(*firstPartyWebsiteDataRemovalMode)
    305311        , WTFMove(*deviceManagementRestrictionsEnabled)

  • trunk/Source/WebKit/NetworkProcess/NetworkSessionCreationParameters.h

    r254293 r254556  
    8787    bool shouldIncludeLocalhostInResourceLoadStatistics { true };
    8888    bool enableResourceLoadStatisticsDebugMode { false };
     89#if ENABLE(RESOURCE_LOAD_STATISTICS)
    8990    WebCore::ThirdPartyCookieBlockingMode thirdPartyCookieBlockingMode { WebCore::ThirdPartyCookieBlockingMode::All };
     91#endif
    9092    WebCore::FirstPartyWebsiteDataRemovalMode firstPartyWebsiteDataRemovalMode { WebCore::FirstPartyWebsiteDataRemovalMode::AllButCookies };
    9193    bool deviceManagementRestrictionsEnabled { false };

  • trunk/Source/WebKit/Scripts/webkit/messages.py

    r254516 r254556  
    586586        'WebCore::ShippingContactUpdate': ['<WebCore/ApplePaySessionPaymentRequest.h>'],
    587587        'WebCore::ShippingMethodUpdate': ['<WebCore/ApplePaySessionPaymentRequest.h>'],
     588        'WebCore::ShouldAskITP': ['<WebCore/NetworkStorageSession.h>'],
    588589        'WebCore::ShouldNotifyWhenResolved': ['<WebCore/ServiceWorkerTypes.h>'],
    589590        'WebCore::ShouldSample': ['<WebCore/DiagnosticLoggingClient.h>'],

  • trunk/Source/WebKit/Shared/WebProcessDataStoreParameters.h

    r250016 r254556  
    2727
    2828#include "SandboxExtension.h"
     29#include <WebCore/NetworkStorageSession.h>
    2930#include <pal/SessionID.h>
    3031#include <wtf/HashMap.h>
    … …  
    4647    SandboxExtension::Handle javaScriptConfigurationDirectoryExtensionHandle;
    4748    HashMap<unsigned, WallTime> plugInAutoStartOriginHashes;
     49#if ENABLE(RESOURCE_LOAD_STATISTICS)
     50    WebCore::ThirdPartyCookieBlockingMode thirdPartyCookieBlockingMode { WebCore::ThirdPartyCookieBlockingMode::All };
     51#endif
    4852    bool resourceLoadStatisticsEnabled { false };
    4953
    … …  
    6872    encoder << javaScriptConfigurationDirectoryExtensionHandle;
    6973    encoder << plugInAutoStartOriginHashes;
     74#if ENABLE(RESOURCE_LOAD_STATISTICS)
     75    encoder << thirdPartyCookieBlockingMode;
     76#endif
    7077    encoder << resourceLoadStatisticsEnabled;
    7178}
    … …  
    133140        return WTF::nullopt;
    134141
     142#if ENABLE(RESOURCE_LOAD_STATISTICS)
     143    Optional<WebCore::ThirdPartyCookieBlockingMode> thirdPartyCookieBlockingMode;
     144    decoder >> thirdPartyCookieBlockingMode;
     145    if (!thirdPartyCookieBlockingMode)
     146        return WTF::nullopt;
     147#endif
     148
    135149    bool resourceLoadStatisticsEnabled = false;
    136150    if (!decoder.decode(resourceLoadStatisticsEnabled))
    … …  
    151165        WTFMove(*javaScriptConfigurationDirectoryExtensionHandle),
    152166        WTFMove(*plugInAutoStartOriginHashes),
     167#if ENABLE(RESOURCE_LOAD_STATISTICS)
     168        *thirdPartyCookieBlockingMode,
     169#endif
    153170        resourceLoadStatisticsEnabled
    154171    };

  • trunk/Source/WebKit/UIProcess/Network/NetworkProcessProxy.cpp

    r254345 r254556  
    11161116void NetworkProcessProxy::setShouldBlockThirdPartyCookiesForTesting(PAL::SessionID sessionID, ThirdPartyCookieBlockingMode blockingMode, CompletionHandler<void()>&& completionHandler)
    11171117{
    1118     if (!canSendMessage()) {
    1119         completionHandler();
    1120         return;
    1121     }
    1122    
    11231118    sendWithAsyncReply(Messages::NetworkProcess::SetShouldBlockThirdPartyCookiesForTesting(sessionID, blockingMode), WTFMove(completionHandler));
    11241119}

  • trunk/Source/WebKit/UIProcess/WebProcessPool.cpp

    r254487 r254556  
    581581    bool shouldIncludeLocalhost = true;
    582582    bool enableResourceLoadStatisticsDebugMode = false;
     583#if ENABLE(RESOURCE_LOAD_STATISTICS)
    583584    WebCore::ThirdPartyCookieBlockingMode thirdPartyCookieBlockingMode = WebCore::ThirdPartyCookieBlockingMode::All;
     585#endif
    584586    WebCore::FirstPartyWebsiteDataRemovalMode firstPartyWebsiteDataRemovalMode = WebCore::FirstPartyWebsiteDataRemovalMode::AllButCookies;
    585587    WebCore::RegistrableDomain manualPrevalentResource { };
    … …  
    593595            shouldIncludeLocalhost = networkSessionParameters.shouldIncludeLocalhostInResourceLoadStatistics;
    594596            enableResourceLoadStatisticsDebugMode = networkSessionParameters.enableResourceLoadStatisticsDebugMode;
     597#if ENABLE(RESOURCE_LOAD_STATISTICS)
    595598            thirdPartyCookieBlockingMode = networkSessionParameters.thirdPartyCookieBlockingMode;
     599#endif
    596600            firstPartyWebsiteDataRemovalMode = networkSessionParameters.firstPartyWebsiteDataRemovalMode;
    597601            manualPrevalentResource = networkSessionParameters.resourceLoadStatisticsManualPrevalentResource;
    … …  
    615619            shouldIncludeLocalhost = networkSessionParameters.shouldIncludeLocalhostInResourceLoadStatistics;
    616620            enableResourceLoadStatisticsDebugMode = networkSessionParameters.enableResourceLoadStatisticsDebugMode;
     621#if ENABLE(RESOURCE_LOAD_STATISTICS)
    617622            thirdPartyCookieBlockingMode = networkSessionParameters.thirdPartyCookieBlockingMode;
     623#endif
    618624            firstPartyWebsiteDataRemovalMode = networkSessionParameters.firstPartyWebsiteDataRemovalMode;
    619625            manualPrevalentResource = networkSessionParameters.resourceLoadStatisticsManualPrevalentResource;
    … …  
    640646    parameters.defaultDataStoreParameters.networkSessionParameters.shouldIncludeLocalhostInResourceLoadStatistics = shouldIncludeLocalhost;
    641647    parameters.defaultDataStoreParameters.networkSessionParameters.enableResourceLoadStatisticsDebugMode = enableResourceLoadStatisticsDebugMode;
     648#if ENABLE(RESOURCE_LOAD_STATISTICS)
    642649    parameters.defaultDataStoreParameters.networkSessionParameters.thirdPartyCookieBlockingMode = thirdPartyCookieBlockingMode;
     650#endif
    643651    parameters.defaultDataStoreParameters.networkSessionParameters.firstPartyWebsiteDataRemovalMode = firstPartyWebsiteDataRemovalMode;
    644652
    … …  
    946954        WTFMove(javaScriptConfigurationDirectoryExtensionHandle),
    947955        WTFMove(plugInAutoStartOriginHashes),
     956#if ENABLE(RESOURCE_LOAD_STATISTICS)
     957        websiteDataStore.thirdPartyCookieBlockingMode(),
     958#endif
    948959        websiteDataStore.resourceLoadStatisticsEnabled()
    949960    };

  • trunk/Source/WebKit/UIProcess/WebProcessProxy.cpp

    r254392 r254556  
    434434        page.value->postMessageToInjectedBundle("ResourceLoadStatisticsTelemetryFinished", messageBody);
    435435}
     436
     437void WebProcessProxy::setShouldBlockThirdPartyCookiesForTesting(ThirdPartyCookieBlockingMode thirdPartyCookieBlockingMode, CompletionHandler<void()>&& completionHandler)
     438{
     439    sendWithAsyncReply(Messages::WebProcess::SetShouldBlockThirdPartyCookiesForTesting(thirdPartyCookieBlockingMode), WTFMove(completionHandler));
     440}
    436441#endif
    437442

  • trunk/Source/WebKit/UIProcess/WebProcessProxy.h

    r254392 r254556  
    6767struct PrewarmInformation;
    6868struct SecurityOriginData;
     69enum class ThirdPartyCookieBlockingMode : uint8_t;
    6970}
    7071
    … …  
    207208    static void notifyWebsiteDataDeletionForRegistrableDomainsFinished();
    208209    static void notifyWebsiteDataScanForRegistrableDomainsFinished();
     210
     211    void setShouldBlockThirdPartyCookiesForTesting(WebCore::ThirdPartyCookieBlockingMode, CompletionHandler<void()>&&);
    209212#endif
    210213

  • trunk/Source/WebKit/UIProcess/WebsiteData/Cocoa/WebsiteDataStoreCocoa.mm

    r254344 r254556  
    6262static NSString * const WebKitNetworkLoadThrottleLatencyMillisecondsDefaultsKey = @"WebKitNetworkLoadThrottleLatencyMilliseconds";
    6363
     64#if ENABLE(RESOURCE_LOAD_STATISTICS)
     65WebCore::ThirdPartyCookieBlockingMode WebsiteDataStore::thirdPartyCookieBlockingMode() const
     66{
     67    if (!m_thirdPartyCookieBlockingMode) {
     68        NSUserDefaults *defaults = [NSUserDefaults standardUserDefaults];
     69        if ([defaults boolForKey:[NSString stringWithFormat:@"Experimental%@", WebPreferencesKey::isThirdPartyCookieBlockingDisabledKey().createCFString().get()]])
     70            m_thirdPartyCookieBlockingMode = WebCore::ThirdPartyCookieBlockingMode::AllOnSitesWithoutUserInteraction;
     71        else
     72            m_thirdPartyCookieBlockingMode = WebCore::ThirdPartyCookieBlockingMode::All;
     73    }
     74    return *m_thirdPartyCookieBlockingMode;
     75}
     76#endif
     77
    6478WebsiteDataStoreParameters WebsiteDataStore::parameters()
    6579{
    … …  
    7185    bool shouldLogCookieInformation = false;
    7286    bool enableResourceLoadStatisticsDebugMode = false;
    73     auto thirdPartyCookieBlockingMode = WebCore::ThirdPartyCookieBlockingMode::All;
    7487    auto firstPartyWebsiteDataRemovalMode = WebCore::FirstPartyWebsiteDataRemovalMode::AllButCookies;
    7588    bool enableLegacyTLS = configuration().legacyTLSEnabled();
    … …  
    8699#if ENABLE(RESOURCE_LOAD_STATISTICS)
    87100    enableResourceLoadStatisticsDebugMode = [defaults boolForKey:@"ITPDebugMode"];
    88     if ([defaults boolForKey:[NSString stringWithFormat:@"Experimental%@", WebPreferencesKey::isThirdPartyCookieBlockingDisabledKey().createCFString().get()]])
    89         thirdPartyCookieBlockingMode = WebCore::ThirdPartyCookieBlockingMode::AllOnSitesWithoutUserInteraction;
    90     else
    91         thirdPartyCookieBlockingMode = WebCore::ThirdPartyCookieBlockingMode::All;
    92101    if ([defaults boolForKey:[NSString stringWithFormat:@"Experimental%@", WebPreferencesKey::isFirstPartyWebsiteDataRemovalDisabledKey().createCFString().get()]])
    93102        firstPartyWebsiteDataRemovalMode = WebCore::FirstPartyWebsiteDataRemovalMode::None;
    … …  
    163172        shouldIncludeLocalhostInResourceLoadStatistics,
    164173        enableResourceLoadStatisticsDebugMode,
    165         thirdPartyCookieBlockingMode,
     174        thirdPartyCookieBlockingMode(),
    166175        firstPartyWebsiteDataRemovalMode,
    167176        m_configuration->deviceManagementRestrictionsEnabled(),

  • trunk/Source/WebKit/UIProcess/WebsiteData/WebsiteDataStore.cpp

    r254392 r254556  
    18001800}
    18011801
     1802#if !PLATFORM(COCOA)
     1803WebCore::ThirdPartyCookieBlockingMode WebsiteDataStore::thirdPartyCookieBlockingMode() const
     1804{
     1805    if (!m_thirdPartyCookieBlockingMode)
     1806        m_thirdPartyCookieBlockingMode = WebCore::ThirdPartyCookieBlockingMode::All;
     1807    return *m_thirdPartyCookieBlockingMode;
     1808}
     1809#endif
     1810
    18021811void WebsiteDataStore::setResourceLoadStatisticsShouldBlockThirdPartyCookiesForTesting(bool enabled, bool onlyOnSitesWithoutUserInteraction, CompletionHandler<void()>&& completionHandler)
    18031812{
    … …  
    18061815    if (enabled)
    18071816        blockingMode = onlyOnSitesWithoutUserInteraction ? WebCore::ThirdPartyCookieBlockingMode::AllOnSitesWithoutUserInteraction : WebCore::ThirdPartyCookieBlockingMode::All;
     1817
     1818    if (thirdPartyCookieBlockingMode() != blockingMode) {
     1819        m_thirdPartyCookieBlockingMode = blockingMode;
     1820        for (auto& webProcess : processes())
     1821            webProcess.setShouldBlockThirdPartyCookiesForTesting(blockingMode, [callbackAggregator = callbackAggregator.copyRef()] { });
     1822    }
    18081823
    18091824    for (auto& processPool : processPools()) {

  • trunk/Source/WebKit/UIProcess/WebsiteData/WebsiteDataStore.h

    r254342 r254556  
    195195    void setResourceLoadStatisticsShouldBlockThirdPartyCookiesForTesting(bool enabled, bool onlyOnSitesWithoutUserInteraction, CompletionHandler<void()>&&);
    196196    void setResourceLoadStatisticsFirstPartyWebsiteDataRemovalModeForTesting(bool enabled, CompletionHandler<void()>&&);
     197    WebCore::ThirdPartyCookieBlockingMode thirdPartyCookieBlockingMode() const;
    197198#endif
    198199    void setCacheMaxAgeCapForPrevalentResources(Seconds, CompletionHandler<void()>&&);
    … …  
    374375    UniqueRef<SOAuthorizationCoordinator> m_soAuthorizationCoordinator;
    375376#endif
     377#if ENABLE(RESOURCE_LOAD_STATISTICS)
     378    mutable Optional<WebCore::ThirdPartyCookieBlockingMode> m_thirdPartyCookieBlockingMode; // Lazily computed.
     379#endif
    376380};
    377381

  • trunk/Source/WebKit/WebProcess/WebCoreSupport/WebResourceLoadObserver.cpp

    r252641 r254556  
    7272}
    7373
    74 void WebResourceLoadObserver::requestStorageAccessUnderOpener(const RegistrableDomain& domainInNeedOfStorageAccess, PageIdentifier openerPageID, Document& openerDocument)
     74void WebResourceLoadObserver::requestStorageAccessUnderOpener(const RegistrableDomain& domainInNeedOfStorageAccess, WebPage& openerPage, Document& openerDocument)
    7575{
    7676    auto openerUrl = openerDocument.url();
    … …  
    7979        && !openerDocument.hasRequestedPageSpecificStorageAccessWithUserInteraction(domainInNeedOfStorageAccess)
    8080        && !equalIgnoringASCIICase(openerUrl.string(), WTF::blankURL())) {
    81         WebProcess::singleton().ensureNetworkProcessConnection().connection().send(Messages::NetworkConnectionToWebProcess::RequestStorageAccessUnderOpener(domainInNeedOfStorageAccess, openerPageID, openerDomain), 0);
     81        WebProcess::singleton().ensureNetworkProcessConnection().connection().send(Messages::NetworkConnectionToWebProcess::RequestStorageAccessUnderOpener(domainInNeedOfStorageAccess, openerPage.identifier(), openerDomain), 0);
    8282       
     83        openerPage.addDomainWithPageLevelStorageAccess(openerDomain, domainInNeedOfStorageAccess);
     84
    8385        // Remember user interaction-based requests since they don't need to be repeated.
    8486        openerDocument.setHasRequestedPageSpecificStorageAccessWithUserInteraction(domainInNeedOfStorageAccess);
    … …  
    336338        if (auto* opener = frame->loader().opener()) {
    337339            if (auto* openerDocument = opener->document()) {
    338                 if (auto* openerFrame = openerDocument->frame()) {
    339                     if (auto openerPageID = openerFrame->loader().client().pageID())
    340                         requestStorageAccessUnderOpener(topFrameDomain, openerPageID.value(), *openerDocument);
    341                 }
     340                if (auto* openerPage = openerDocument->page())
     341                    requestStorageAccessUnderOpener(topFrameDomain, WebPage::fromCorePage(*openerPage), *openerDocument);
    342342            }
    343343        }

  • trunk/Source/WebKit/WebProcess/WebCoreSupport/WebResourceLoadObserver.h

    r252641 r254556  
    3535namespace WebKit {
    3636
     37class WebPage;
     38
    3739class WebResourceLoadObserver final : public WebCore::ResourceLoadObserver {
    3840public:
    … …  
    6567
    6668    Vector<WebCore::ResourceLoadStatistics> takeStatistics();
    67     void requestStorageAccessUnderOpener(const WebCore::RegistrableDomain& domainInNeedOfStorageAccess, WebCore::PageIdentifier openerPageID, WebCore::Document& openerDocument);
     69    void requestStorageAccessUnderOpener(const WebCore::RegistrableDomain& domainInNeedOfStorageAccess, WebPage& openerPage, WebCore::Document& openerDocument);
    6870
    6971    HashMap<WebCore::RegistrableDomain, WebCore::ResourceLoadStatistics> m_resourceStatisticsMap;

  • trunk/Source/WebKit/WebProcess/WebPage/WebCookieJar.cpp

    r250153 r254556  
    2929#include "NetworkConnectionToWebProcessMessages.h"
    3030#include "NetworkProcessConnection.h"
     31#include "WebFrame.h"
     32#include "WebPage.h"
    3133#include "WebProcess.h"
    3234#include <WebCore/CookieRequestHeaderFieldProxy.h>
     35#include <WebCore/DeprecatedGlobalSettings.h>
    3336#include <WebCore/Document.h>
    3437#include <WebCore/Frame.h>
    … …  
    4952    : WebCore::CookieJar(adoptRef(*new WebStorageSessionProvider)) { }
    5053
     54#if ENABLE(RESOURCE_LOAD_STATISTICS)
     55static bool shouldBlockCookies(WebFrame* frame, const URL& firstPartyForCookies, const URL& resourceURL, ShouldAskITP& shouldAskITPInNetworkProcess)
     56{
     57    if (!WebCore::DeprecatedGlobalSettings::resourceLoadStatisticsEnabled())
     58        return false;
     59
     60    if (frame && frame->isMainFrame())
     61        return false;
     62
     63    RegistrableDomain firstPartyDomain { firstPartyForCookies };
     64    if (firstPartyDomain.isEmpty())
     65        return false;
     66
     67    RegistrableDomain resourceDomain { resourceURL };
     68    if (resourceDomain.isEmpty())
     69        return false;
     70
     71    if (firstPartyDomain == resourceDomain)
     72        return false;
     73
     74    if (frame && frame->frameLoaderClient()->hasFrameSpecificStorageAccess())
     75        return false;
     76
     77    if (frame && frame->page() && frame->page()->hasPageLevelStorageAccess(firstPartyDomain, resourceDomain))
     78        return false;
     79
     80    // The WebContent process does not have enough information to deal with other policies than ThirdPartyCookieBlockingMode::All so we have to go to the NetworkProcess for all
     81    // other policies and the request may end up getting blocked on NetworkProcess side.
     82    if (WebProcess::singleton().thirdPartyCookieBlockingMode() != ThirdPartyCookieBlockingMode::All) {
     83        shouldAskITPInNetworkProcess = ShouldAskITP::Yes;
     84        return false;
     85    }
     86
     87    return true;
     88}
     89#endif
     90
    5191String WebCookieJar::cookies(WebCore::Document& document, const URL& url) const
    5292{
    53     Optional<FrameIdentifier> frameID;
    54     Optional<PageIdentifier> pageID;
    55     if (auto* frame = document.frame()) {
    56         frameID = frame->loader().client().frameID();
    57         pageID = frame->loader().client().pageID();
    58     }
     93    auto* webFrame = document.frame() ? WebFrame::fromCoreFrame(*document.frame()) : nullptr;
     94    if (!webFrame || !webFrame->page())
     95        return { };
     96
     97    ShouldAskITP shouldAskITPInNetworkProcess = ShouldAskITP::No;
     98#if ENABLE(RESOURCE_LOAD_STATISTICS)
     99    if (shouldBlockCookies(webFrame, document.firstPartyForCookies(), url, shouldAskITPInNetworkProcess))
     100        return { };
     101#endif
     102
     103    auto frameID = webFrame->frameID();
     104    auto pageID = webFrame->page()->identifier();
    59105
    60106    String cookieString;
    61107    bool secureCookiesAccessed = false;
    62     if (!WebProcess::singleton().ensureNetworkProcessConnection().connection().sendSync(Messages::NetworkConnectionToWebProcess::CookiesForDOM(document.firstPartyForCookies(), sameSiteInfo(document), url, frameID, pageID, shouldIncludeSecureCookies(document, url)), Messages::NetworkConnectionToWebProcess::CookiesForDOM::Reply(cookieString, secureCookiesAccessed), 0))
     108    if (!WebProcess::singleton().ensureNetworkProcessConnection().connection().sendSync(Messages::NetworkConnectionToWebProcess::CookiesForDOM(document.firstPartyForCookies(), sameSiteInfo(document), url, frameID, pageID, shouldIncludeSecureCookies(document, url), shouldAskITPInNetworkProcess), Messages::NetworkConnectionToWebProcess::CookiesForDOM::Reply(cookieString, secureCookiesAccessed), 0))
    63109        return { };
    64110
    … …  
    68114void WebCookieJar::setCookies(WebCore::Document& document, const URL& url, const String& cookieString)
    69115{
    70     Optional<FrameIdentifier> frameID;
    71     Optional<PageIdentifier> pageID;
    72     if (auto* frame = document.frame()) {
    73         frameID = frame->loader().client().frameID();
    74         pageID = frame->loader().client().pageID();
    75     }
     116    auto* webFrame = document.frame() ? WebFrame::fromCoreFrame(*document.frame()) : nullptr;
     117    if (!webFrame || !webFrame->page())
     118        return;
    76119
    77     WebProcess::singleton().ensureNetworkProcessConnection().connection().send(Messages::NetworkConnectionToWebProcess::SetCookiesFromDOM(document.firstPartyForCookies(), sameSiteInfo(document), url, frameID, pageID, cookieString), 0);
     120    ShouldAskITP shouldAskITPInNetworkProcess = ShouldAskITP::No;
     121#if ENABLE(RESOURCE_LOAD_STATISTICS)
     122    if (shouldBlockCookies(webFrame, document.firstPartyForCookies(), url, shouldAskITPInNetworkProcess))
     123        return;
     124#endif
     125
     126    auto frameID = webFrame->frameID();
     127    auto pageID = webFrame->page()->identifier();
     128
     129    WebProcess::singleton().ensureNetworkProcessConnection().connection().send(Messages::NetworkConnectionToWebProcess::SetCookiesFromDOM(document.firstPartyForCookies(), sameSiteInfo(document), url, frameID, pageID, shouldAskITPInNetworkProcess, cookieString), 0);
    78130}
    79131
    … …  
    88140std::pair<String, WebCore::SecureCookiesAccessed> WebCookieJar::cookieRequestHeaderFieldValue(const URL& firstParty, const WebCore::SameSiteInfo& sameSiteInfo, const URL& url, Optional<FrameIdentifier> frameID, Optional<PageIdentifier> pageID, WebCore::IncludeSecureCookies includeSecureCookies) const
    89141{
     142    ShouldAskITP shouldAskITPInNetworkProcess = ShouldAskITP::No;
     143#if ENABLE(RESOURCE_LOAD_STATISTICS)
     144    auto* webFrame = frameID ? WebProcess::singleton().webFrame(*frameID) : nullptr;
     145    if (shouldBlockCookies(webFrame, firstParty, url, shouldAskITPInNetworkProcess))
     146        return { };
     147#endif
     148
    90149    String cookieString;
    91150    bool secureCookiesAccessed = false;
    92     if (!WebProcess::singleton().ensureNetworkProcessConnection().connection().sendSync(Messages::NetworkConnectionToWebProcess::CookieRequestHeaderFieldValue(firstParty, sameSiteInfo, url, frameID, pageID, includeSecureCookies), Messages::NetworkConnectionToWebProcess::CookieRequestHeaderFieldValue::Reply(cookieString, secureCookiesAccessed), 0))
     151    if (!WebProcess::singleton().ensureNetworkProcessConnection().connection().sendSync(Messages::NetworkConnectionToWebProcess::CookieRequestHeaderFieldValue(firstParty, sameSiteInfo, url, frameID, pageID, includeSecureCookies, shouldAskITPInNetworkProcess), Messages::NetworkConnectionToWebProcess::CookieRequestHeaderFieldValue::Reply(cookieString, secureCookiesAccessed), 0))
    93152        return { };
    94153    return { cookieString, secureCookiesAccessed ? WebCore::SecureCookiesAccessed::Yes : WebCore::SecureCookiesAccessed::No };
    … …  
    97156bool WebCookieJar::getRawCookies(const WebCore::Document& document, const URL& url, Vector<WebCore::Cookie>& rawCookies) const
    98157{
    99     Optional<FrameIdentifier> frameID;
    100     Optional<PageIdentifier> pageID;
    101     if (auto* frame = document.frame()) {
    102         frameID = frame->loader().client().frameID();
    103         pageID = frame->loader().client().pageID();
    104     }
     158    auto* webFrame = document.frame() ? WebFrame::fromCoreFrame(*document.frame()) : nullptr;
     159    ShouldAskITP shouldAskITPInNetworkProcess = ShouldAskITP::No;
     160#if ENABLE(RESOURCE_LOAD_STATISTICS)
     161    if (shouldBlockCookies(webFrame, document.firstPartyForCookies(), url, shouldAskITPInNetworkProcess))
     162        return { };
     163#endif
    105164
    106     if (!WebProcess::singleton().ensureNetworkProcessConnection().connection().sendSync(Messages::NetworkConnectionToWebProcess::GetRawCookies(document.firstPartyForCookies(), sameSiteInfo(document), url, frameID, pageID), Messages::NetworkConnectionToWebProcess::GetRawCookies::Reply(rawCookies), 0))
     165    Optional<FrameIdentifier> frameID = webFrame ? makeOptional(webFrame->frameID()) : WTF::nullopt;
     166    Optional<PageIdentifier> pageID = webFrame && webFrame->page() ? makeOptional(webFrame->page()->identifier()) : WTF::nullopt;
     167    if (!WebProcess::singleton().ensureNetworkProcessConnection().connection().sendSync(Messages::NetworkConnectionToWebProcess::GetRawCookies(document.firstPartyForCookies(), sameSiteInfo(document), url, frameID, pageID, shouldAskITPInNetworkProcess), Messages::NetworkConnectionToWebProcess::GetRawCookies::Reply(rawCookies), 0))
    107168        return false;
    108169    return true;

  • trunk/Source/WebKit/WebProcess/WebPage/WebPage.cpp

    r254384 r254556  
    66066606}
    66076607
     6608void WebPage::addDomainWithPageLevelStorageAccess(const RegistrableDomain& topLevelDomain, const RegistrableDomain& resourceDomain)
     6609{
     6610    m_domainsWithPageLevelStorageAccess.add(topLevelDomain, resourceDomain);
     6611}
     6612
     6613bool WebPage::hasPageLevelStorageAccess(const RegistrableDomain& topLevelDomain, const RegistrableDomain& resourceDomain) const
     6614{
     6615    auto it = m_domainsWithPageLevelStorageAccess.find(topLevelDomain);
     6616    return it != m_domainsWithPageLevelStorageAccess.end() && it->value == resourceDomain;
     6617}
     6618
    66086619void WebPage::wasLoadedWithDataTransferFromPrevalentResource()
    66096620{

  • trunk/Source/WebKit/WebProcess/WebPage/WebPage.h

    r254387 r254556  
    11691169    void hasStorageAccess(WebCore::RegistrableDomain&& subFrameDomain, WebCore::RegistrableDomain&& topFrameDomain, WebFrame&, CompletionHandler<void(bool)>&&);
    11701170    void requestStorageAccess(WebCore::RegistrableDomain&& subFrameDomain, WebCore::RegistrableDomain&& topFrameDomain, WebFrame&, CompletionHandler<void(WebCore::StorageAccessWasGranted, WebCore::StorageAccessPromptWasShown)>&&);
     1171    bool hasPageLevelStorageAccess(const WebCore::RegistrableDomain& topLevelDomain, const WebCore::RegistrableDomain& resourceDomain) const;
     1172    void addDomainWithPageLevelStorageAccess(const WebCore::RegistrableDomain& topLevelDomain, const WebCore::RegistrableDomain& resourceDomain);
    11711173    void wasLoadedWithDataTransferFromPrevalentResource();
    11721174#endif
    … …  
    20372039#endif
    20382040
     2041#if ENABLE(RESOURCE_LOAD_STATISTICS)
     2042    HashMap<WebCore::RegistrableDomain, WebCore::RegistrableDomain> m_domainsWithPageLevelStorageAccess;
     2043#endif
     2044
    20392045    String m_overriddenMediaType;
    20402046};

  • trunk/Source/WebKit/WebProcess/WebProcess.cpp

    r254392 r254556  
    478478
    479479#if ENABLE(RESOURCE_LOAD_STATISTICS)
     480    m_thirdPartyCookieBlockingMode = parameters.thirdPartyCookieBlockingMode;
    480481    if (parameters.resourceLoadStatisticsEnabled && !parameters.sessionID.isEphemeral() && !ResourceLoadObserver::sharedIfExists())
    481482        ResourceLoadObserver::setShared(*new WebResourceLoadObserver);
    … …  
    19781979}
    19791980
     1981#if ENABLE(RESOURCE_LOAD_STATISTICS)
     1982void WebProcess::setShouldBlockThirdPartyCookiesForTesting(ThirdPartyCookieBlockingMode thirdPartyCookieBlockingMode, CompletionHandler<void()>&& completionHandler)
     1983{
     1984    m_thirdPartyCookieBlockingMode = thirdPartyCookieBlockingMode;
     1985    completionHandler();
     1986}
     1987#endif
     1988
    19801989} // namespace WebKit
    19811990

  • trunk/Source/WebKit/WebProcess/WebProcess.h

    r254433 r254556  
    4545#include <WebCore/ActivityState.h>
    4646#include <WebCore/FrameIdentifier.h>
     47#include <WebCore/NetworkStorageSession.h>
    4748#include <WebCore/PageIdentifier.h>
    4849#include <WebCore/RegistrableDomain.h>
    … …  
    166167    PAL::SessionID sessionID() const { ASSERT(m_sessionID); return *m_sessionID; }
    167168
     169#if ENABLE(RESOURCE_LOAD_STATISTICS)
     170    WebCore::ThirdPartyCookieBlockingMode thirdPartyCookieBlockingMode() const { return m_thirdPartyCookieBlockingMode; }
     171#endif
     172
    168173#if PLATFORM(COCOA)
    169174    const WTF::MachSendRight& compositingRenderServerPort() const { return m_compositingRenderServerPort; }
    … …  
    438443#endif
    439444
     445#if ENABLE(RESOURCE_LOAD_STATISTICS)
     446    void setShouldBlockThirdPartyCookiesForTesting(WebCore::ThirdPartyCookieBlockingMode, CompletionHandler<void()>&&);
     447#endif
     448
    440449    void platformInitializeProcess(const AuxiliaryProcessInitializationParameters&);
    441450
    … …  
    605614    // By the time the WebProcess gets a WebPage, it is guaranteed to have a sessionID.
    606615    Optional<PAL::SessionID> m_sessionID;
     616
     617#if ENABLE(RESOURCE_LOAD_STATISTICS)
     618    WebCore::ThirdPartyCookieBlockingMode m_thirdPartyCookieBlockingMode { WebCore::ThirdPartyCookieBlockingMode::All };
     619#endif
    607620};
    608621

  • trunk/Source/WebKit/WebProcess/WebProcess.messages.in

    r254433 r254556  
    163163#if ENABLE(RESOURCE_LOAD_STATISTICS)
    164164    SeedResourceLoadStatisticsForTesting(WebCore::RegistrableDomain firstPartyDomain, WebCore::RegistrableDomain thirdPartyDomain, bool shouldScheduleNotification) -> () Async
     165    SetShouldBlockThirdPartyCookiesForTesting(enum:uint8_t WebCore::ThirdPartyCookieBlockingMode blockingMode) -> () Async
    165166#endif
    166167}

  • trunk/Tools/ChangeLog

    r254554 r254556  
     12020-01-14  Chris Dumez  <cdumez@apple.com>
     2
     3        document.cookie should not do a sync IPC to the network process for iframes that do not have storage access
     4        https://bugs.webkit.org/show_bug.cgi?id=206108
     5
     6        Reviewed by Geoff Garen and John Wilander.
     7
     8        Make setStatisticsShouldBlockThirdPartyCookies IPC from the WebProcess to the UIProcess asynchronous
     9        since this ends up sending an IPC back to the WebProcess now (which would deadlock).
     10
     11        * WebKitTestRunner/InjectedBundle/TestRunner.cpp:
     12        (WTR::TestRunner::setStatisticsShouldBlockThirdPartyCookies):
     13        * WebKitTestRunner/TestInvocation.cpp:
     14        (WTR::TestInvocation::didReceiveMessageFromInjectedBundle):
     15        (WTR::TestInvocation::didReceiveSynchronousMessageFromInjectedBundle):
     16
    1172020-01-10  Jiewen Tan  <jiewen_tan@apple.com>
    218

  • trunk/Tools/WebKitTestRunner/InjectedBundle/TestRunner.cpp

    r253149 r254556  
    22362236        messageName = adoptWK(WKStringCreateWithUTF8CString("SetStatisticsShouldBlockThirdPartyCookiesOnSitesWithoutUserInteraction"));
    22372237    WKRetainPtr<WKBooleanRef> messageBody = adoptWK(WKBooleanCreate(value));
    2238     WKBundlePostSynchronousMessage(InjectedBundle::singleton().bundle(), messageName.get(), messageBody.get(), nullptr);
     2238    WKBundlePostMessage(InjectedBundle::singleton().bundle(), messageName.get(), messageBody.get());
    22392239    m_hasSetBlockThirdPartyCookiesCallback = true;
    22402240}

  • trunk/Tools/WebKitTestRunner/TestInvocation.cpp

    r253149 r254556  
    748748    }
    749749
     750    if (WKStringIsEqualToUTF8CString(messageName, "SetStatisticsShouldBlockThirdPartyCookiesOnSitesWithoutUserInteraction")) {
     751        ASSERT(WKGetTypeID(messageBody) == WKBooleanGetTypeID());
     752        WKBooleanRef value = static_cast<WKBooleanRef>(messageBody);
     753        TestController::singleton().setStatisticsShouldBlockThirdPartyCookies(WKBooleanGetValue(value), true);
     754        return;
     755    }
     756
     757    if (WKStringIsEqualToUTF8CString(messageName, "SetStatisticsShouldBlockThirdPartyCookies")) {
     758        ASSERT(WKGetTypeID(messageBody) == WKBooleanGetTypeID());
     759        WKBooleanRef value = static_cast<WKBooleanRef>(messageBody);
     760        TestController::singleton().setStatisticsShouldBlockThirdPartyCookies(WKBooleanGetValue(value), false);
     761        return;
     762    }
     763
    750764    if (WKStringIsEqualToUTF8CString(messageName, "RunUIProcessScript")) {
    751765        WKDictionaryRef messageBodyDictionary = static_cast<WKDictionaryRef>(messageBody);
    … …  
    15601574    }
    15611575   
    1562     if (WKStringIsEqualToUTF8CString(messageName, "SetStatisticsShouldBlockThirdPartyCookiesOnSitesWithoutUserInteraction")) {
    1563         ASSERT(WKGetTypeID(messageBody) == WKBooleanGetTypeID());
    1564         WKBooleanRef value = static_cast<WKBooleanRef>(messageBody);
    1565         TestController::singleton().setStatisticsShouldBlockThirdPartyCookies(WKBooleanGetValue(value), true);
    1566         return nullptr;
    1567     }
    1568    
    1569     if (WKStringIsEqualToUTF8CString(messageName, "SetStatisticsShouldBlockThirdPartyCookies")) {
    1570         ASSERT(WKGetTypeID(messageBody) == WKBooleanGetTypeID());
    1571         WKBooleanRef value = static_cast<WKBooleanRef>(messageBody);
    1572         TestController::singleton().setStatisticsShouldBlockThirdPartyCookies(WKBooleanGetValue(value), false);
    1573         return nullptr;
    1574     }
    1575    
    15761576    if (WKStringIsEqualToUTF8CString(messageName, "SetStatisticsFirstPartyWebsiteDataRemovalMode")) {
    15771577        ASSERT(WKGetTypeID(messageBody) == WKBooleanGetTypeID());
Note: See TracChangeset for help on using the changeset viewer.