⚠ Archived content — this site is no longer maintained.   Current WebKit documentation is at docs.webkit.org.

Changeset 225934 in webkit


Ignore:
Timestamp:
Dec 14, 2017, 2:39:48 PM (9 years ago)
Author:
wilander@apple.com
Message:

Storage Access API: Implement frame-specific access in the document.cookie layer
​https://bugs.webkit.org/show_bug.cgi?id=180682
<rdar://problem/35982257>

Reviewed by Alex Christensen.

Source/WebCore:

No new tests. Changed expected result from existing test.

CookiesStrategy::cookiesForDOM(), CookiesStrategy::setCookiesFromDOM(),
CookiesStrategy::cookieRequestHeaderFieldValue(), and
CookiesStrategy::getRawCookies() now take optional parameters for
frameID and pageID to allow frame-specific scoping of cookies.

This change makes the return values of FrameLoaderClient::frameID()
and FrameLoaderClient::pageID() std::optional<uint64_t> so that
WebCore can call those getters and get the right return values in
WebKit and std:nullopt in WebKitLegacy.

  • dom/Document.cpp:

(WebCore::Document::requestStorageAccess):

  • loader/CookieJar.cpp:

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

  • loader/EmptyFrameLoaderClient.h:
  • loader/FrameLoaderClient.h:
  • platform/CookiesStrategy.h:
  • platform/network/CacheValidation.cpp:

(WebCore::headerValueForVary):

  • platform/network/PlatformCookieJar.h:
  • platform/network/cf/CookieJarCFNet.cpp:

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

  • platform/network/curl/CookieJarCurl.cpp:

(WebCore::CookieJarCurlFileSystem::setCookiesFromDOM):
(WebCore::CookieJarCurlFileSystem::cookiesForDOM):
(WebCore::CookieJarCurlFileSystem::cookieRequestHeaderFieldValue):
(WebCore::CookieJarCurlFileSystem::getRawCookies):
(WebCore::cookiesForDOM):
(WebCore::setCookiesFromDOM):
(WebCore::cookieRequestHeaderFieldValue):
(WebCore::getRawCookies):

  • platform/network/curl/CookieJarCurl.h:
  • platform/network/mac/CookieJarMac.mm:

(WebCore::cookiesInPartitionForURL):
(WebCore::cookiesForURL):
(WebCore::cookiesForSession):
(WebCore::cookiesForDOM):
(WebCore::cookieRequestHeaderFieldValue):
(WebCore::setCookiesFromDOM):
(WebCore::getRawCookies):

  • platform/network/soup/CookieJarSoup.cpp:

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

Source/WebKit:

CookiesStrategy::cookiesForDOM(), CookiesStrategy::setCookiesFromDOM(),
CookiesStrategy::cookieRequestHeaderFieldValue(), and
CookiesStrategy::getRawCookies() now take optional parameters for
frameID and pageID to allow frame-specific scoping of cookies.

This change makes the return values of FrameLoaderClient::frameID()
and FrameLoaderClient::pageID() std::optional<uint64_t> so that
WebCore can call those getters and get the right return values in
WebKit and std:nullopt in WebKitLegacy.

  • NetworkProcess/NetworkConnectionToWebProcess.cpp:

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

  • NetworkProcess/NetworkConnectionToWebProcess.h:
  • NetworkProcess/NetworkConnectionToWebProcess.messages.in:
  • Shared/mac/CookieStorageShim.mm:

(WebKit::webKitCookieStorageCopyRequestHeaderFieldsForURL):

  • WebProcess/Network/WebLoaderStrategy.cpp:

(WebKit::WebLoaderStrategy::scheduleLoad):

Now handles the fact that FrameLoaderClient::frameID() and
FrameLoaderClient::pageID() return an optional.

  • WebProcess/Storage/WebSWContextManagerConnection.cpp:
  • WebProcess/WebCoreSupport/WebFrameLoaderClient.cpp:

(WebKit::WebFrameLoaderClient::pageID const):
(WebKit::WebFrameLoaderClient::frameID const):

Now return an optional.

  • WebProcess/WebCoreSupport/WebFrameLoaderClient.h:
  • WebProcess/WebCoreSupport/WebPlatformStrategies.cpp:

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

  • WebProcess/WebCoreSupport/WebPlatformStrategies.h:

Source/WebKitLegacy/mac:

CookiesStrategy::cookiesForDOM(), CookiesStrategy::setCookiesFromDOM(),
CookiesStrategy::cookieRequestHeaderFieldValue(), and
CookiesStrategy::getRawCookies() now take optional parameters for
frameID and pageID to allow frame-specific scoping of cookies.

This change makes the return values of FrameLoaderClient::frameID()
and FrameLoaderClient::pageID() std::optional<uint64_t> so that
WebCore can call those getters and get the right return values in
WebKit and std:nullopt in WebKitLegacy.

  • WebCoreSupport/WebFrameLoaderClient.h:
  • WebCoreSupport/WebFrameLoaderClient.mm:

(WebFrameLoaderClient::pageID const):
(WebFrameLoaderClient::frameID const):

  • WebCoreSupport/WebPlatformStrategies.h:
  • WebCoreSupport/WebPlatformStrategies.mm:

(WebPlatformStrategies::cookiesForDOM):
(WebPlatformStrategies::setCookiesFromDOM):
(WebPlatformStrategies::cookieRequestHeaderFieldValue):
(WebPlatformStrategies::getRawCookies):

Source/WebKitLegacy/win:

CookiesStrategy::cookiesForDOM(), CookiesStrategy::setCookiesFromDOM(),
CookiesStrategy::cookieRequestHeaderFieldValue(), and
CookiesStrategy::getRawCookies() now take optional parameters for
frameID and pageID to allow frame-specific scoping of cookies.

This change makes the return values of FrameLoaderClient::frameID()
and FrameLoaderClient::pageID() std::optional<uint64_t> so that
WebCore can call those getters and get the right return values in
WebKit and std:nullopt in WebKitLegacy.

  • WebCoreSupport/WebFrameLoaderClient.cpp:

(WebFrameLoaderClient::pageID const):
(WebFrameLoaderClient::frameID const):

Now return an optional.

  • WebCoreSupport/WebFrameLoaderClient.h:
  • WebCoreSupport/WebPlatformStrategies.cpp:

(WebPlatformStrategies::cookiesForDOM):
(WebPlatformStrategies::setCookiesFromDOM):
(WebPlatformStrategies::cookieRequestHeaderFieldValue):
(WebPlatformStrategies::getRawCookies):

  • WebCoreSupport/WebPlatformStrategies.h:

LayoutTests:

CookiesStrategy::cookiesForDOM(), CookiesStrategy::setCookiesFromDOM(),
CookiesStrategy::cookieRequestHeaderFieldValue(), and
CookiesStrategy::getRawCookies() now take optional parameters for
frameID and pageID to allow frame-specific scoping of cookies.

This change makes the return values of FrameLoaderClient::frameID()
and FrameLoaderClient::pageID() std::optional<uint64_t> so that
WebCore can call those getters and get the right return values in
WebKit and std:nullopt in WebKitLegacy.

  • http/tests/storageAccess/request-and-grant-storage-access-cross-origin-sandboxed-iframe-from-prevalent-domain-with-non-recent-user-interaction-and-try-access-from-right-frame-expected.txt:

Now expects the correct behavior for document.cookie.

Location:
trunk
Files:
36 edited

Legend:

Unmodified
Added
Removed

  • trunk/LayoutTests/ChangeLog

    r225928 r225934  
     12017-12-14  John Wilander  <wilander@apple.com>
     2
     3        Storage Access API: Implement frame-specific access in the document.cookie layer
     4        https://bugs.webkit.org/show_bug.cgi?id=180682
     5        <rdar://problem/35982257>
     6
     7        Reviewed by Alex Christensen.
     8
     9        CookiesStrategy::cookiesForDOM(), CookiesStrategy::setCookiesFromDOM(),
     10        CookiesStrategy::cookieRequestHeaderFieldValue(), and
     11        CookiesStrategy::getRawCookies() now take optional parameters for
     12        frameID and pageID to allow frame-specific scoping of cookies.
     13
     14        This change makes the return values of FrameLoaderClient::frameID()
     15        and FrameLoaderClient::pageID() std::optional<uint64_t> so that
     16        WebCore can call those getters and get the right return values in
     17        WebKit and std:nullopt in WebKitLegacy.
     18
     19        * http/tests/storageAccess/request-and-grant-storage-access-cross-origin-sandboxed-iframe-from-prevalent-domain-with-non-recent-user-interaction-and-try-access-from-right-frame-expected.txt:
     20            Now expects the correct behavior for document.cookie.
     21
    1222017-12-14  Antoine Quint  <graouts@apple.com>
    223

  • trunk/LayoutTests/http/tests/storageAccess/request-and-grant-storage-access-cross-origin-sandboxed-iframe-from-prevalent-domain-with-non-recent-user-interaction-and-try-access-from-right-frame-expected.txt

    r225827 r225934  
    1717Received cookie named 'firstPartyCookie'.
    1818Did not receive cookie named 'partitionedCookie'.
    19 Client-side document.cookie: partitionedCookie=value
     19Client-side document.cookie: firstPartyCookie=value
    2020
    2121--------

  • trunk/Source/WebCore/ChangeLog

    r225931 r225934  
     12017-12-14  John Wilander  <wilander@apple.com>
     2
     3        Storage Access API: Implement frame-specific access in the document.cookie layer
     4        https://bugs.webkit.org/show_bug.cgi?id=180682
     5        <rdar://problem/35982257>
     6
     7        Reviewed by Alex Christensen.
     8
     9        No new tests. Changed expected result from existing test.
     10
     11        CookiesStrategy::cookiesForDOM(), CookiesStrategy::setCookiesFromDOM(),
     12        CookiesStrategy::cookieRequestHeaderFieldValue(), and
     13        CookiesStrategy::getRawCookies() now take optional parameters for
     14        frameID and pageID to allow frame-specific scoping of cookies.
     15
     16        This change makes the return values of FrameLoaderClient::frameID()
     17        and FrameLoaderClient::pageID() std::optional<uint64_t> so that
     18        WebCore can call those getters and get the right return values in
     19        WebKit and std:nullopt in WebKitLegacy.
     20
     21        * dom/Document.cpp:
     22        (WebCore::Document::requestStorageAccess):
     23        * loader/CookieJar.cpp:
     24        (WebCore::cookies):
     25        (WebCore::setCookies):
     26        (WebCore::cookieRequestHeaderFieldValue):
     27        (WebCore::getRawCookies):
     28        * loader/EmptyFrameLoaderClient.h:
     29        * loader/FrameLoaderClient.h:
     30        * platform/CookiesStrategy.h:
     31        * platform/network/CacheValidation.cpp:
     32        (WebCore::headerValueForVary):
     33        * platform/network/PlatformCookieJar.h:
     34        * platform/network/cf/CookieJarCFNet.cpp:
     35        (WebCore::setCookiesFromDOM):
     36        (WebCore::cookiesForDOM):
     37        (WebCore::cookieRequestHeaderFieldValue):
     38        (WebCore::getRawCookies):
     39        * platform/network/curl/CookieJarCurl.cpp:
     40        (WebCore::CookieJarCurlFileSystem::setCookiesFromDOM):
     41        (WebCore::CookieJarCurlFileSystem::cookiesForDOM):
     42        (WebCore::CookieJarCurlFileSystem::cookieRequestHeaderFieldValue):
     43        (WebCore::CookieJarCurlFileSystem::getRawCookies):
     44        (WebCore::cookiesForDOM):
     45        (WebCore::setCookiesFromDOM):
     46        (WebCore::cookieRequestHeaderFieldValue):
     47        (WebCore::getRawCookies):
     48        * platform/network/curl/CookieJarCurl.h:
     49        * platform/network/mac/CookieJarMac.mm:
     50        (WebCore::cookiesInPartitionForURL):
     51        (WebCore::cookiesForURL):
     52        (WebCore::cookiesForSession):
     53        (WebCore::cookiesForDOM):
     54        (WebCore::cookieRequestHeaderFieldValue):
     55        (WebCore::setCookiesFromDOM):
     56        (WebCore::getRawCookies):
     57        * platform/network/soup/CookieJarSoup.cpp:
     58        (WebCore::setCookiesFromDOM):
     59        (WebCore::cookiesForDOM):
     60        (WebCore::cookieRequestHeaderFieldValue):
     61        (WebCore::getRawCookies):
     62
    1632017-12-14  Alex Christensen  <achristensen@webkit.org>
    264

  • trunk/Source/WebCore/dom/Document.cpp

    r225868 r225934  
    75237523    auto frameID = m_frame->loader().client().frameID();
    75247524    auto pageID = m_frame->loader().client().pageID();
     7525    if (!frameID || !pageID) {
     7526        promise->reject();
     7527        return;
     7528    }
    75257529
    75267530    // FIXME: Don't use runJavaScriptConfirm because it responds synchronously.
    75277531    if ((page && page->chrome().runJavaScriptConfirm(*m_frame, builder.toString())) || m_grantStorageAccessOverride) {
    7528         page->chrome().client().requestStorageAccess(WTFMove(iframeHost), WTFMove(topHost), frameID, pageID, [documentReference = m_weakFactory.createWeakPtr(*this), promise] (bool wasGranted) {
     7532        page->chrome().client().requestStorageAccess(WTFMove(iframeHost), WTFMove(topHost), frameID.value(), pageID.value(), [documentReference = m_weakFactory.createWeakPtr(*this), promise] (bool wasGranted) {
    75297533            Document* document = documentReference.get();
    75307534            if (!document)

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

    r222938 r225934  
    3131#include "Frame.h"
    3232#include "FrameLoader.h"
     33#include "FrameLoaderClient.h"
    3334#include "NetworkStorageSession.h"
    3435#include "NetworkingContext.h"
    … …  
    6061
    6162    auto includeSecureCookies = (url.protocolIs("https") && !document.foundMixedContent().contains(SecurityContext::MixedContentType::Active)) ? IncludeSecureCookies::Yes : IncludeSecureCookies::No;
    62     auto result = platformStrategies()->cookiesStrategy()->cookiesForDOM(storageSession(document), document.firstPartyForCookies(), url, includeSecureCookies);
     63    std::pair<String, bool> result;
     64    auto frame = document.frame();
     65    if (frame)
     66        result = platformStrategies()->cookiesStrategy()->cookiesForDOM(storageSession(document), document.firstPartyForCookies(), url, frame->loader().client().frameID(), frame->loader().client().pageID(), includeSecureCookies);
     67    else
     68        result = platformStrategies()->cookiesStrategy()->cookiesForDOM(storageSession(document), document.firstPartyForCookies(), url, std::nullopt, std::nullopt, includeSecureCookies);
     69
    6370    if (result.second)
    6471        document.setSecureCookiesAccessed();
    … …  
    6976void setCookies(Document& document, const URL& url, const String& cookieString)
    7077{
    71     platformStrategies()->cookiesStrategy()->setCookiesFromDOM(storageSession(document), document.firstPartyForCookies(), url, cookieString);
     78    auto frame = document.frame();
     79    if (frame)
     80        platformStrategies()->cookiesStrategy()->setCookiesFromDOM(storageSession(document), document.firstPartyForCookies(), url, frame->loader().client().frameID(), frame->loader().client().pageID(), cookieString);
     81    else
     82        platformStrategies()->cookiesStrategy()->setCookiesFromDOM(storageSession(document), document.firstPartyForCookies(), url, std::nullopt, std::nullopt, cookieString);
    7283}
    7384
    … …  
    8091{
    8192    auto includeSecureCookies = (url.protocolIs("https") && !document.foundMixedContent().contains(SecurityContext::MixedContentType::Active)) ? IncludeSecureCookies::Yes : IncludeSecureCookies::No;
    82     auto result = platformStrategies()->cookiesStrategy()->cookieRequestHeaderFieldValue(storageSession(document), document.firstPartyForCookies(), url, includeSecureCookies);
     93    std::pair<String, bool> result;
     94    auto frame = document.frame();
     95    if (frame)
     96        result = platformStrategies()->cookiesStrategy()->cookieRequestHeaderFieldValue(storageSession(document), document.firstPartyForCookies(), url, frame->loader().client().frameID(), frame->loader().client().pageID(), includeSecureCookies);
     97    else
     98        result = platformStrategies()->cookiesStrategy()->cookieRequestHeaderFieldValue(storageSession(document), document.firstPartyForCookies(), url, std::nullopt, std::nullopt, includeSecureCookies);
     99
    83100    if (result.second)
    84101        document.setSecureCookiesAccessed();
    … …  
    89106bool getRawCookies(const Document& document, const URL& url, Vector<Cookie>& cookies)
    90107{
    91     return platformStrategies()->cookiesStrategy()->getRawCookies(storageSession(document), document.firstPartyForCookies(), url, cookies);
     108    auto frame = document.frame();
     109    if (frame)
     110        return platformStrategies()->cookiesStrategy()->getRawCookies(storageSession(document), document.firstPartyForCookies(), url, frame->loader().client().frameID(), frame->loader().client().pageID(), cookies);
     111
     112    return platformStrategies()->cookiesStrategy()->getRawCookies(storageSession(document), document.firstPartyForCookies(), url, std::nullopt, std::nullopt, cookies);
    92113}
    93114

  • trunk/Source/WebCore/loader/EmptyFrameLoaderClient.h

    r225716 r225934  
    3333    void frameLoaderDestroyed() override { }
    3434
    35     uint64_t frameID() const override { return 0; }
    36     uint64_t pageID() const override { return 0; }
     35    std::optional<uint64_t> frameID() const override { return std::nullopt; }
     36    std::optional<uint64_t> pageID() const override { return std::nullopt; }
    3737    PAL::SessionID sessionID() const override;
    3838

  • trunk/Source/WebCore/loader/FrameLoaderClient.h

    r225564 r225934  
    122122    virtual void makeRepresentation(DocumentLoader*) = 0;
    123123
    124     virtual uint64_t pageID() const = 0;
    125     virtual uint64_t frameID() const = 0;
     124    virtual std::optional<uint64_t> pageID() const = 0;
     125    virtual std::optional<uint64_t> frameID() const = 0;
    126126    virtual PAL::SessionID sessionID() const = 0;
    127127

  • trunk/Source/WebCore/platform/CookiesStrategy.h

    r223728 r225934  
    4242class CookiesStrategy {
    4343public:
    44     virtual std::pair<String, bool> cookiesForDOM(const NetworkStorageSession&, const URL& firstParty, const URL&, IncludeSecureCookies) = 0;
    45     virtual void setCookiesFromDOM(const NetworkStorageSession&, const URL& firstParty, const URL&, const String& cookieString) = 0;
     44    virtual std::pair<String, bool> cookiesForDOM(const NetworkStorageSession&, const URL& firstParty, const URL&, std::optional<uint64_t> frameID, std::optional<uint64_t> pageID, IncludeSecureCookies) = 0;
     45    virtual void setCookiesFromDOM(const NetworkStorageSession&, const URL& firstParty, const URL&, std::optional<uint64_t> frameID, std::optional<uint64_t> pageID, const String& cookieString) = 0;
    4646    virtual bool cookiesEnabled(const NetworkStorageSession&) = 0;
    47     virtual std::pair<String, bool> cookieRequestHeaderFieldValue(const NetworkStorageSession&, const URL& firstParty, const URL&, IncludeSecureCookies) = 0;
    48     virtual std::pair<String, bool> cookieRequestHeaderFieldValue(PAL::SessionID, const URL& firstParty, const URL&, IncludeSecureCookies) = 0;
    49     virtual bool getRawCookies(const NetworkStorageSession&, const URL& firstParty, const URL&, Vector<Cookie>&) = 0;
     47    virtual std::pair<String, bool> cookieRequestHeaderFieldValue(const NetworkStorageSession&, const URL& firstParty, const URL&, std::optional<uint64_t> frameID, std::optional<uint64_t> pageID, IncludeSecureCookies) = 0;
     48    virtual std::pair<String, bool> cookieRequestHeaderFieldValue(PAL::SessionID, const URL& firstParty, const URL&, std::optional<uint64_t> frameID, std::optional<uint64_t> pageID, IncludeSecureCookies) = 0;
     49    virtual bool getRawCookies(const NetworkStorageSession&, const URL& firstParty, const URL&, std::optional<uint64_t> frameID, std::optional<uint64_t> pageID, Vector<Cookie>&) = 0;
    5050    virtual void deleteCookie(const NetworkStorageSession&, const URL&, const String& cookieName) = 0;
    5151

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

    r225117 r225934  
    349349        if (!cookieStrategy) {
    350350            ASSERT(sessionID == PAL::SessionID::defaultSessionID());
    351             return cookieRequestHeaderFieldValue(NetworkStorageSession::defaultStorageSession(), request.firstPartyForCookies(), request.url(), includeSecureCookies).first;
    352         }
    353         return cookieStrategy->cookieRequestHeaderFieldValue(sessionID, request.firstPartyForCookies(), request.url(), includeSecureCookies).first;
     351            return cookieRequestHeaderFieldValue(NetworkStorageSession::defaultStorageSession(), request.firstPartyForCookies(), request.url(), std::nullopt, std::nullopt, includeSecureCookies).first;
     352        }
     353        return cookieStrategy->cookieRequestHeaderFieldValue(sessionID, request.firstPartyForCookies(), request.url(), std::nullopt, std::nullopt, includeSecureCookies).first;
    354354    }
    355355    return request.httpHeaderField(headerName);

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

    r222938 r225934  
    4242// FIXME: These should probably be NetworkStorageSession member functions.
    4343
    44 WEBCORE_EXPORT std::pair<String, bool> cookiesForDOM(const NetworkStorageSession&, const URL& firstParty, const URL&, IncludeSecureCookies);
    45 WEBCORE_EXPORT void setCookiesFromDOM(const NetworkStorageSession&, const URL& firstParty, const URL&, const String&);
     44WEBCORE_EXPORT std::pair<String, bool> cookiesForDOM(const NetworkStorageSession&, const URL& firstParty, const URL&, std::optional<uint64_t> frameID, std::optional<uint64_t> pageID, IncludeSecureCookies);
     45WEBCORE_EXPORT void setCookiesFromDOM(const NetworkStorageSession&, const URL& firstParty, const URL&, std::optional<uint64_t> frameID, std::optional<uint64_t> pageID, const String&);
    4646WEBCORE_EXPORT bool cookiesEnabled(const NetworkStorageSession&);
    47 WEBCORE_EXPORT std::pair<String, bool> cookieRequestHeaderFieldValue(const NetworkStorageSession&, const URL& firstParty, const URL&, IncludeSecureCookies);
    48 WEBCORE_EXPORT bool getRawCookies(const NetworkStorageSession&, const URL& firstParty, const URL&, Vector<Cookie>&);
     47WEBCORE_EXPORT std::pair<String, bool> cookieRequestHeaderFieldValue(const NetworkStorageSession&, const URL& firstParty, const URL&, std::optional<uint64_t> frameID, std::optional<uint64_t> pageID, IncludeSecureCookies);
     48WEBCORE_EXPORT bool getRawCookies(const NetworkStorageSession&, const URL& firstParty, const URL&, std::optional<uint64_t> frameID, std::optional<uint64_t> pageID, Vector<Cookie>&);
    4949WEBCORE_EXPORT void deleteCookie(const NetworkStorageSession&, const URL&, const String&);
    5050WEBCORE_EXPORT void getHostnamesWithCookies(const NetworkStorageSession&, HashSet<String>& hostnames);

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

    r224846 r225934  
    139139}
    140140
    141 void setCookiesFromDOM(const NetworkStorageSession& session, const URL& firstParty, const URL& url, const String& value)
    142 {
     141void setCookiesFromDOM(const NetworkStorageSession& session, const URL& firstParty, const URL& url, std::optional<uint64_t> frameID, std::optional<uint64_t> pageID, const String& value)
     142{
     143    UNUSED_PARAM(frameID);
     144    UNUSED_PARAM(pageID);
    143145    // <rdar://problem/5632883> CFHTTPCookieStorage stores an empty cookie, which would be sent as "Cookie: =".
    144146    if (value.isEmpty())
    … …  
    173175}
    174176
    175 std::pair<String, bool> cookiesForDOM(const NetworkStorageSession& session, const URL& firstParty, const URL& url, IncludeSecureCookies includeSecureCookies)
    176 {
     177std::pair<String, bool> cookiesForDOM(const NetworkStorageSession& session, const URL& firstParty, const URL& url, std::optional<uint64_t> frameID, std::optional<uint64_t> pageID, IncludeSecureCookies includeSecureCookies)
     178{
     179    UNUSED_PARAM(frameID);
     180    UNUSED_PARAM(pageID);
    177181    RetainPtr<CFArrayRef> cookiesCF = copyCookiesForURLWithFirstPartyURL(session, firstParty, url, includeSecureCookies);
    178182
    … …  
    186190}
    187191
    188 std::pair<String, bool> cookieRequestHeaderFieldValue(const NetworkStorageSession& session, const URL& firstParty, const URL& url, IncludeSecureCookies includeSecureCookies)
    189 {
     192std::pair<String, bool> cookieRequestHeaderFieldValue(const NetworkStorageSession& session, const URL& firstParty, const URL& url, std::optional<uint64_t> frameID, std::optional<uint64_t> pageID, IncludeSecureCookies includeSecureCookies)
     193{
     194    UNUSED_PARAM(frameID);
     195    UNUSED_PARAM(pageID);
    190196    RetainPtr<CFArrayRef> cookiesCF = copyCookiesForURLWithFirstPartyURL(session, firstParty, url, includeSecureCookies);
    191197
    … …  
    203209}
    204210
    205 bool getRawCookies(const NetworkStorageSession& session, const URL& firstParty, const URL& url, Vector<Cookie>& rawCookies)
    206 {
     211bool getRawCookies(const NetworkStorageSession& session, const URL& firstParty, const URL& url, std::optional<uint64_t> frameID, std::optional<uint64_t> pageID, Vector<Cookie>& rawCookies)
     212{
     213    UNUSED_PARAM(frameID);
     214    UNUSED_PARAM(pageID);
    207215    rawCookies.clear();
    208216

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

    r222938 r225934  
    240240}
    241241
    242 void CookieJarCurlFileSystem::setCookiesFromDOM(const NetworkStorageSession&, const URL& firstParty, const URL& url, const String& value)
    243 {
     242void CookieJarCurlFileSystem::setCookiesFromDOM(const NetworkStorageSession&, const URL& firstParty, const URL& url, std::optional<uint64_t> frameID, std::optional<uint64_t> pageID, const String& value)
     243{
     244    UNUSED_PARAM(frameID);
     245    UNUSED_PARAM(pageID);
    244246    CurlHandle curlHandle;
    245247
    … …  
    288290}
    289291
    290 std::pair<String, bool> CookieJarCurlFileSystem::cookiesForDOM(const NetworkStorageSession& session, const URL& firstParty, const URL& url, IncludeSecureCookies)
    291 {
     292std::pair<String, bool> CookieJarCurlFileSystem::cookiesForDOM(const NetworkStorageSession& session, const URL& firstParty, const URL& url, std::optional<uint64_t> frameID, std::optional<uint64_t> pageID, IncludeSecureCookies)
     293{
     294    UNUSED_PARAM(frameID);
     295    UNUSED_PARAM(pageID);
    292296    // FIXME: This should filter secure cookies out if the caller requests it.
    293297    return { cookiesForSession(session, firstParty, url, false), false };
    294298}
    295299
    296 std::pair<String, bool> CookieJarCurlFileSystem::cookieRequestHeaderFieldValue(const NetworkStorageSession& session, const URL& firstParty, const URL& url, IncludeSecureCookies)
    297 {
     300std::pair<String, bool> CookieJarCurlFileSystem::cookieRequestHeaderFieldValue(const NetworkStorageSession& session, const URL& firstParty, const URL& url, std::optional<uint64_t> frameID, std::optional<uint64_t> pageID, IncludeSecureCookies)
     301{
     302    UNUSED_PARAM(frameID);
     303    UNUSED_PARAM(pageID);
    298304    // FIXME: This should filter secure cookies out if the caller requests it.
    299305    return { cookiesForSession(session, firstParty, url, true), false };
    … …  
    305311}
    306312
    307 bool CookieJarCurlFileSystem::getRawCookies(const NetworkStorageSession&, const URL& firstParty, const URL&, Vector<Cookie>& rawCookies)
    308 {
     313bool CookieJarCurlFileSystem::getRawCookies(const NetworkStorageSession&, const URL& firstParty, const URL&, std::optional<uint64_t> frameID, std::optional<uint64_t> pageID, Vector<Cookie>& rawCookies)
     314{
     315    UNUSED_PARAM(frameID);
     316    UNUSED_PARAM(pageID);
    309317    // FIXME: Not yet implemented
    310318    rawCookies.clear();
    … …  
    339347// dispatcher functions
    340348
    341 std::pair<String, bool> cookiesForDOM(const NetworkStorageSession& session, const URL& firstParty, const URL& url, IncludeSecureCookies includeSecureCookies)
    342 {
    343     return CurlContext::singleton().cookieJar().cookiesForDOM(session, firstParty, url, includeSecureCookies);
    344 }
    345 
    346 void setCookiesFromDOM(const NetworkStorageSession& session, const URL& firstParty, const URL& url, const String& value)
    347 {
    348     CurlContext::singleton().cookieJar().setCookiesFromDOM(session, firstParty, url, value);
    349 }
    350 
    351 std::pair<String, bool> cookieRequestHeaderFieldValue(const NetworkStorageSession& session, const URL& firstParty, const URL& url, IncludeSecureCookies includeSecureCookies)
    352 {
    353     return CurlContext::singleton().cookieJar().cookieRequestHeaderFieldValue(session, firstParty, url, includeSecureCookies);
     349std::pair<String, bool> cookiesForDOM(const NetworkStorageSession& session, const URL& firstParty, const URL& url, std::optional<uint64_t> frameID, std::optional<uint64_t> pageID, IncludeSecureCookies includeSecureCookies)
     350{
     351    return CurlContext::singleton().cookieJar().cookiesForDOM(session, firstParty, url, frameID, pageID, includeSecureCookies);
     352}
     353
     354void setCookiesFromDOM(const NetworkStorageSession& session, const URL& firstParty, const URL& url, std::optional<uint64_t> frameID, std::optional<uint64_t> pageID, const String& value)
     355{
     356    CurlContext::singleton().cookieJar().setCookiesFromDOM(session, firstParty, url, frameID, pageID, value);
     357}
     358
     359std::pair<String, bool> cookieRequestHeaderFieldValue(const NetworkStorageSession& session, const URL& firstParty, const URL& url, std::optional<uint64_t> frameID, std::optional<uint64_t> pageID, IncludeSecureCookies includeSecureCookies)
     360{
     361    return CurlContext::singleton().cookieJar().cookieRequestHeaderFieldValue(session, firstParty, url, frameID, pageID, includeSecureCookies);
    354362}
    355363
    … …  
    359367}
    360368
    361 bool getRawCookies(const NetworkStorageSession& session, const URL& firstParty, const URL& url, Vector<Cookie>& rawCookies)
    362 {
    363     return CurlContext::singleton().cookieJar().getRawCookies(session, firstParty, url, rawCookies);
     369bool getRawCookies(const NetworkStorageSession& session, const URL& firstParty, const URL& url, std::optional<uint64_t> frameID, std::optional<uint64_t> pageID, Vector<Cookie>& rawCookies)
     370{
     371    return CurlContext::singleton().cookieJar().getRawCookies(session, firstParty, url, frameID, pageID, rawCookies);
    364372}
    365373

  • trunk/Source/WebCore/platform/network/curl/CookieJarCurl.h

    r223752 r225934  
    2929class CookieJarCurl {
    3030public:
    31     virtual std::pair<String, bool> cookiesForDOM(const NetworkStorageSession&, const URL& firstParty, const URL&, IncludeSecureCookies) = 0;
    32     virtual void setCookiesFromDOM(const NetworkStorageSession&, const URL& firstParty, const URL&, const String&) = 0;
     31    virtual std::pair<String, bool> cookiesForDOM(const NetworkStorageSession&, const URL& firstParty, const URL&, std::optional<uint64_t> frameID, std::optional<uint64_t> pageID, IncludeSecureCookies) = 0;
     32    virtual void setCookiesFromDOM(const NetworkStorageSession&, const URL& firstParty, const URL&, std::optional<uint64_t> frameID, std::optional<uint64_t> pageID, const String&) = 0;
    3333    virtual bool cookiesEnabled(const NetworkStorageSession&) = 0;
    34     virtual std::pair<String, bool> cookieRequestHeaderFieldValue(const NetworkStorageSession&, const URL& firstParty, const URL&, IncludeSecureCookies) = 0;
    35     virtual bool getRawCookies(const NetworkStorageSession&, const URL& firstParty, const URL&, Vector<Cookie>&) = 0;
     34    virtual std::pair<String, bool> cookieRequestHeaderFieldValue(const NetworkStorageSession&, const URL& firstParty, const URL&, std::optional<uint64_t> frameID, std::optional<uint64_t> pageID, IncludeSecureCookies) = 0;
     35    virtual bool getRawCookies(const NetworkStorageSession&, const URL& firstParty, const URL&, std::optional<uint64_t> frameID, std::optional<uint64_t> pageID, Vector<Cookie>&) = 0;
    3636    virtual void deleteCookie(const NetworkStorageSession&, const URL&, const String&) = 0;
    3737    virtual void getHostnamesWithCookies(const NetworkStorageSession&, HashSet<String>& hostnames) = 0;
    … …  
    4242
    4343class CookieJarCurlFileSystem : public CookieJarCurl {
    44     std::pair<String, bool> cookiesForDOM(const NetworkStorageSession&, const URL& firstParty, const URL&, IncludeSecureCookies) override;
    45     void setCookiesFromDOM(const NetworkStorageSession&, const URL& firstParty, const URL&, const String&) override;
     44    std::pair<String, bool> cookiesForDOM(const NetworkStorageSession&, const URL& firstParty, const URL&, std::optional<uint64_t> frameID, std::optional<uint64_t> pageID, IncludeSecureCookies) override;
     45    void setCookiesFromDOM(const NetworkStorageSession&, const URL& firstParty, const URL&, std::optional<uint64_t> frameID, std::optional<uint64_t> pageID, const String&) override;
    4646    bool cookiesEnabled(const NetworkStorageSession&) override;
    47     std::pair<String, bool> cookieRequestHeaderFieldValue(const NetworkStorageSession&, const URL& firstParty, const URL&, IncludeSecureCookies) override;
    48     bool getRawCookies(const NetworkStorageSession&, const URL& firstParty, const URL&, Vector<Cookie>&) override;
     47    std::pair<String, bool> cookieRequestHeaderFieldValue(const NetworkStorageSession&, const URL& firstParty, const URL&, std::optional<uint64_t> frameID, std::optional<uint64_t> pageID, IncludeSecureCookies) override;
     48    bool getRawCookies(const NetworkStorageSession&, const URL& firstParty, const URL&, std::optional<uint64_t> frameID, std::optional<uint64_t> pageID, Vector<Cookie>&) override;
    4949    void deleteCookie(const NetworkStorageSession&, const URL&, const String&) override;
    5050    void getHostnamesWithCookies(const NetworkStorageSession&, HashSet<String>& hostnames) override;

  • trunk/Source/WebCore/platform/network/mac/CookieJarMac.mm

    r225827 r225934  
    123123}
    124124
    125 static NSArray *cookiesInPartitionForURL(const NetworkStorageSession& session, const URL& firstParty, const URL& url)
    126 {
    127     String partition = session.cookieStoragePartition(firstParty, url, std::nullopt, std::nullopt);
     125static NSArray *cookiesInPartitionForURL(const NetworkStorageSession& session, const URL& firstParty, const URL& url, std::optional<uint64_t> frameID, std::optional<uint64_t> pageID)
     126{
     127    String partition = session.cookieStoragePartition(firstParty, url, frameID, pageID);
    128128    if (partition.isEmpty())
    129129        return nil;
    … …  
    149149#endif // HAVE(CFNETWORK_STORAGE_PARTITIONING)
    150150   
    151 static NSArray *cookiesForURL(const NetworkStorageSession& session, const URL& firstParty, const URL& url)
     151static NSArray *cookiesForURL(const NetworkStorageSession& session, const URL& firstParty, const URL& url, std::optional<uint64_t> frameID, std::optional<uint64_t> pageID)
    152152{
    153153#if HAVE(CFNETWORK_STORAGE_PARTITIONING)
    … …  
    155155        return nil;
    156156   
    157     if (NSArray *cookies = cookiesInPartitionForURL(session, firstParty, url))
     157    if (NSArray *cookies = cookiesInPartitionForURL(session, firstParty, url, frameID, pageID))
    158158        return cookies;
     159#else
     160    UNUSED_PARAM(frameID);
     161    UNUSED_PARAM(pageID);
    159162#endif
    160163    return httpCookiesForURL(session.cookieStorage().get(), firstParty, url);
    … …  
    162165
    163166enum IncludeHTTPOnlyOrNot { DoNotIncludeHTTPOnly, IncludeHTTPOnly };
    164 static std::pair<String, bool> cookiesForSession(const NetworkStorageSession& session, const URL& firstParty, const URL& url, IncludeHTTPOnlyOrNot includeHTTPOnly, IncludeSecureCookies includeSecureCookies)
    165 {
    166     BEGIN_BLOCK_OBJC_EXCEPTIONS;
    167 
    168     NSArray *cookies = cookiesForURL(session, firstParty, url);
     167static std::pair<String, bool> cookiesForSession(const NetworkStorageSession& session, const URL& firstParty, const URL& url, std::optional<uint64_t> frameID, std::optional<uint64_t> pageID, IncludeHTTPOnlyOrNot includeHTTPOnly, IncludeSecureCookies includeSecureCookies)
     168{
     169    BEGIN_BLOCK_OBJC_EXCEPTIONS;
     170
     171    NSArray *cookies = cookiesForURL(session, firstParty, url, frameID, pageID);
    169172    if (![cookies count])
    170173        return { String(), false }; // Return a null string, not an empty one that StringBuilder would create below.
    … …  
    225228}
    226229
    227 std::pair<String, bool> cookiesForDOM(const NetworkStorageSession& session, const URL& firstParty, const URL& url, IncludeSecureCookies includeSecureCookies)
    228 {
    229     return cookiesForSession(session, firstParty, url, DoNotIncludeHTTPOnly, includeSecureCookies);
    230 }
    231 
    232 std::pair<String, bool> cookieRequestHeaderFieldValue(const NetworkStorageSession& session, const URL& firstParty, const URL& url, IncludeSecureCookies includeSecureCookies)
    233 {
    234     return cookiesForSession(session, firstParty, url, IncludeHTTPOnly, includeSecureCookies);
    235 }
    236 
    237 void setCookiesFromDOM(const NetworkStorageSession& session, const URL& firstParty, const URL& url, const String& cookieStr)
     230std::pair<String, bool> cookiesForDOM(const NetworkStorageSession& session, const URL& firstParty, const URL& url, std::optional<uint64_t> frameID, std::optional<uint64_t> pageID, IncludeSecureCookies includeSecureCookies)
     231{
     232    return cookiesForSession(session, firstParty, url, frameID, pageID, DoNotIncludeHTTPOnly, includeSecureCookies);
     233}
     234
     235std::pair<String, bool> cookieRequestHeaderFieldValue(const NetworkStorageSession& session, const URL& firstParty, const URL& url, std::optional<uint64_t> frameID, std::optional<uint64_t> pageID, IncludeSecureCookies includeSecureCookies)
     236{
     237    return cookiesForSession(session, firstParty, url, frameID, pageID, IncludeHTTPOnly, includeSecureCookies);
     238}
     239
     240void setCookiesFromDOM(const NetworkStorageSession& session, const URL& firstParty, const URL& url, std::optional<uint64_t> frameID, std::optional<uint64_t> pageID, const String& cookieStr)
    238241{
    239242    BEGIN_BLOCK_OBJC_EXCEPTIONS;
    … …  
    261264
    262265#if HAVE(CFNETWORK_STORAGE_PARTITIONING)
    263     String partition = session.cookieStoragePartition(firstParty, url, std::nullopt, std::nullopt);
     266    String partition = session.cookieStoragePartition(firstParty, url, frameID, pageID);
    264267    if (!partition.isEmpty())
    265268        filteredCookies = applyPartitionToCookies(partition, filteredCookies.get());
     269#else
     270    UNUSED_PARAM(frameID);
     271    UNUSED_PARAM(pageID);
    266272#endif
    267273
    … …  
    290296}
    291297
    292 bool getRawCookies(const NetworkStorageSession& session, const URL& firstParty, const URL& url, Vector<Cookie>& rawCookies)
     298bool getRawCookies(const NetworkStorageSession& session, const URL& firstParty, const URL& url, std::optional<uint64_t> frameID, std::optional<uint64_t> pageID, Vector<Cookie>& rawCookies)
    293299{
    294300    rawCookies.clear();
    295301    BEGIN_BLOCK_OBJC_EXCEPTIONS;
    296302
    297     NSArray *cookies = cookiesForURL(session, firstParty, url);
     303    NSArray *cookies = cookiesForURL(session, firstParty, url, frameID, pageID);
    298304    NSUInteger count = [cookies count];
    299305    rawCookies.reserveCapacity(count);

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

    r222938 r225934  
    5151}
    5252
    53 void setCookiesFromDOM(const NetworkStorageSession& session, const URL& firstParty, const URL& url, const String& value)
    54 {
     53void setCookiesFromDOM(const NetworkStorageSession& session, const URL& firstParty, const URL& url, std::optional<uint64_t> frameID, std::optional<uint64_t> pageID, const String& value)
     54{
     55    UNUSED_PARAM(frameID);
     56    UNUSED_PARAM(pageID);
    5557    SoupCookieJar* jar = session.cookieStorage();
    5658
    … …  
    117119}
    118120
    119 std::pair<String, bool> cookiesForDOM(const NetworkStorageSession& session, const URL&, const URL& url, IncludeSecureCookies includeSecureCookies)
    120 {
     121std::pair<String, bool> cookiesForDOM(const NetworkStorageSession& session, const URL&, const URL& url, std::optional<uint64_t> frameID, std::optional<uint64_t> pageID, IncludeSecureCookies includeSecureCookies)
     122{
     123    UNUSED_PARAM(frameID);
     124    UNUSED_PARAM(pageID);
    121125    return cookiesForSession(session, url, false, includeSecureCookies);
    122126}
    123127
    124 std::pair<String, bool> cookieRequestHeaderFieldValue(const NetworkStorageSession& session, const URL& /*firstParty*/, const URL& url, IncludeSecureCookies includeSecureCookies)
    125 {
     128std::pair<String, bool> cookieRequestHeaderFieldValue(const NetworkStorageSession& session, const URL& /*firstParty*/, const URL& url, std::optional<uint64_t> frameID, std::optional<uint64_t> pageID, IncludeSecureCookies includeSecureCookies)
     129{
     130    UNUSED_PARAM(frameID);
     131    UNUSED_PARAM(pageID);
    126132    // Secure cookies will still only be included if url's protocol is https.
    127133    return cookiesForSession(session, url, true, includeSecureCookies);
    … …  
    134140}
    135141
    136 bool getRawCookies(const NetworkStorageSession& session, const URL& /*firstParty*/, const URL& url, Vector<Cookie>& rawCookies)
    137 {
     142bool getRawCookies(const NetworkStorageSession& session, const URL& /*firstParty*/, const URL& url, std::optional<uint64_t> frameID, std::optional<uint64_t> pageID, Vector<Cookie>& rawCookies)
     143{
     144    UNUSED_PARAM(frameID);
     145    UNUSED_PARAM(pageID);
    138146    rawCookies.clear();
    139147    GUniquePtr<SoupURI> uri = url.createSoupURI();

  • trunk/Source/WebKit/ChangeLog

    r225931 r225934  
     12017-12-14  John Wilander  <wilander@apple.com>
     2
     3        Storage Access API: Implement frame-specific access in the document.cookie layer
     4        https://bugs.webkit.org/show_bug.cgi?id=180682
     5        <rdar://problem/35982257>
     6
     7        Reviewed by Alex Christensen.
     8
     9        CookiesStrategy::cookiesForDOM(), CookiesStrategy::setCookiesFromDOM(),
     10        CookiesStrategy::cookieRequestHeaderFieldValue(), and
     11        CookiesStrategy::getRawCookies() now take optional parameters for
     12        frameID and pageID to allow frame-specific scoping of cookies.
     13
     14        This change makes the return values of FrameLoaderClient::frameID()
     15        and FrameLoaderClient::pageID() std::optional<uint64_t> so that
     16        WebCore can call those getters and get the right return values in
     17        WebKit and std:nullopt in WebKitLegacy.
     18
     19        * NetworkProcess/NetworkConnectionToWebProcess.cpp:
     20        (WebKit::NetworkConnectionToWebProcess::cookiesForDOM):
     21        (WebKit::NetworkConnectionToWebProcess::setCookiesFromDOM):
     22        (WebKit::NetworkConnectionToWebProcess::cookieRequestHeaderFieldValue):
     23        (WebKit::NetworkConnectionToWebProcess::getRawCookies):
     24        * NetworkProcess/NetworkConnectionToWebProcess.h:
     25        * NetworkProcess/NetworkConnectionToWebProcess.messages.in:
     26        * Shared/mac/CookieStorageShim.mm:
     27        (WebKit::webKitCookieStorageCopyRequestHeaderFieldsForURL):
     28        * WebProcess/Network/WebLoaderStrategy.cpp:
     29        (WebKit::WebLoaderStrategy::scheduleLoad):
     30            Now handles the fact that FrameLoaderClient::frameID() and
     31            FrameLoaderClient::pageID() return an optional.
     32        * WebProcess/Storage/WebSWContextManagerConnection.cpp:
     33        * WebProcess/WebCoreSupport/WebFrameLoaderClient.cpp:
     34        (WebKit::WebFrameLoaderClient::pageID const):
     35        (WebKit::WebFrameLoaderClient::frameID const):
     36            Now return an optional.
     37        * WebProcess/WebCoreSupport/WebFrameLoaderClient.h:
     38        * WebProcess/WebCoreSupport/WebPlatformStrategies.cpp:
     39        (WebKit::WebPlatformStrategies::cookiesForDOM):
     40        (WebKit::WebPlatformStrategies::setCookiesFromDOM):
     41        (WebKit::WebPlatformStrategies::cookieRequestHeaderFieldValue):
     42        (WebKit::WebPlatformStrategies::getRawCookies):
     43        * WebProcess/WebCoreSupport/WebPlatformStrategies.h:
     44
    1452017-12-14  Alex Christensen  <achristensen@webkit.org>
    246

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

    r225926 r225934  
    348348}
    349349
    350 void NetworkConnectionToWebProcess::cookiesForDOM(PAL::SessionID sessionID, const URL& firstParty, const URL& url, IncludeSecureCookies includeSecureCookies, String& cookieString, bool& secureCookiesAccessed)
    351 {
    352     std::tie(cookieString, secureCookiesAccessed) = WebCore::cookiesForDOM(storageSession(sessionID), firstParty, url, includeSecureCookies);
    353 }
    354 
    355 void NetworkConnectionToWebProcess::setCookiesFromDOM(PAL::SessionID sessionID, const URL& firstParty, const URL& url, const String& cookieString)
    356 {
    357     WebCore::setCookiesFromDOM(storageSession(sessionID), firstParty, url, cookieString);
     350void NetworkConnectionToWebProcess::cookiesForDOM(PAL::SessionID sessionID, const URL& firstParty, const URL& url, std::optional<uint64_t> frameID, std::optional<uint64_t> pageID, IncludeSecureCookies includeSecureCookies, String& cookieString, bool& secureCookiesAccessed)
     351{
     352    std::tie(cookieString, secureCookiesAccessed) = WebCore::cookiesForDOM(storageSession(sessionID), firstParty, url, frameID, pageID, includeSecureCookies);
     353}
     354
     355void NetworkConnectionToWebProcess::setCookiesFromDOM(PAL::SessionID sessionID, const URL& firstParty, const URL& url, std::optional<uint64_t> frameID, std::optional<uint64_t> pageID, const String& cookieString)
     356{
     357    WebCore::setCookiesFromDOM(storageSession(sessionID), firstParty, url, frameID, pageID, cookieString);
    358358}
    359359
    … …  
    363363}
    364364
    365 void NetworkConnectionToWebProcess::cookieRequestHeaderFieldValue(PAL::SessionID sessionID, const URL& firstParty, const URL& url, IncludeSecureCookies includeSecureCookies, String& cookieString, bool& secureCookiesAccessed)
    366 {
    367     std::tie(cookieString, secureCookiesAccessed) = WebCore::cookieRequestHeaderFieldValue(storageSession(sessionID), firstParty, url, includeSecureCookies);
    368 }
    369 
    370 void NetworkConnectionToWebProcess::getRawCookies(PAL::SessionID sessionID, const URL& firstParty, const URL& url, Vector<Cookie>& result)
    371 {
    372     WebCore::getRawCookies(storageSession(sessionID), firstParty, url, result);
     365void NetworkConnectionToWebProcess::cookieRequestHeaderFieldValue(PAL::SessionID sessionID, const URL& firstParty, const URL& url, std::optional<uint64_t> frameID, std::optional<uint64_t> pageID, IncludeSecureCookies includeSecureCookies, String& cookieString, bool& secureCookiesAccessed)
     366{
     367    std::tie(cookieString, secureCookiesAccessed) = WebCore::cookieRequestHeaderFieldValue(storageSession(sessionID), firstParty, url, frameID, pageID, includeSecureCookies);
     368}
     369
     370void NetworkConnectionToWebProcess::getRawCookies(PAL::SessionID sessionID, const URL& firstParty, const URL& url, std::optional<uint64_t> frameID, std::optional<uint64_t> pageID, Vector<Cookie>& result)
     371{
     372    WebCore::getRawCookies(storageSession(sessionID), firstParty, url, frameID, pageID, result);
    373373}
    374374

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

    r225926 r225934  
    102102    void convertMainResourceLoadToDownload(PAL::SessionID, uint64_t mainResourceLoadIdentifier, DownloadID, const WebCore::ResourceRequest&, const WebCore::ResourceResponse&);
    103103
    104     void cookiesForDOM(PAL::SessionID, const WebCore::URL& firstParty, const WebCore::URL&, WebCore::IncludeSecureCookies, String& cookieString, bool& secureCookiesAccessed);
    105     void setCookiesFromDOM(PAL::SessionID, const WebCore::URL& firstParty, const WebCore::URL&, const String&);
     104    void cookiesForDOM(PAL::SessionID, const WebCore::URL& firstParty, const WebCore::URL&, std::optional<uint64_t> frameID, std::optional<uint64_t> pageID, WebCore::IncludeSecureCookies, String& cookieString, bool& secureCookiesAccessed);
     105    void setCookiesFromDOM(PAL::SessionID, const WebCore::URL& firstParty, const WebCore::URL&, std::optional<uint64_t> frameID, std::optional<uint64_t> pageID, const String&);
    106106    void cookiesEnabled(PAL::SessionID, bool& result);
    107     void cookieRequestHeaderFieldValue(PAL::SessionID, const WebCore::URL& firstParty, const WebCore::URL&, WebCore::IncludeSecureCookies, String& cookieString, bool& secureCookiesAccessed);
    108     void getRawCookies(PAL::SessionID, const WebCore::URL& firstParty, const WebCore::URL&, Vector<WebCore::Cookie>&);
     107    void cookieRequestHeaderFieldValue(PAL::SessionID, const WebCore::URL& firstParty, const WebCore::URL&, std::optional<uint64_t> frameID, std::optional<uint64_t> pageID, WebCore::IncludeSecureCookies, String& cookieString, bool& secureCookiesAccessed);
     108    void getRawCookies(PAL::SessionID, const WebCore::URL& firstParty, const WebCore::URL&, std::optional<uint64_t> frameID, std::optional<uint64_t> pageID, Vector<WebCore::Cookie>&);
    109109    void deleteCookie(PAL::SessionID, const WebCore::URL&, const String& cookieName);
    110110

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

    r223179 r225934  
    3434    ConvertMainResourceLoadToDownload(PAL::SessionID sessionID, uint64_t mainResourceLoadIdentifier, WebKit::DownloadID downloadID, WebCore::ResourceRequest request, WebCore::ResourceResponse response)
    3535
    36     CookiesForDOM(PAL::SessionID sessionID, WebCore::URL firstParty, WebCore::URL url, enum WebCore::IncludeSecureCookies includeSecureCookies) -> (String cookieString, bool didAccessSecureCookies)
    37     SetCookiesFromDOM(PAL::SessionID sessionID, WebCore::URL firstParty, WebCore::URL url, String cookieString)
     36    CookiesForDOM(PAL::SessionID sessionID, WebCore::URL firstParty, WebCore::URL url, std::optional<uint64_t> frameID, std::optional<uint64_t> pageID, enum WebCore::IncludeSecureCookies includeSecureCookies) -> (String cookieString, bool didAccessSecureCookies)
     37    SetCookiesFromDOM(PAL::SessionID sessionID, WebCore::URL firstParty, WebCore::URL url, std::optional<uint64_t> frameID, std::optional<uint64_t> pageID, String cookieString)
    3838    CookiesEnabled(PAL::SessionID sessionID) -> (bool enabled)
    39     CookieRequestHeaderFieldValue(PAL::SessionID sessionID, WebCore::URL firstParty, WebCore::URL url, enum WebCore::IncludeSecureCookies includeSecureCookies) -> (String cookieString, bool didAccessSecureCookies)
    40     GetRawCookies(PAL::SessionID sessionID, WebCore::URL firstParty, WebCore::URL url) -> (Vector<WebCore::Cookie> cookies)
     39    CookieRequestHeaderFieldValue(PAL::SessionID sessionID, WebCore::URL firstParty, WebCore::URL url, std::optional<uint64_t> frameID, std::optional<uint64_t> pageID, enum WebCore::IncludeSecureCookies includeSecureCookies) -> (String cookieString, bool didAccessSecureCookies)
     40    GetRawCookies(PAL::SessionID sessionID, WebCore::URL firstParty, WebCore::URL url, std::optional<uint64_t> frameID, std::optional<uint64_t> pageID) -> (Vector<WebCore::Cookie> cookies)
    4141    DeleteCookie(PAL::SessionID sessionID, WebCore::URL url, String cookieName)
    4242

  • trunk/Source/WebKit/Shared/mac/CookieStorageShim.mm

    r225282 r225934  
    6262    bool secureCookiesAccessed = false;
    6363    URL firstPartyForCookiesURL;
    64     if (!WebProcess::singleton().ensureNetworkProcessConnection().connection().sendSync(Messages::NetworkConnectionToWebProcess::CookieRequestHeaderFieldValue(PAL::SessionID::defaultSessionID(), firstPartyForCookiesURL, inRequestURL, includeSecureCookies), Messages::NetworkConnectionToWebProcess::CookieRequestHeaderFieldValue::Reply(cookies, secureCookiesAccessed), 0))
     64    if (!WebProcess::singleton().ensureNetworkProcessConnection().connection().sendSync(Messages::NetworkConnectionToWebProcess::CookieRequestHeaderFieldValue(PAL::SessionID::defaultSessionID(), firstPartyForCookiesURL, inRequestURL, std::nullopt, std::nullopt, includeSecureCookies), Messages::NetworkConnectionToWebProcess::CookieRequestHeaderFieldValue::Reply(cookies, secureCookiesAccessed), 0))
    6565        return 0;
    6666

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

    r225705 r225934  
    159159
    160160    WebResourceLoader::TrackingParameters trackingParameters;
    161     trackingParameters.pageID = frameLoaderClient.pageID();
    162     trackingParameters.frameID = frameLoaderClient.frameID();
     161    trackingParameters.pageID = frameLoaderClient.pageID().value();
     162    trackingParameters.frameID = frameLoaderClient.frameID().value();
    163163    trackingParameters.resourceID = identifier;
    164164    auto sessionID = frameLoaderClient.sessionID();

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

    r225760 r225934  
    8585
    8686    PAL::SessionID sessionID() const final { return m_sessionID; }
    87     uint64_t pageID() const final { return m_pageID; }
    88     uint64_t frameID() const final { return m_frameID; }
     87    std::optional<uint64_t> pageID() const final { return m_pageID; }
     88    std::optional<uint64_t> frameID() const final { return m_frameID; }
    8989    String userAgent(const URL&) final { return m_userAgent; }
    9090

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

    r225925 r225934  
    107107}
    108108
    109 uint64_t WebFrameLoaderClient::pageID() const
    110 {
    111     return m_frame && m_frame->page() ? m_frame->page()->pageID() : 0;
    112 }
    113 
    114 uint64_t WebFrameLoaderClient::frameID() const
    115 {
    116     return m_frame ? m_frame->frameID() : 0;
     109std::optional<uint64_t> WebFrameLoaderClient::pageID() const
     110{
     111    if (m_frame && m_frame->page())
     112        return m_frame->page()->pageID();
     113
     114    return std::nullopt;
     115}
     116
     117std::optional<uint64_t> WebFrameLoaderClient::frameID() const
     118{
     119    if (m_frame)
     120        return m_frame->frameID();
     121
     122    return std::nullopt;
    117123}
    118124

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

    r225682 r225934  
    5252    void applyToDocumentLoader(WebsitePolicies&&);
    5353
    54     uint64_t pageID() const final;
    55     uint64_t frameID() const final;
     54    std::optional<uint64_t> pageID() const final;
     55    std::optional<uint64_t> frameID() const final;
    5656    PAL::SessionID sessionID() const final;
    5757

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

    r225926 r225934  
    110110// CookiesStrategy
    111111
    112 std::pair<String, bool> WebPlatformStrategies::cookiesForDOM(const NetworkStorageSession& session, const URL& firstParty, const URL& url, IncludeSecureCookies includeSecureCookies)
     112std::pair<String, bool> WebPlatformStrategies::cookiesForDOM(const NetworkStorageSession& session, const URL& firstParty, const URL& url, std::optional<uint64_t> frameID, std::optional<uint64_t> pageID, IncludeSecureCookies includeSecureCookies)
    113113{
    114114    String cookieString;
    115115    bool secureCookiesAccessed = false;
    116     if (!WebProcess::singleton().ensureNetworkProcessConnection().connection().sendSync(Messages::NetworkConnectionToWebProcess::CookiesForDOM(session.sessionID(), firstParty, url, includeSecureCookies), Messages::NetworkConnectionToWebProcess::CookiesForDOM::Reply(cookieString, secureCookiesAccessed), 0))
     116    if (!WebProcess::singleton().ensureNetworkProcessConnection().connection().sendSync(Messages::NetworkConnectionToWebProcess::CookiesForDOM(session.sessionID(), firstParty, url, frameID, pageID, includeSecureCookies), Messages::NetworkConnectionToWebProcess::CookiesForDOM::Reply(cookieString, secureCookiesAccessed), 0))
    117117        return { String(), false };
    118118
    … …  
    120120}
    121121
    122 void WebPlatformStrategies::setCookiesFromDOM(const NetworkStorageSession& session, const URL& firstParty, const URL& url, const String& cookieString)
    123 {
    124     WebProcess::singleton().ensureNetworkProcessConnection().connection().send(Messages::NetworkConnectionToWebProcess::SetCookiesFromDOM(session.sessionID(), firstParty, url, cookieString), 0);
     122void WebPlatformStrategies::setCookiesFromDOM(const NetworkStorageSession& session, const URL& firstParty, const URL& url, std::optional<uint64_t> frameID, std::optional<uint64_t> pageID, const String& cookieString)
     123{
     124    WebProcess::singleton().ensureNetworkProcessConnection().connection().send(Messages::NetworkConnectionToWebProcess::SetCookiesFromDOM(session.sessionID(), firstParty, url, frameID, pageID, cookieString), 0);
    125125}
    126126
    … …  
    133133}
    134134
    135 std::pair<String, bool> WebPlatformStrategies::cookieRequestHeaderFieldValue(const NetworkStorageSession& session, const URL& firstParty, const URL& url, IncludeSecureCookies includeSecureCookies)
    136 {
    137     return cookieRequestHeaderFieldValue(session.sessionID(), firstParty, url, includeSecureCookies);
    138 }
    139 
    140 std::pair<String, bool> WebPlatformStrategies::cookieRequestHeaderFieldValue(PAL::SessionID sessionID, const URL& firstParty, const URL& url, IncludeSecureCookies includeSecureCookies)
     135std::pair<String, bool> WebPlatformStrategies::cookieRequestHeaderFieldValue(const NetworkStorageSession& session, const URL& firstParty, const URL& url, std::optional<uint64_t> frameID, std::optional<uint64_t> pageID, IncludeSecureCookies includeSecureCookies)
     136{
     137    return cookieRequestHeaderFieldValue(session.sessionID(), firstParty, url, frameID, pageID, includeSecureCookies);
     138}
     139
     140std::pair<String, bool> WebPlatformStrategies::cookieRequestHeaderFieldValue(PAL::SessionID sessionID, const URL& firstParty, const URL& url, std::optional<uint64_t> frameID, std::optional<uint64_t> pageID, IncludeSecureCookies includeSecureCookies)
    141141{
    142142    String cookieString;
    143143    bool secureCookiesAccessed = false;
    144     if (!WebProcess::singleton().ensureNetworkProcessConnection().connection().sendSync(Messages::NetworkConnectionToWebProcess::CookieRequestHeaderFieldValue(sessionID, firstParty, url, includeSecureCookies), Messages::NetworkConnectionToWebProcess::CookieRequestHeaderFieldValue::Reply(cookieString, secureCookiesAccessed), 0))
     144    if (!WebProcess::singleton().ensureNetworkProcessConnection().connection().sendSync(Messages::NetworkConnectionToWebProcess::CookieRequestHeaderFieldValue(sessionID, firstParty, url, frameID, pageID, includeSecureCookies), Messages::NetworkConnectionToWebProcess::CookieRequestHeaderFieldValue::Reply(cookieString, secureCookiesAccessed), 0))
    145145        return { String(), false };
    146146    return { cookieString, secureCookiesAccessed };
    147147}
    148148
    149 bool WebPlatformStrategies::getRawCookies(const NetworkStorageSession& session, const URL& firstParty, const URL& url, Vector<Cookie>& rawCookies)
    150 {
    151     if (!WebProcess::singleton().ensureNetworkProcessConnection().connection().sendSync(Messages::NetworkConnectionToWebProcess::GetRawCookies(session.sessionID(), firstParty, url), Messages::NetworkConnectionToWebProcess::GetRawCookies::Reply(rawCookies), 0))
     149bool WebPlatformStrategies::getRawCookies(const NetworkStorageSession& session, const URL& firstParty, const URL& url, std::optional<uint64_t> frameID, std::optional<uint64_t> pageID, Vector<Cookie>& rawCookies)
     150{
     151    if (!WebProcess::singleton().ensureNetworkProcessConnection().connection().sendSync(Messages::NetworkConnectionToWebProcess::GetRawCookies(session.sessionID(), firstParty, url, frameID, pageID), Messages::NetworkConnectionToWebProcess::GetRawCookies::Reply(rawCookies), 0))
    152152        return false;
    153153    return true;

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

    r223195 r225934  
    4848
    4949    // WebCore::CookiesStrategy
    50     std::pair<String, bool> cookiesForDOM(const WebCore::NetworkStorageSession&, const WebCore::URL& firstParty, const WebCore::URL&, WebCore::IncludeSecureCookies) override;
    51     void setCookiesFromDOM(const WebCore::NetworkStorageSession&, const WebCore::URL& firstParty, const WebCore::URL&, const String&) override;
     50    std::pair<String, bool> cookiesForDOM(const WebCore::NetworkStorageSession&, const WebCore::URL& firstParty, const WebCore::URL&, std::optional<uint64_t> frameID, std::optional<uint64_t> pageID, WebCore::IncludeSecureCookies) override;
     51    void setCookiesFromDOM(const WebCore::NetworkStorageSession&, const WebCore::URL& firstParty, const WebCore::URL&, std::optional<uint64_t> frameID, std::optional<uint64_t> pageID, const String&) override;
    5252    bool cookiesEnabled(const WebCore::NetworkStorageSession&) override;
    53     std::pair<String, bool> cookieRequestHeaderFieldValue(const WebCore::NetworkStorageSession&, const WebCore::URL& firstParty, const WebCore::URL&, WebCore::IncludeSecureCookies) override;
    54     std::pair<String, bool> cookieRequestHeaderFieldValue(PAL::SessionID, const WebCore::URL& firstParty, const WebCore::URL&, WebCore::IncludeSecureCookies) override;
    55     bool getRawCookies(const WebCore::NetworkStorageSession&, const WebCore::URL& firstParty, const WebCore::URL&, Vector<WebCore::Cookie>&) override;
     53    std::pair<String, bool> cookieRequestHeaderFieldValue(const WebCore::NetworkStorageSession&, const WebCore::URL& firstParty, const WebCore::URL&, std::optional<uint64_t> frameID, std::optional<uint64_t> pageID, WebCore::IncludeSecureCookies) override;
     54    std::pair<String, bool> cookieRequestHeaderFieldValue(PAL::SessionID, const WebCore::URL& firstParty, const WebCore::URL&, std::optional<uint64_t> frameID, std::optional<uint64_t> pageID, WebCore::IncludeSecureCookies) override;
     55    bool getRawCookies(const WebCore::NetworkStorageSession&, const WebCore::URL& firstParty, const WebCore::URL&, std::optional<uint64_t> frameID, std::optional<uint64_t> pageID, Vector<WebCore::Cookie>&) override;
    5656    void deleteCookie(const WebCore::NetworkStorageSession&, const WebCore::URL&, const String&) override;
    5757

  • trunk/Source/WebKitLegacy/mac/ChangeLog

    r225797 r225934  
     12017-12-14  John Wilander  <wilander@apple.com>
     2
     3        Storage Access API: Implement frame-specific access in the document.cookie layer
     4        https://bugs.webkit.org/show_bug.cgi?id=180682
     5        <rdar://problem/35982257>
     6
     7        Reviewed by Alex Christensen.
     8
     9        CookiesStrategy::cookiesForDOM(), CookiesStrategy::setCookiesFromDOM(),
     10        CookiesStrategy::cookieRequestHeaderFieldValue(), and
     11        CookiesStrategy::getRawCookies() now take optional parameters for
     12        frameID and pageID to allow frame-specific scoping of cookies.
     13
     14        This change makes the return values of FrameLoaderClient::frameID()
     15        and FrameLoaderClient::pageID() std::optional<uint64_t> so that
     16        WebCore can call those getters and get the right return values in
     17        WebKit and std:nullopt in WebKitLegacy.
     18
     19        * WebCoreSupport/WebFrameLoaderClient.h:
     20        * WebCoreSupport/WebFrameLoaderClient.mm:
     21        (WebFrameLoaderClient::pageID const):
     22        (WebFrameLoaderClient::frameID const):
     23        * WebCoreSupport/WebPlatformStrategies.h:
     24        * WebCoreSupport/WebPlatformStrategies.mm:
     25        (WebPlatformStrategies::cookiesForDOM):
     26        (WebPlatformStrategies::setCookiesFromDOM):
     27        (WebPlatformStrategies::cookieRequestHeaderFieldValue):
     28        (WebPlatformStrategies::getRawCookies):
     29
    1302017-12-12  Simon Fraser  <simon.fraser@apple.com>
    231

  • trunk/Source/WebKitLegacy/mac/WebCoreSupport/WebFrameLoaderClient.h

    r223981 r225934  
    6363    bool hasWebView() const final; // mainly for assertions
    6464
    65     uint64_t pageID() const final;
    66     uint64_t frameID() const final;
     65    std::optional<uint64_t> pageID() const final;
     66    std::optional<uint64_t> frameID() const final;
    6767    PAL::SessionID sessionID() const final;
    6868

  • trunk/Source/WebKitLegacy/mac/WebCoreSupport/WebFrameLoaderClient.mm

    r224846 r225934  
    202202}
    203203
    204 uint64_t WebFrameLoaderClient::pageID() const
    205 {
    206     RELEASE_ASSERT_NOT_REACHED();
    207     return 0;
    208 }
    209 
    210 uint64_t WebFrameLoaderClient::frameID() const
    211 {
    212     RELEASE_ASSERT_NOT_REACHED();
    213     return 0;
     204std::optional<uint64_t> WebFrameLoaderClient::pageID() const
     205{
     206    return std::nullopt;
     207}
     208
     209std::optional<uint64_t> WebFrameLoaderClient::frameID() const
     210{
     211    return std::nullopt;
    214212}
    215213

  • trunk/Source/WebKitLegacy/mac/WebCoreSupport/WebPlatformStrategies.h

    r223195 r225934  
    4949
    5050    // WebCore::CookiesStrategy
    51     std::pair<String, bool> cookiesForDOM(const WebCore::NetworkStorageSession&, const WebCore::URL& firstParty, const WebCore::URL&, WebCore::IncludeSecureCookies) override;
    52     void setCookiesFromDOM(const WebCore::NetworkStorageSession&, const WebCore::URL& firstParty, const WebCore::URL&, const String&) override;
     51    std::pair<String, bool> cookiesForDOM(const WebCore::NetworkStorageSession&, const WebCore::URL& firstParty, const WebCore::URL&, std::optional<uint64_t> frameID, std::optional<uint64_t> pageID, WebCore::IncludeSecureCookies) override;
     52    void setCookiesFromDOM(const WebCore::NetworkStorageSession&, const WebCore::URL& firstParty, const WebCore::URL&, std::optional<uint64_t> frameID, std::optional<uint64_t> pageID, const String&) override;
    5353    bool cookiesEnabled(const WebCore::NetworkStorageSession&) override;
    54     std::pair<String, bool> cookieRequestHeaderFieldValue(const WebCore::NetworkStorageSession&, const WebCore::URL& firstParty, const WebCore::URL&, WebCore::IncludeSecureCookies) override;
    55     std::pair<String, bool> cookieRequestHeaderFieldValue(PAL::SessionID, const WebCore::URL& firstParty, const WebCore::URL&, WebCore::IncludeSecureCookies) override;
    56     bool getRawCookies(const WebCore::NetworkStorageSession&, const WebCore::URL& firstParty, const WebCore::URL&, Vector<WebCore::Cookie>&) override;
     54    std::pair<String, bool> cookieRequestHeaderFieldValue(const WebCore::NetworkStorageSession&, const WebCore::URL& firstParty, const WebCore::URL&, std::optional<uint64_t> frameID, std::optional<uint64_t> pageID, WebCore::IncludeSecureCookies) override;
     55    std::pair<String, bool> cookieRequestHeaderFieldValue(PAL::SessionID, const WebCore::URL& firstParty, const WebCore::URL&, std::optional<uint64_t> frameID, std::optional<uint64_t> pageID, WebCore::IncludeSecureCookies) override;
     56    bool getRawCookies(const WebCore::NetworkStorageSession&, const WebCore::URL& firstParty, const WebCore::URL&, std::optional<uint64_t> frameID, std::optional<uint64_t> pageID, Vector<WebCore::Cookie>&) override;
    5757    void deleteCookie(const WebCore::NetworkStorageSession&, const WebCore::URL&, const String&) override;
    5858

  • trunk/Source/WebKitLegacy/mac/WebCoreSupport/WebPlatformStrategies.mm

    r223195 r225934  
    7373}
    7474
    75 std::pair<String, bool> WebPlatformStrategies::cookiesForDOM(const NetworkStorageSession& session, const URL& firstParty, const URL& url, IncludeSecureCookies includeSecureCookies)
    76 {
    77     return WebCore::cookiesForDOM(session, firstParty, url, includeSecureCookies);
    78 }
    79 
    80 void WebPlatformStrategies::setCookiesFromDOM(const NetworkStorageSession& session, const URL& firstParty, const URL& url, const String& cookieString)
    81 {
    82     WebCore::setCookiesFromDOM(session, firstParty, url, cookieString);
     75std::pair<String, bool> WebPlatformStrategies::cookiesForDOM(const NetworkStorageSession& session, const URL& firstParty, const URL& url, std::optional<uint64_t> frameID, std::optional<uint64_t> pageID, IncludeSecureCookies includeSecureCookies)
     76{
     77    return WebCore::cookiesForDOM(session, firstParty, url, frameID, pageID, includeSecureCookies);
     78}
     79
     80void WebPlatformStrategies::setCookiesFromDOM(const NetworkStorageSession& session, const URL& firstParty, const URL& url, std::optional<uint64_t> frameID, std::optional<uint64_t> pageID, const String& cookieString)
     81{
     82    WebCore::setCookiesFromDOM(session, firstParty, url, frameID, pageID, cookieString);
    8383}
    8484
    … …  
    8888}
    8989
    90 std::pair<String, bool> WebPlatformStrategies::cookieRequestHeaderFieldValue(const NetworkStorageSession& session, const URL& firstParty, const URL& url, IncludeSecureCookies includeSecureCookies)
    91 {
    92     return WebCore::cookieRequestHeaderFieldValue(session, firstParty, url, includeSecureCookies);
    93 }
    94 
    95 std::pair<String, bool> WebPlatformStrategies::cookieRequestHeaderFieldValue(PAL::SessionID sessionID, const URL& firstParty, const URL& url, IncludeSecureCookies includeSecureCookies)
     90std::pair<String, bool> WebPlatformStrategies::cookieRequestHeaderFieldValue(const NetworkStorageSession& session, const URL& firstParty, const URL& url, std::optional<uint64_t> frameID, std::optional<uint64_t> pageID, IncludeSecureCookies includeSecureCookies)
     91{
     92    return WebCore::cookieRequestHeaderFieldValue(session, firstParty, url, frameID, pageID, includeSecureCookies);
     93}
     94
     95std::pair<String, bool> WebPlatformStrategies::cookieRequestHeaderFieldValue(PAL::SessionID sessionID, const URL& firstParty, const URL& url, std::optional<uint64_t> frameID, std::optional<uint64_t> pageID, IncludeSecureCookies includeSecureCookies)
    9696{
    9797    auto& session = sessionID.isEphemeral() ? WebFrameNetworkingContext::ensurePrivateBrowsingSession() : NetworkStorageSession::defaultStorageSession();
    98     return WebCore::cookieRequestHeaderFieldValue(session, firstParty, url, includeSecureCookies);
    99 }
    100 
    101 bool WebPlatformStrategies::getRawCookies(const NetworkStorageSession& session, const URL& firstParty, const URL& url, Vector<Cookie>& rawCookies)
    102 {
    103     return WebCore::getRawCookies(session, firstParty, url, rawCookies);
     98    return WebCore::cookieRequestHeaderFieldValue(session, firstParty, url, frameID, pageID, includeSecureCookies);
     99}
     100
     101bool WebPlatformStrategies::getRawCookies(const NetworkStorageSession& session, const URL& firstParty, const URL& url, std::optional<uint64_t> frameID, std::optional<uint64_t> pageID, Vector<Cookie>& rawCookies)
     102{
     103    return WebCore::getRawCookies(session, firstParty, url, frameID, pageID, rawCookies);
    104104}
    105105

  • trunk/Source/WebKitLegacy/win/ChangeLog

    r225778 r225934  
     12017-12-14  John Wilander  <wilander@apple.com>
     2
     3        Storage Access API: Implement frame-specific access in the document.cookie layer
     4        https://bugs.webkit.org/show_bug.cgi?id=180682
     5        <rdar://problem/35982257>
     6
     7        Reviewed by Alex Christensen.
     8
     9        CookiesStrategy::cookiesForDOM(), CookiesStrategy::setCookiesFromDOM(),
     10        CookiesStrategy::cookieRequestHeaderFieldValue(), and
     11        CookiesStrategy::getRawCookies() now take optional parameters for
     12        frameID and pageID to allow frame-specific scoping of cookies.
     13
     14        This change makes the return values of FrameLoaderClient::frameID()
     15        and FrameLoaderClient::pageID() std::optional<uint64_t> so that
     16        WebCore can call those getters and get the right return values in
     17        WebKit and std:nullopt in WebKitLegacy.
     18
     19        * WebCoreSupport/WebFrameLoaderClient.cpp:
     20        (WebFrameLoaderClient::pageID const):
     21        (WebFrameLoaderClient::frameID const):
     22            Now return an optional.
     23        * WebCoreSupport/WebFrameLoaderClient.h:
     24        * WebCoreSupport/WebPlatformStrategies.cpp:
     25        (WebPlatformStrategies::cookiesForDOM):
     26        (WebPlatformStrategies::setCookiesFromDOM):
     27        (WebPlatformStrategies::cookieRequestHeaderFieldValue):
     28        (WebPlatformStrategies::getRawCookies):
     29        * WebCoreSupport/WebPlatformStrategies.h:
     30
    1312017-12-12  Yusuke Suzuki  <utatane.tea@gmail.com>
    232

  • trunk/Source/WebKitLegacy/win/WebCoreSupport/WebFrameLoaderClient.cpp

    r224387 r225934  
    122122}
    123123
    124 uint64_t WebFrameLoaderClient::pageID() const
     124std::optional<uint64_t> WebFrameLoaderClient::pageID() const
    125125{
    126126    RELEASE_ASSERT_NOT_REACHED();
    127     return 0;
    128 }
    129 
    130 uint64_t WebFrameLoaderClient::frameID() const
     127    return std::nullopt;
     128}
     129
     130std::optional<uint64_t> WebFrameLoaderClient::frameID() const
    131131{
    132132    RELEASE_ASSERT_NOT_REACHED();
    133     return 0;
     133    return std::nullopt;
    134134}
    135135

  • trunk/Source/WebKitLegacy/win/WebCoreSupport/WebFrameLoaderClient.h

    r223981 r225934  
    5252    void dispatchDidFailToStartPlugin(const WebCore::PluginView*) const;
    5353
    54     uint64_t pageID() const final;
    55     uint64_t frameID() const final;
     54    std::optional<uint64_t> pageID() const final;
     55    std::optional<uint64_t> frameID() const final;
    5656    PAL::SessionID sessionID() const final;
    5757

  • trunk/Source/WebKitLegacy/win/WebCoreSupport/WebPlatformStrategies.cpp

    r222938 r225934  
    7171}
    7272
    73 std::pair<String, bool> WebPlatformStrategies::cookiesForDOM(const WebCore::NetworkStorageSession& session, const WebCore::URL& firstParty, const WebCore::URL& url, WebCore::IncludeSecureCookies includeSecureCookies)
     73std::pair<String, bool> WebPlatformStrategies::cookiesForDOM(const WebCore::NetworkStorageSession& session, const WebCore::URL& firstParty, const WebCore::URL& url, std::optional<uint64_t> frameID, std::optional<uint64_t> pageID, WebCore::IncludeSecureCookies includeSecureCookies)
    7474{
    75     return WebCore::cookiesForDOM(session, firstParty, url, includeSecureCookies);
     75    return WebCore::cookiesForDOM(session, firstParty, url, frameID, pageID, includeSecureCookies);
    7676}
    7777
    78 void WebPlatformStrategies::setCookiesFromDOM(const NetworkStorageSession& session, const URL& firstParty, const URL& url, const String& cookieString)
     78void WebPlatformStrategies::setCookiesFromDOM(const NetworkStorageSession& session, const URL& firstParty, const URL& url, std::optional<uint64_t> frameID, std::optional<uint64_t> pageID, const String& cookieString)
    7979{
    80     WebCore::setCookiesFromDOM(session, firstParty, url, cookieString);
     80    WebCore::setCookiesFromDOM(session, firstParty, url, frameID, pageID, cookieString);
    8181}
    8282
    … …  
    8686}
    8787
    88 std::pair<String, bool> WebPlatformStrategies::cookieRequestHeaderFieldValue(const NetworkStorageSession& session, const URL& firstParty, const URL& url, WebCore::IncludeSecureCookies includeSecureCookies)
     88std::pair<String, bool> WebPlatformStrategies::cookieRequestHeaderFieldValue(const NetworkStorageSession& session, const URL& firstParty, const URL& url, std::optional<uint64_t> frameID, std::optional<uint64_t> pageID, WebCore::IncludeSecureCookies includeSecureCookies)
    8989{
    90     return WebCore::cookieRequestHeaderFieldValue(session, firstParty, url, includeSecureCookies);
     90    return WebCore::cookieRequestHeaderFieldValue(session, firstParty, url, frameID, pageID, includeSecureCookies);
    9191}
    9292
    93 std::pair<String, bool> WebPlatformStrategies::cookieRequestHeaderFieldValue(PAL::SessionID sessionID, const URL& firstParty, const URL& url, WebCore::IncludeSecureCookies includeSecureCookies)
     93std::pair<String, bool> WebPlatformStrategies::cookieRequestHeaderFieldValue(PAL::SessionID sessionID, const URL& firstParty, const URL& url, std::optional<uint64_t> frameID, std::optional<uint64_t> pageID, WebCore::IncludeSecureCookies includeSecureCookies)
    9494{
    9595    auto& session = sessionID.isEphemeral() ? WebFrameNetworkingContext::ensurePrivateBrowsingSession() : NetworkStorageSession::defaultStorageSession();
    96     return WebCore::cookieRequestHeaderFieldValue(session, firstParty, url, includeSecureCookies);
     96    return WebCore::cookieRequestHeaderFieldValue(session, firstParty, url, frameID, pageID, includeSecureCookies);
    9797}
    9898
    99 bool WebPlatformStrategies::getRawCookies(const NetworkStorageSession& session, const URL& firstParty, const URL& url, Vector<Cookie>& rawCookies)
     99bool WebPlatformStrategies::getRawCookies(const NetworkStorageSession& session, const URL& firstParty, const URL& url, std::optional<uint64_t> frameID, std::optional<uint64_t> pageID, Vector<Cookie>& rawCookies)
    100100{
    101     return WebCore::getRawCookies(session, firstParty, url, rawCookies);
     101    return WebCore::getRawCookies(session, firstParty, url, frameID, pageID, rawCookies);
    102102}
    103103

  • trunk/Source/WebKitLegacy/win/WebCoreSupport/WebPlatformStrategies.h

    r222938 r225934  
    4646
    4747    // WebCore::CookiesStrategy
    48     std::pair<String, bool> cookiesForDOM(const WebCore::NetworkStorageSession&, const WebCore::URL& firstParty, const WebCore::URL&, WebCore::IncludeSecureCookies) override;
    49     virtual void setCookiesFromDOM(const WebCore::NetworkStorageSession&, const WebCore::URL& firstParty, const WebCore::URL&, const String&);
     48    std::pair<String, bool> cookiesForDOM(const WebCore::NetworkStorageSession&, const WebCore::URL& firstParty, const WebCore::URL&, std::optional<uint64_t> frameID, std::optional<uint64_t> pageID, WebCore::IncludeSecureCookies) override;
     49    virtual void setCookiesFromDOM(const WebCore::NetworkStorageSession&, const WebCore::URL& firstParty, const WebCore::URL&, std::optional<uint64_t> frameID, std::optional<uint64_t> pageID, const String&);
    5050    virtual bool cookiesEnabled(const WebCore::NetworkStorageSession&);
    51     std::pair<String, bool> cookieRequestHeaderFieldValue(const WebCore::NetworkStorageSession&, const WebCore::URL& firstParty, const WebCore::URL&, WebCore::IncludeSecureCookies) override;
    52     std::pair<String, bool> cookieRequestHeaderFieldValue(PAL::SessionID, const WebCore::URL& firstParty, const WebCore::URL&, WebCore::IncludeSecureCookies) override;
    53     virtual bool getRawCookies(const WebCore::NetworkStorageSession&, const WebCore::URL& firstParty, const WebCore::URL&, Vector<WebCore::Cookie>&);
     51    std::pair<String, bool> cookieRequestHeaderFieldValue(const WebCore::NetworkStorageSession&, const WebCore::URL& firstParty, const WebCore::URL&, std::optional<uint64_t> frameID, std::optional<uint64_t> pageID, WebCore::IncludeSecureCookies) override;
     52    std::pair<String, bool> cookieRequestHeaderFieldValue(PAL::SessionID, const WebCore::URL& firstParty, const WebCore::URL&, std::optional<uint64_t> frameID, std::optional<uint64_t> pageID, WebCore::IncludeSecureCookies) override;
     53    virtual bool getRawCookies(const WebCore::NetworkStorageSession&, const WebCore::URL& firstParty, const WebCore::URL&, std::optional<uint64_t> frameID, std::optional<uint64_t> pageID, Vector<WebCore::Cookie>&);
    5454    virtual void deleteCookie(const WebCore::NetworkStorageSession&, const WebCore::URL&, const String&);
    5555};
Note: See TracChangeset for help on using the changeset viewer.