Changeset 234376 in webkit


Ignore:
Timestamp:
Jul 30, 2018, 12:37:42 PM (7 years ago)
Author:
commit-queue@webkit.org
Message:

Source/WebCore:
Merge PlatformCookieJar functions into NetworkStorageSession
​https://bugs.webkit.org/show_bug.cgi?id=188137

Patch by Rob Buis <​rbuis@igalia.com> on 2018-07-30
Reviewed by Alex Christensen.

No new tests -- no change in WebKit functionality.

  • PlatformMac.cmake: Remove CookieJarMac.mm reference
  • SourcesCocoa.txt: Remove CookieJarMac.mm reference
  • WebCore.xcodeproj/project.pbxproj:
  • loader/CookieJar.cpp: Remove PlatformCookieJar.h reference.
  • platform/Curl.cmake: Remove CookieJarCurl.cpp reference.
  • platform/SourcesSoup.txt: Remove CookieJarSoup.cpp reference.
  • platform/network/CacheValidation.cpp: Adapt callsites to use

NetworkStorageSession instead of CookieJar functions.

(WebCore::headerValueForVary):

  • platform/network/NetworkStorageSession.h: Add PlatformCookieJar

functions.

  • platform/network/PlatformCookieJar.h: Removed.
  • platform/network/SocketStreamHandleImpl.cpp: Adapt callsites to

use NetworkStorageSession instead of CookieJar functions.
(WebCore::cookieDataForHandshake):

  • platform/network/cf/CookieJarCFNet.cpp: Removed.
  • platform/network/cf/NetworkStorageSessionCFNet.cpp: Move functions

from CookieJarCFNet.cpp.
(WebCore::cookieDomain):
(WebCore::canonicalCookieTime):
(WebCore::cookieCreatedTime):
(WebCore::cookieExpirationTime):
(WebCore::cookieName):
(WebCore::cookiePath):
(WebCore::cookieValue):
(WebCore::filterCookies):
(WebCore::copyCookiesForURLWithFirstPartyURL):
(WebCore::createCookies):
(WebCore::NetworkStorageSession::setCookiesFromDOM const):
(WebCore::containsSecureCookies):
(WebCore::NetworkStorageSession::cookiesForDOM const):
(WebCore::NetworkStorageSession::cookieRequestHeaderFieldValue const):
(WebCore::NetworkStorageSession::cookiesEnabled const):
(WebCore::NetworkStorageSession::getRawCookies const):
(WebCore::NetworkStorageSession::deleteCookie const):
(WebCore::NetworkStorageSession::getHostnamesWithCookies):
(WebCore::NetworkStorageSession::deleteAllCookies):
(WebCore::NetworkStorageSession::deleteCookiesForHostnames):
(WebCore::NetworkStorageSession::deleteAllCookiesModifiedSince):

  • platform/network/cocoa/NetworkStorageSessionCocoa.mm: Move functions

from CookieJarMac.mm.
(WebCore::httpCookies):
(WebCore::deleteHTTPCookie):
(WebCore::policyProperties):
(WebCore::cookiesForURL):
(WebCore::setHTTPCookiesForURL):
(WebCore::httpCookiesForURL):
(WebCore::filterCookies):
(WebCore::applyPartitionToCookies):
(WebCore::cookiesAreBlockedForURL):
(WebCore::cookiesInPartitionForURL):
(WebCore::cookiesForSession):
(WebCore::deleteAllHTTPCookies):
(WebCore::NetworkStorageSession::cookiesForDOM const):
(WebCore::NetworkStorageSession::cookieRequestHeaderFieldValue const):
(WebCore::NetworkStorageSession::setCookiesFromDOM const):
(WebCore::httpCookieAcceptPolicy):
(WebCore::NetworkStorageSession::cookiesEnabled const):
(WebCore::NetworkStorageSession::getRawCookies const):
(WebCore::NetworkStorageSession::deleteCookie const):
(WebCore::NetworkStorageSession::getHostnamesWithCookies):
(WebCore::NetworkStorageSession::deleteAllCookies):
(WebCore::NetworkStorageSession::deleteCookiesForHostnames):
(WebCore::NetworkStorageSession::deleteAllCookiesModifiedSince):

  • platform/network/curl/CookieJarCurl.cpp: Removed.
  • platform/network/curl/CookieJarCurl.h:
  • platform/network/curl/NetworkStorageSessionCurl.cpp: Merge functions

from CookieJarCurl.cpp.
(WebCore::NetworkStorageSession::setCookiesFromDOM const):
(WebCore::NetworkStorageSession::cookiesEnabled const):
(WebCore::NetworkStorageSession::cookiesForDOM const):
(WebCore::NetworkStorageSession::deleteCookie const):
(WebCore::NetworkStorageSession::deleteAllCookies):
(WebCore::NetworkStorageSession::deleteAllCookiesModifiedSince):
(WebCore::NetworkStorageSession::deleteCookiesForHostnames):
(WebCore::NetworkStorageSession::getHostnamesWithCookies):
(WebCore::NetworkStorageSession::getRawCookies const):
(WebCore::NetworkStorageSession::cookieRequestHeaderFieldValue const):

  • platform/network/mac/CookieJarMac.mm: Removed.
  • platform/network/mac/WebCoreResourceHandleAsOperationQueueDelegate.mm:
  • platform/network/soup/CookieJarSoup.cpp: Removed.
  • platform/network/soup/NetworkStorageSessionSoup.cpp: Merge functions

from CookieJarSoup.cpp.
(WebCore::NetworkStorageSession::cookiesEnabled const):
(WebCore::httpOnlyCookieExists):
(WebCore::NetworkStorageSession::setCookiesFromDOM const):
(WebCore::NetworkStorageSession::deleteCookie const):
(WebCore::NetworkStorageSession::deleteAllCookies):
(WebCore::NetworkStorageSession::deleteAllCookiesModifiedSince):
(WebCore::NetworkStorageSession::deleteCookiesForHostnames):
(WebCore::NetworkStorageSession::getHostnamesWithCookies):
(WebCore::NetworkStorageSession::getRawCookies const):
(WebCore::cookiesForSession):
(WebCore::NetworkStorageSession::cookiesForDOM const):
(WebCore::NetworkStorageSession::cookieRequestHeaderFieldValue const):

Source/WebKit:
​https://bugs.webkit.org/show_bug.cgi?id=188137
Merge PlatformCookieJar functions into NetworkStorageSession

Adapt callsites to use NetworkStorageSession instead of CookieJar functions.

Patch by Rob Buis <​rbuis@igalia.com> on 2018-07-30
Reviewed by Alex Christensen.

  • NetworkProcess/Cookies/WebCookieManager.cpp:

(WebKit::WebCookieManager::getHostnamesWithCookies):
(WebKit::WebCookieManager::deleteCookiesForHostname):
(WebKit::WebCookieManager::deleteAllCookies):
(WebKit::WebCookieManager::deleteAllCookiesModifiedSince):

  • NetworkProcess/NetworkConnectionToWebProcess.cpp:

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

  • NetworkProcess/NetworkProcess.cpp:

(WebKit::NetworkProcess::fetchWebsiteData):
(WebKit::NetworkProcess::deleteWebsiteData):
(WebKit::NetworkProcess::deleteWebsiteDataForOrigins):

  • NetworkProcess/NetworkResourceLoader.cpp:

(WebKit::logCookieInformationInternal):

  • NetworkProcess/cache/NetworkCache.cpp:
  • WebProcess/WebCoreSupport/WebPlatformStrategies.cpp:

Source/WebKitLegacy/mac:
Merge PlatformCookieJar functions into NetworkStorageSession
​https://bugs.webkit.org/show_bug.cgi?id=188137

Adapt callsites to use NetworkStorageSession instead of CookieJar functions.

Patch by Rob Buis <​rbuis@igalia.com> on 2018-07-30
Reviewed by Alex Christensen.

  • WebCoreSupport/WebPlatformStrategies.mm:

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

  • WebView/WebPreferences.mm:

(+[WebPreferences _clearNetworkLoaderSession]):

Source/WebKitLegacy/win:
​https://bugs.webkit.org/show_bug.cgi?id=188137
Merge PlatformCookieJar functions into NetworkStorageSession

Adapt callsites to use NetworkStorageSession instead of CookieJar functions.

Patch by Rob Buis <​rbuis@igalia.com> on 2018-07-30
Reviewed by Alex Christensen.

  • WebCoreSupport/WebPlatformStrategies.cpp:

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

  • WebPreferences.cpp:

(WebPreferences::clearNetworkLoaderSession):

Location:
trunk/Source
Files:
5 deleted
30 edited

Legend:

Unmodified
Added
Removed

  • trunk/Source/WebCore/ChangeLog

    r234374 r234376  
     12018-07-30  Rob Buis  <rbuis@igalia.com>
     2
     3        Merge PlatformCookieJar functions into NetworkStorageSession
     4        https://bugs.webkit.org/show_bug.cgi?id=188137
     5
     6        Reviewed by Alex Christensen.
     7
     8        No new tests -- no change in WebKit functionality.
     9
     10        * PlatformMac.cmake: Remove CookieJarMac.mm reference
     11        * SourcesCocoa.txt: Remove CookieJarMac.mm reference
     12        * WebCore.xcodeproj/project.pbxproj:
     13        * loader/CookieJar.cpp: Remove PlatformCookieJar.h reference.
     14        * platform/Curl.cmake: Remove CookieJarCurl.cpp reference.
     15        * platform/SourcesSoup.txt: Remove CookieJarSoup.cpp reference.
     16        * platform/network/CacheValidation.cpp: Adapt callsites to use
     17        NetworkStorageSession instead of CookieJar functions.
     18
     19        (WebCore::headerValueForVary):
     20        * platform/network/NetworkStorageSession.h: Add PlatformCookieJar
     21        functions.
     22
     23        * platform/network/PlatformCookieJar.h: Removed.
     24        * platform/network/SocketStreamHandleImpl.cpp: Adapt callsites to
     25        use NetworkStorageSession instead of CookieJar functions.
     26        (WebCore::cookieDataForHandshake):
     27        * platform/network/cf/CookieJarCFNet.cpp: Removed.
     28        * platform/network/cf/NetworkStorageSessionCFNet.cpp: Move functions
     29        from CookieJarCFNet.cpp.
     30        (WebCore::cookieDomain):
     31        (WebCore::canonicalCookieTime):
     32        (WebCore::cookieCreatedTime):
     33        (WebCore::cookieExpirationTime):
     34        (WebCore::cookieName):
     35        (WebCore::cookiePath):
     36        (WebCore::cookieValue):
     37        (WebCore::filterCookies):
     38        (WebCore::copyCookiesForURLWithFirstPartyURL):
     39        (WebCore::createCookies):
     40        (WebCore::NetworkStorageSession::setCookiesFromDOM const):
     41        (WebCore::containsSecureCookies):
     42        (WebCore::NetworkStorageSession::cookiesForDOM const):
     43        (WebCore::NetworkStorageSession::cookieRequestHeaderFieldValue const):
     44        (WebCore::NetworkStorageSession::cookiesEnabled const):
     45        (WebCore::NetworkStorageSession::getRawCookies const):
     46        (WebCore::NetworkStorageSession::deleteCookie const):
     47        (WebCore::NetworkStorageSession::getHostnamesWithCookies):
     48        (WebCore::NetworkStorageSession::deleteAllCookies):
     49        (WebCore::NetworkStorageSession::deleteCookiesForHostnames):
     50        (WebCore::NetworkStorageSession::deleteAllCookiesModifiedSince):
     51        * platform/network/cocoa/NetworkStorageSessionCocoa.mm: Move functions
     52        from CookieJarMac.mm.
     53        (WebCore::httpCookies):
     54        (WebCore::deleteHTTPCookie):
     55        (WebCore::policyProperties):
     56        (WebCore::cookiesForURL):
     57        (WebCore::setHTTPCookiesForURL):
     58        (WebCore::httpCookiesForURL):
     59        (WebCore::filterCookies):
     60        (WebCore::applyPartitionToCookies):
     61        (WebCore::cookiesAreBlockedForURL):
     62        (WebCore::cookiesInPartitionForURL):
     63        (WebCore::cookiesForSession):
     64        (WebCore::deleteAllHTTPCookies):
     65        (WebCore::NetworkStorageSession::cookiesForDOM const):
     66        (WebCore::NetworkStorageSession::cookieRequestHeaderFieldValue const):
     67        (WebCore::NetworkStorageSession::setCookiesFromDOM const):
     68        (WebCore::httpCookieAcceptPolicy):
     69        (WebCore::NetworkStorageSession::cookiesEnabled const):
     70        (WebCore::NetworkStorageSession::getRawCookies const):
     71        (WebCore::NetworkStorageSession::deleteCookie const):
     72        (WebCore::NetworkStorageSession::getHostnamesWithCookies):
     73        (WebCore::NetworkStorageSession::deleteAllCookies):
     74        (WebCore::NetworkStorageSession::deleteCookiesForHostnames):
     75        (WebCore::NetworkStorageSession::deleteAllCookiesModifiedSince):
     76        * platform/network/curl/CookieJarCurl.cpp: Removed.
     77        * platform/network/curl/CookieJarCurl.h:
     78        * platform/network/curl/NetworkStorageSessionCurl.cpp: Merge functions
     79        from CookieJarCurl.cpp.
     80        (WebCore::NetworkStorageSession::setCookiesFromDOM const):
     81        (WebCore::NetworkStorageSession::cookiesEnabled const):
     82        (WebCore::NetworkStorageSession::cookiesForDOM const):
     83        (WebCore::NetworkStorageSession::deleteCookie const):
     84        (WebCore::NetworkStorageSession::deleteAllCookies):
     85        (WebCore::NetworkStorageSession::deleteAllCookiesModifiedSince):
     86        (WebCore::NetworkStorageSession::deleteCookiesForHostnames):
     87        (WebCore::NetworkStorageSession::getHostnamesWithCookies):
     88        (WebCore::NetworkStorageSession::getRawCookies const):
     89        (WebCore::NetworkStorageSession::cookieRequestHeaderFieldValue const):
     90        * platform/network/mac/CookieJarMac.mm: Removed.
     91        * platform/network/mac/WebCoreResourceHandleAsOperationQueueDelegate.mm:
     92        * platform/network/soup/CookieJarSoup.cpp: Removed.
     93        * platform/network/soup/NetworkStorageSessionSoup.cpp: Merge functions
     94        from CookieJarSoup.cpp.
     95        (WebCore::NetworkStorageSession::cookiesEnabled const):
     96        (WebCore::httpOnlyCookieExists):
     97        (WebCore::NetworkStorageSession::setCookiesFromDOM const):
     98        (WebCore::NetworkStorageSession::deleteCookie const):
     99        (WebCore::NetworkStorageSession::deleteAllCookies):
     100        (WebCore::NetworkStorageSession::deleteAllCookiesModifiedSince):
     101        (WebCore::NetworkStorageSession::deleteCookiesForHostnames):
     102        (WebCore::NetworkStorageSession::getHostnamesWithCookies):
     103        (WebCore::NetworkStorageSession::getRawCookies const):
     104        (WebCore::cookiesForSession):
     105        (WebCore::NetworkStorageSession::cookiesForDOM const):
     106        (WebCore::NetworkStorageSession::cookieRequestHeaderFieldValue const):
     107
    11082018-07-30  Chris Dumez  <cdumez@apple.com>
    2109

  • trunk/Source/WebCore/PlatformAppleWin.cmake

    r229359 r234376  
    4848
    4949    platform/network/cf/AuthenticationCF.cpp
    50     platform/network/cf/CookieJarCFNet.cpp
    5150    platform/network/cf/CookieStorageCFNet.cpp
    5251    platform/network/cf/CredentialStorageCFNet.cpp

  • trunk/Source/WebCore/PlatformMac.cmake

    r234258 r234376  
    435435    platform/network/mac/BlobDataFileReferenceMac.mm
    436436    platform/network/mac/CertificateInfoMac.mm
    437     platform/network/mac/CookieJarMac.mm
    438437    platform/network/mac/CookieStorageMac.mm
    439438    platform/network/mac/CredentialStorageMac.mm

  • trunk/Source/WebCore/SourcesCocoa.txt

    r234258 r234376  
    508508platform/network/mac/BlobDataFileReferenceMac.mm
    509509platform/network/mac/CertificateInfoMac.mm
    510 platform/network/mac/CookieJarMac.mm
    511510platform/network/mac/CookieStorageMac.mm
    512511platform/network/mac/CredentialStorageMac.mm

  • trunk/Source/WebCore/WebCore.xcodeproj/project.pbxproj

    r234289 r234376  
    46044604                E139866415478474001E3F65 /* StyleResolver.h in Headers */ = {isa = PBXBuildFile; fileRef = E139866215478474001E3F65 /* StyleResolver.h */; };
    46054605                E13EF3441684ECF40034C83F /* NetworkStorageSession.h in Headers */ = {isa = PBXBuildFile; fileRef = E13EF3421684ECF40034C83F /* NetworkStorageSession.h */; settings = {ATTRIBUTES = (Private, ); }; };
    4606                 E1424C8A164B3B4E00F32D40 /* PlatformCookieJar.h in Headers */ = {isa = PBXBuildFile; fileRef = E1424C89164B3B4E00F32D40 /* PlatformCookieJar.h */; settings = {ATTRIBUTES = (Private, ); }; };
    46074606                E1424C94164B52C800F32D40 /* CookieJar.h in Headers */ = {isa = PBXBuildFile; fileRef = E1424C92164B52C800F32D40 /* CookieJar.h */; settings = {ATTRIBUTES = (Private, ); }; };
    46084607                E14F1C4514B5DAC600EA9009 /* HTMLFormControlElementWithState.h in Headers */ = {isa = PBXBuildFile; fileRef = E14F1C4314B5DAC600EA9009 /* HTMLFormControlElementWithState.h */; settings = {ATTRIBUTES = (Private, ); }; };
    … …  
    1413114130                E13F01EA1270E10D00DFBA71 /* CookieStorage.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = CookieStorage.h; sourceTree = "<group>"; };
    1413214131                E13F01F01270E19000DFBA71 /* CookieStorageMac.mm */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.objcpp; path = CookieStorageMac.mm; sourceTree = "<group>"; };
    14133                 E1424C89164B3B4E00F32D40 /* PlatformCookieJar.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = PlatformCookieJar.h; sourceTree = "<group>"; };
    14134                 E1424C8F164B460B00F32D40 /* CookieJarMac.mm */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.objcpp; path = CookieJarMac.mm; sourceTree = "<group>"; };
    1413514132                E1424C91164B52C800F32D40 /* CookieJar.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = CookieJar.cpp; sourceTree = "<group>"; };
    1413614133                E1424C92164B52C800F32D40 /* CookieJar.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = CookieJar.h; sourceTree = "<group>"; };
    … …  
    1907419071                                447958021643B47B001E0A7F /* ParsedContentType.cpp */,
    1907519072                                447958031643B47B001E0A7F /* ParsedContentType.h */,
    19076                                 E1424C89164B3B4E00F32D40 /* PlatformCookieJar.h */,
    1907719073                                37BAAE571980D1DD005DFE71 /* ProtectionSpace.h */,
    1907819074                                514C765F0CE923A1007EF3CD /* ProtectionSpaceBase.cpp */,
    … …  
    1911419110                                E164A2EB191AE6350010737D /* BlobDataFileReferenceMac.mm */,
    1911519111                                5F2DBBE7178E332D00141486 /* CertificateInfoMac.mm */,
    19116                                 E1424C8F164B460B00F32D40 /* CookieJarMac.mm */,
    1911719112                                E13F01F01270E19000DFBA71 /* CookieStorageMac.mm */,
    1911819113                                E1B4CD2410B322E200BFFD7E /* CredentialStorageMac.mm */,
    … …  
    2971629711                                2D70BA1318074DDF0001908A /* PlatformCALayerCocoa.h in Headers */,
    2971729712                                A14978711ABAF3A500CEF7E4 /* PlatformContentFilter.h in Headers */,
    29718                                 E1424C8A164B3B4E00F32D40 /* PlatformCookieJar.h in Headers */,
    2971929713                                BC5C762B1497FE1400BC4775 /* PlatformEvent.h in Headers */,
    2972029714                                26601EBF14B3B9AD0012C0FE /* PlatformEventFactoryIOS.h in Headers */,
    … …  
    2989529889                                0BE030A20F3112FB003C1A46 /* RenderLineBoxList.h in Headers */,
    2989629890                                BCEA4864097D93020094C9E4 /* RenderLineBreak.h in Headers */,
    29897                                 94CFD60A1FE9867E002488AD /* RenderLinesClampFlow.h in Headers */,
    29898                                 94CFD60D1FEACEFE002488AD /* RenderLinesClampSet.h in Headers */,
    2989929891                                ABB5419F0ACDDFE4002820EB /* RenderListBox.h in Headers */,
    2990029892                                A8EA7A520A191A5200A8EF5F /* RenderListItem.h in Headers */,

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

    r230944 r234376  
    3636#include "NetworkStorageSession.h"
    3737#include "NetworkingContext.h"
    38 #include "PlatformCookieJar.h"
    3938#include "PlatformStrategies.h"
    4039#include "SameSiteInfo.h"

  • trunk/Source/WebCore/platform/Curl.cmake

    r233481 r234376  
    66    platform/network/curl/AuthenticationChallengeCurl.cpp
    77    platform/network/curl/CertificateInfo.cpp
    8     platform/network/curl/CookieJarCurl.cpp
    98    platform/network/curl/CookieJarCurlDatabase.cpp
    109    platform/network/curl/CookieJarDB.cpp

  • trunk/Source/WebCore/platform/SourcesSoup.txt

    r229359 r234376  
    2424platform/network/soup/AuthenticationChallengeSoup.cpp
    2525platform/network/soup/CertificateInfo.cpp
    26 platform/network/soup/CookieJarSoup.cpp
    2726platform/network/soup/CookieSoup.cpp
    2827platform/network/soup/CookieStorageSoup.cpp

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

    r234278 r234376  
    3030#include "HTTPHeaderMap.h"
    3131#include "NetworkStorageSession.h"
    32 #include "PlatformCookieJar.h"
    3332#include "PlatformStrategies.h"
    3433#include "ResourceRequest.h"
    … …  
    339338        if (!cookieStrategy) {
    340339            ASSERT(sessionID == PAL::SessionID::defaultSessionID());
    341             return cookieRequestHeaderFieldValue(NetworkStorageSession::defaultStorageSession(), request.firstPartyForCookies(), SameSiteInfo::create(request), request.url(), std::nullopt, std::nullopt, includeSecureCookies).first;
     340            return NetworkStorageSession::defaultStorageSession().cookieRequestHeaderFieldValue(request.firstPartyForCookies(), SameSiteInfo::create(request), request.url(), std::nullopt, std::nullopt, includeSecureCookies).first;
    342341        }
    343342        return cookieStrategy->cookieRequestHeaderFieldValue(sessionID, request.firstPartyForCookies(), SameSiteInfo::create(request), request.url(), std::nullopt, std::nullopt, includeSecureCookies).first;

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

    r232863 r234376  
    3131#include <wtf/HashMap.h>
    3232#include <wtf/HashSet.h>
     33#include <wtf/WallTime.h>
    3334#include <wtf/text/WTFString.h>
    3435
    … …  
    6566
    6667struct Cookie;
     68struct CookieRequestHeaderFieldProxy;
     69struct SameSiteInfo;
     70
     71enum class IncludeSecureCookies;
    6772
    6873class NetworkStorageSession {
    … …  
    138143#endif
    139144
     145    WEBCORE_EXPORT bool cookiesEnabled() const;
    140146    WEBCORE_EXPORT void setCookie(const Cookie&);
    141147    WEBCORE_EXPORT void setCookies(const Vector<Cookie>&, const URL&, const URL& mainDocumentURL);
     148    WEBCORE_EXPORT void setCookiesFromDOM(const URL& firstParty, const SameSiteInfo&, const URL&, std::optional<uint64_t> frameID, std::optional<uint64_t> pageID, const String&) const;
    142149    WEBCORE_EXPORT void deleteCookie(const Cookie&);
     150    WEBCORE_EXPORT void deleteCookie(const URL&, const String&) const;
     151    WEBCORE_EXPORT void deleteAllCookies();
     152    WEBCORE_EXPORT void deleteAllCookiesModifiedSince(WallTime);
     153    WEBCORE_EXPORT void deleteCookiesForHostnames(const Vector<String>& cookieHostNames);
    143154    WEBCORE_EXPORT Vector<Cookie> getAllCookies();
    144155    WEBCORE_EXPORT Vector<Cookie> getCookies(const URL&);
     156    WEBCORE_EXPORT bool getRawCookies(const URL& firstParty, const SameSiteInfo&, const URL&, std::optional<uint64_t> frameID, std::optional<uint64_t> pageID, Vector<Cookie>&) const;
    145157    WEBCORE_EXPORT void flushCookieStore();
     158    WEBCORE_EXPORT void getHostnamesWithCookies(HashSet<String>& hostnames);
     159    WEBCORE_EXPORT std::pair<String, bool> cookiesForDOM(const URL& firstParty, const SameSiteInfo&, const URL&, std::optional<uint64_t> frameID, std::optional<uint64_t> pageID, IncludeSecureCookies) const;
     160    WEBCORE_EXPORT std::pair<String, bool> cookieRequestHeaderFieldValue(const URL& firstParty, const SameSiteInfo&, const URL&, std::optional<uint64_t> frameID, std::optional<uint64_t> pageID, IncludeSecureCookies) const;
     161    WEBCORE_EXPORT std::pair<String, bool> cookieRequestHeaderFieldValue(const CookieRequestHeaderFieldProxy&) const;
     162
    146163
    147164private:

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

    r233183 r234376  
    2929#include "CookieRequestHeaderFieldProxy.h"
    3030#include "NetworkStorageSession.h"
    31 #include "PlatformCookieJar.h"
    3231#include "SocketStreamHandleClient.h"
    3332#include <wtf/Function.h>
    … …  
    8685    String cookieDataString;
    8786    bool secureCookiesAccessed = false;
    88     std::tie(cookieDataString, secureCookiesAccessed) = WebCore::cookieRequestHeaderFieldValue(*networkStorageSession, headerFieldProxy);
     87    std::tie(cookieDataString, secureCookiesAccessed) = networkStorageSession->cookieRequestHeaderFieldValue(headerFieldProxy);
    8988    if (cookieDataString.isEmpty())
    9089        return std::pair<Vector<uint8_t>, bool> { { }, secureCookiesAccessed };

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

    r233222 r234376  
    3838#include <WebKitSystemInterface/WebKitSystemInterface.h>
    3939#endif
     40#if USE(CFURLCONNECTION)
     41#include "Cookie.h"
     42#include "CookieRequestHeaderFieldProxy.h"
     43#include "CookiesStrategy.h"
     44#include "NotImplemented.h"
     45#include "URL.h"
     46#include <CFNetwork/CFHTTPCookiesPriv.h>
     47#include <CoreFoundation/CoreFoundation.h>
     48#include <pal/spi/cf/CFNetworkSPI.h>
     49#include <windows.h>
     50#include <wtf/SoftLinking.h>
     51#include <wtf/cf/TypeCastsCF.h>
     52#include <wtf/text/WTFString.h>
     53
     54enum {
     55    CFHTTPCookieStorageAcceptPolicyExclusivelyFromMainDocumentDomain = 3
     56};
     57
     58namespace WTF {
     59
     60#define DECLARE_CF_TYPE_TRAIT(ClassName) \
     61template <> \
     62struct CFTypeTrait<ClassName##Ref> { \
     63static inline CFTypeID typeID() { return ClassName##GetTypeID(); } \
     64};
     65
     66#if COMPILER(CLANG)
     67#pragma clang diagnostic push
     68#pragma clang diagnostic ignored "-Wdeprecated-declarations"
     69#endif
     70DECLARE_CF_TYPE_TRAIT(CFHTTPCookie);
     71#if COMPILER(CLANG)
     72#pragma clang diagnostic pop
     73#endif
     74
     75#undef DECLARE_CF_TYPE_TRAIT
     76} // namespace WTF
     77
     78#endif
    4079
    4180namespace WebCore {
    … …  
    403442#endif
    404443
    405 }
     444} // namespace WebCore
     445
     446#if USE(CFURLCONNECTION)
     447
     448namespace WebCore {
     449
     450static const CFStringRef s_setCookieKeyCF = CFSTR("Set-Cookie");
     451static const CFStringRef s_cookieCF = CFSTR("Cookie");
     452static const CFStringRef s_createdCF = CFSTR("Created");
     453
     454static inline RetainPtr<CFStringRef> cookieDomain(CFHTTPCookieRef cookie)
     455{
     456    return adoptCF(CFHTTPCookieCopyDomain(cookie));
     457}
     458
     459static double canonicalCookieTime(double time)
     460{
     461    if (!time)
     462        return time;
     463
     464    return (time + kCFAbsoluteTimeIntervalSince1970) * 1000;
     465}
     466
     467static double cookieCreatedTime(CFHTTPCookieRef cookie)
     468{
     469    RetainPtr<CFDictionaryRef> props = adoptCF(CFHTTPCookieCopyProperties(cookie));
     470    auto value = CFDictionaryGetValue(props.get(), s_createdCF);
     471
     472    auto asNumber = dynamic_cf_cast<CFNumberRef>(value);
     473    if (asNumber) {
     474        double asDouble;
     475        if (CFNumberGetValue(asNumber, kCFNumberFloat64Type, &asDouble))
     476            return canonicalCookieTime(asDouble);
     477        return 0.0;
     478    }
     479
     480    auto asString = dynamic_cf_cast<CFStringRef>(value);
     481    if (asString)
     482        return canonicalCookieTime(CFStringGetDoubleValue(asString));
     483
     484    return 0.0;
     485}
     486
     487static inline CFAbsoluteTime cookieExpirationTime(CFHTTPCookieRef cookie)
     488{
     489    return canonicalCookieTime(CFHTTPCookieGetExpirationTime(cookie));
     490}
     491
     492static inline RetainPtr<CFStringRef> cookieName(CFHTTPCookieRef cookie)
     493{
     494    return adoptCF(CFHTTPCookieCopyName(cookie));
     495}
     496
     497static inline RetainPtr<CFStringRef> cookiePath(CFHTTPCookieRef cookie)
     498{
     499    return adoptCF(CFHTTPCookieCopyPath(cookie));
     500}
     501
     502static inline RetainPtr<CFStringRef> cookieValue(CFHTTPCookieRef cookie)
     503{
     504    return adoptCF(CFHTTPCookieCopyValue(cookie));
     505}
     506
     507static RetainPtr<CFArrayRef> filterCookies(CFArrayRef unfilteredCookies)
     508{
     509    ASSERT(unfilteredCookies);
     510    CFIndex count = CFArrayGetCount(unfilteredCookies);
     511    RetainPtr<CFMutableArrayRef> filteredCookies = adoptCF(CFArrayCreateMutable(0, count, &kCFTypeArrayCallBacks));
     512    for (CFIndex i = 0; i < count; ++i) {
     513        CFHTTPCookieRef cookie = (CFHTTPCookieRef)CFArrayGetValueAtIndex(unfilteredCookies, i);
     514
     515        // <rdar://problem/5632883> CFHTTPCookieStorage would store an empty cookie,
     516        // which would be sent as "Cookie: =". We have a workaround in setCookies() to prevent
     517        // that, but we also need to avoid sending cookies that were previously stored, and
     518        // there's no harm to doing this check because such a cookie is never valid.
     519        if (!CFStringGetLength(cookieName(cookie).get()))
     520            continue;
     521
     522        if (CFHTTPCookieIsHTTPOnly(cookie))
     523            continue;
     524
     525        CFArrayAppendValue(filteredCookies.get(), cookie);
     526    }
     527    return filteredCookies;
     528}
     529
     530static RetainPtr<CFArrayRef> copyCookiesForURLWithFirstPartyURL(const NetworkStorageSession& session, const URL& firstParty, const URL& url, IncludeSecureCookies includeSecureCookies)
     531{
     532    bool secure = includeSecureCookies == IncludeSecureCookies::Yes;
     533
     534    ASSERT(!secure || (secure && url.protocolIs("https")));
     535
     536    UNUSED_PARAM(firstParty);
     537    return adoptCF(CFHTTPCookieStorageCopyCookiesForURL(session.cookieStorage().get(), url.createCFURL().get(), secure));
     538}
     539
     540static CFArrayRef createCookies(CFDictionaryRef headerFields, CFURLRef url)
     541{
     542    CFArrayRef parsedCookies = CFHTTPCookieCreateWithResponseHeaderFields(kCFAllocatorDefault, headerFields, url);
     543    if (!parsedCookies)
     544        parsedCookies = CFArrayCreate(kCFAllocatorDefault, 0, 0, &kCFTypeArrayCallBacks);
     545
     546    return parsedCookies;
     547}
     548
     549void NetworkStorageSession::setCookiesFromDOM(const URL& firstParty, const SameSiteInfo&, const URL& url, std::optional<uint64_t> frameID, std::optional<uint64_t> pageID, const String& value) const
     550{
     551    UNUSED_PARAM(frameID);
     552    UNUSED_PARAM(pageID);
     553    // <rdar://problem/5632883> CFHTTPCookieStorage stores an empty cookie, which would be sent as "Cookie: =".
     554    if (value.isEmpty())
     555        return;
     556
     557    RetainPtr<CFURLRef> urlCF = url.createCFURL();
     558    RetainPtr<CFURLRef> firstPartyForCookiesCF = firstParty.createCFURL();
     559
     560    // <http://bugs.webkit.org/show_bug.cgi?id=6531>, <rdar://4409034>
     561    // cookiesWithResponseHeaderFields doesn't parse cookies without a value
     562    String cookieString = value.contains('=') ? value : value + "=";
     563
     564    RetainPtr<CFStringRef> cookieStringCF = cookieString.createCFString();
     565    auto cookieStringCFPtr = cookieStringCF.get();
     566    RetainPtr<CFDictionaryRef> headerFieldsCF = adoptCF(CFDictionaryCreate(kCFAllocatorDefault,
     567        (const void**)&s_setCookieKeyCF, (const void**)&cookieStringCFPtr, 1,
     568        &kCFTypeDictionaryKeyCallBacks, &kCFTypeDictionaryValueCallBacks));
     569
     570    RetainPtr<CFArrayRef> unfilteredCookies = adoptCF(createCookies(headerFieldsCF.get(), urlCF.get()));
     571    CFHTTPCookieStorageSetCookies(cookieStorage().get(), filterCookies(unfilteredCookies.get()).get(), urlCF.get(), firstPartyForCookiesCF.get());
     572}
     573
     574static bool containsSecureCookies(CFArrayRef cookies)
     575{
     576    CFIndex cookieCount = CFArrayGetCount(cookies);
     577    while (cookieCount--) {
     578        if (CFHTTPCookieIsSecure(checked_cf_cast<CFHTTPCookieRef>(CFArrayGetValueAtIndex(cookies, cookieCount))))
     579            return true;
     580    }
     581
     582    return false;
     583}
     584
     585std::pair<String, bool> NetworkStorageSession::cookiesForDOM(const URL& firstParty, const SameSiteInfo&, const URL& url, std::optional<uint64_t> frameID, std::optional<uint64_t> pageID, IncludeSecureCookies includeSecureCookies) const
     586{
     587    UNUSED_PARAM(frameID);
     588    UNUSED_PARAM(pageID);
     589    RetainPtr<CFArrayRef> cookiesCF = copyCookiesForURLWithFirstPartyURL(*this, firstParty, url, includeSecureCookies);
     590
     591    auto filteredCookies = filterCookies(cookiesCF.get());
     592
     593    bool didAccessSecureCookies = containsSecureCookies(filteredCookies.get());
     594
     595    RetainPtr<CFDictionaryRef> headerCF = adoptCF(CFHTTPCookieCopyRequestHeaderFields(kCFAllocatorDefault, filteredCookies.get()));
     596    String cookieString = checked_cf_cast<CFStringRef>(CFDictionaryGetValue(headerCF.get(), s_cookieCF));
     597    return { cookieString, didAccessSecureCookies };
     598}
     599
     600std::pair<String, bool> NetworkStorageSession::cookieRequestHeaderFieldValue(const URL& firstParty, const SameSiteInfo&, const URL& url, std::optional<uint64_t> frameID, std::optional<uint64_t> pageID, IncludeSecureCookies includeSecureCookies) const
     601{
     602    UNUSED_PARAM(frameID);
     603    UNUSED_PARAM(pageID);
     604    RetainPtr<CFArrayRef> cookiesCF = copyCookiesForURLWithFirstPartyURL(*this, firstParty, url, includeSecureCookies);
     605
     606    bool didAccessSecureCookies = containsSecureCookies(cookiesCF.get());
     607
     608    RetainPtr<CFDictionaryRef> headerCF = adoptCF(CFHTTPCookieCopyRequestHeaderFields(kCFAllocatorDefault, cookiesCF.get()));
     609    String cookieString = checked_cf_cast<CFStringRef>(CFDictionaryGetValue(headerCF.get(), s_cookieCF));
     610    return { cookieString, didAccessSecureCookies };
     611}
     612
     613std::pair<String, bool> NetworkStorageSession::cookieRequestHeaderFieldValue(const CookieRequestHeaderFieldProxy& headerFieldProxy) const
     614{
     615    return cookieRequestHeaderFieldValue(headerFieldProxy.firstParty, headerFieldProxy.sameSiteInfo, headerFieldProxy.url, headerFieldProxy.frameID, headerFieldProxy.pageID, headerFieldProxy.includeSecureCookies);
     616}
     617
     618bool NetworkStorageSession::cookiesEnabled() const
     619{
     620    CFHTTPCookieStorageAcceptPolicy policy = CFHTTPCookieStorageGetCookieAcceptPolicy(cookieStorage().get());
     621    return policy == CFHTTPCookieStorageAcceptPolicyOnlyFromMainDocumentDomain || policy == CFHTTPCookieStorageAcceptPolicyExclusivelyFromMainDocumentDomain || policy == CFHTTPCookieStorageAcceptPolicyAlways;
     622}
     623
     624bool NetworkStorageSession::getRawCookies(const URL& firstParty, const SameSiteInfo&, const URL& url, std::optional<uint64_t> frameID, std::optional<uint64_t> pageID, Vector<Cookie>& rawCookies) const
     625{
     626    UNUSED_PARAM(frameID);
     627    UNUSED_PARAM(pageID);
     628    rawCookies.clear();
     629
     630    auto includeSecureCookies = url.protocolIs("https") ? IncludeSecureCookies::Yes : IncludeSecureCookies::No;
     631
     632    RetainPtr<CFArrayRef> cookiesCF = copyCookiesForURLWithFirstPartyURL(*this, firstParty, url, includeSecureCookies);
     633
     634    CFIndex count = CFArrayGetCount(cookiesCF.get());
     635    rawCookies.reserveCapacity(count);
     636
     637    for (CFIndex i = 0; i < count; i++) {
     638        CFHTTPCookieRef cfCookie = checked_cf_cast<CFHTTPCookieRef>(CFArrayGetValueAtIndex(cookiesCF.get(), i));
     639        Cookie cookie;
     640        cookie.name = cookieName(cfCookie).get();
     641        cookie.value = cookieValue(cfCookie).get();
     642        cookie.domain = cookieDomain(cfCookie).get();
     643        cookie.path = cookiePath(cfCookie).get();
     644        cookie.created = cookieCreatedTime(cfCookie);
     645        cookie.expires = cookieExpirationTime(cfCookie);
     646        cookie.httpOnly = CFHTTPCookieIsHTTPOnly(cfCookie);
     647        cookie.secure = CFHTTPCookieIsSecure(cfCookie);
     648        cookie.session = false; // FIXME: Need API for if a cookie is a session cookie.
     649        rawCookies.uncheckedAppend(WTFMove(cookie));
     650    }
     651
     652    return true;
     653}
     654
     655void NetworkStorageSession::deleteCookie(const URL& url, const String& name) const
     656{
     657    RetainPtr<CFHTTPCookieStorageRef> cookieStorage = this->cookieStorage();
     658
     659    RetainPtr<CFURLRef> urlCF = url.createCFURL();
     660
     661    bool sendSecureCookies = url.protocolIs("https");
     662    RetainPtr<CFArrayRef> cookiesCF = adoptCF(CFHTTPCookieStorageCopyCookiesForURL(cookieStorage.get(), urlCF.get(), sendSecureCookies));
     663
     664    CFIndex count = CFArrayGetCount(cookiesCF.get());
     665    for (CFIndex i = 0; i < count; i++) {
     666        CFHTTPCookieRef cookie = checked_cf_cast<CFHTTPCookieRef>(CFArrayGetValueAtIndex(cookiesCF.get(), i));
     667        if (String(cookieName(cookie).get()) == name) {
     668            CFHTTPCookieStorageDeleteCookie(cookieStorage.get(), cookie);
     669            break;
     670        }
     671    }
     672}
     673
     674void NetworkStorageSession::getHostnamesWithCookies(HashSet<String>& hostnames)
     675{
     676    RetainPtr<CFArrayRef> cookiesCF = adoptCF(CFHTTPCookieStorageCopyCookies(cookieStorage().get()));
     677    if (!cookiesCF)
     678        return;
     679
     680    CFIndex count = CFArrayGetCount(cookiesCF.get());
     681    for (CFIndex i = 0; i < count; ++i) {
     682        CFHTTPCookieRef cookie = checked_cf_cast<CFHTTPCookieRef>(CFArrayGetValueAtIndex(cookiesCF.get(), i));
     683        RetainPtr<CFStringRef> domain = cookieDomain(cookie);
     684        hostnames.add(domain.get());
     685    }
     686}
     687
     688void NetworkStorageSession::deleteAllCookies()
     689{
     690    CFHTTPCookieStorageDeleteAllCookies(cookieStorage().get());
     691}
     692
     693void NetworkStorageSession::deleteCookiesForHostnames(const Vector<String>& hostnames)
     694{
     695}
     696
     697void NetworkStorageSession::deleteAllCookiesModifiedSince(WallTime)
     698{
     699}
     700
     701} // namespace WebCore
     702
     703#endif // USE(CFURLCONNECTION)

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

    r231146 r234376  
    2828
    2929#import "Cookie.h"
     30#import "CookieRequestHeaderFieldProxy.h"
    3031#import "CookieStorageObserver.h"
     32#import "CookiesStrategy.h"
     33#import "SameSiteInfo.h"
    3134#import "URL.h"
    3235#import <pal/spi/cf/CFNetworkSPI.h>
    3336#import <wtf/BlockObjCExceptions.h>
     37#import <wtf/Optional.h>
    3438#import <wtf/ProcessPrivilege.h>
     39#import <wtf/text/StringBuilder.h>
     40
     41@interface NSURL ()
     42- (CFURLRef)_cfurl;
     43@end
     44
     45#if (PLATFORM(MAC) && __MAC_OS_X_VERSION_MIN_REQUIRED >= 101400) || (PLATFORM(IOS) && __IPHONE_OS_VERSION_MIN_REQUIRED >= 120000)
     46@interface NSHTTPCookieStorage (Staging)
     47- (void)_getCookiesForURL:(NSURL *)url mainDocumentURL:(NSURL *)mainDocumentURL partition:(NSString *)partition policyProperties:(NSDictionary*)props completionHandler:(void (^)(NSArray *))completionHandler;
     48- (void)_setCookies:(NSArray *)cookies forURL:(NSURL *)URL mainDocumentURL:(NSURL *)mainDocumentURL policyProperties:(NSDictionary*) props;
     49@end
     50#endif
    3551
    3652namespace WebCore {
    … …  
    151167}
    152168
     169static NSArray *httpCookies(CFHTTPCookieStorageRef cookieStorage)
     170{
     171    ASSERT(hasProcessPrivilege(ProcessPrivilege::CanAccessRawCookies));
     172    if (!cookieStorage)
     173        return [[NSHTTPCookieStorage sharedHTTPCookieStorage] cookies];
     174   
     175    auto cookies = adoptCF(CFHTTPCookieStorageCopyCookies(cookieStorage));
     176    return [NSHTTPCookie _cf2nsCookies:cookies.get()];
     177}
     178
     179static void deleteHTTPCookie(CFHTTPCookieStorageRef cookieStorage, NSHTTPCookie *cookie)
     180{
     181    ASSERT(hasProcessPrivilege(ProcessPrivilege::CanAccessRawCookies));
     182    if (!cookieStorage) {
     183        [[NSHTTPCookieStorage sharedHTTPCookieStorage] deleteCookie:cookie];
     184        return;
     185    }
     186   
     187    CFHTTPCookieStorageDeleteCookie(cookieStorage, [cookie _GetInternalCFHTTPCookie]);
     188}
     189
     190#if (PLATFORM(MAC) && __MAC_OS_X_VERSION_MIN_REQUIRED >= 101400) || (PLATFORM(IOS) && __IPHONE_OS_VERSION_MIN_REQUIRED >= 120000)
     191static RetainPtr<NSDictionary> policyProperties(const SameSiteInfo& sameSiteInfo, NSURL *url)
     192{
     193    static NSURL *emptyURL = [[NSURL alloc] initWithString:@""];
     194    NSDictionary *policyProperties = @{
     195        @"_kCFHTTPCookiePolicyPropertySiteForCookies": sameSiteInfo.isSameSite ? url : emptyURL,
     196        @"_kCFHTTPCookiePolicyPropertyIsTopLevelNavigation": [NSNumber numberWithBool:sameSiteInfo.isTopSite],
     197    };
     198    return policyProperties;
     199}
     200#endif
     201
     202static NSArray *cookiesForURL(NSHTTPCookieStorage *storage, NSURL *url, NSURL *mainDocumentURL, const std::optional<SameSiteInfo>& sameSiteInfo, NSString *partition = nullptr)
     203{
     204    // The _getCookiesForURL: method calls the completionHandler synchronously. We use std::optional<> to ensure this invariant.
     205    std::optional<RetainPtr<NSArray *>> cookiesPtr;
     206    auto completionHandler = [&cookiesPtr] (NSArray *cookies) {
     207        cookiesPtr = retainPtr(cookies);
     208    };
     209#if (PLATFORM(MAC) && __MAC_OS_X_VERSION_MIN_REQUIRED >= 101400) || (PLATFORM(IOS) && __IPHONE_OS_VERSION_MIN_REQUIRED >= 120000)
     210    if ([storage respondsToSelector:@selector(_getCookiesForURL:mainDocumentURL:partition:policyProperties:completionHandler:)])
     211        [storage _getCookiesForURL:url mainDocumentURL:mainDocumentURL partition:partition policyProperties:sameSiteInfo ? policyProperties(sameSiteInfo.value(), url).get() : nullptr completionHandler:completionHandler];
     212    else
     213        [storage _getCookiesForURL:url mainDocumentURL:mainDocumentURL partition:partition completionHandler:completionHandler];
     214#else
     215    [storage _getCookiesForURL:url mainDocumentURL:mainDocumentURL partition:partition completionHandler:completionHandler];
     216    UNUSED_PARAM(sameSiteInfo);
     217#endif
     218    ASSERT(!!cookiesPtr);
     219    return cookiesPtr->autorelease();
     220}
     221
     222static void setHTTPCookiesForURL(CFHTTPCookieStorageRef cookieStorage, NSArray *cookies, NSURL *url, NSURL *mainDocumentURL, const SameSiteInfo& sameSiteInfo)
     223{
     224    ASSERT(hasProcessPrivilege(ProcessPrivilege::CanAccessRawCookies));
     225    if (!cookieStorage) {
     226#if (PLATFORM(MAC) && __MAC_OS_X_VERSION_MIN_REQUIRED >= 101400) || (PLATFORM(IOS) && __IPHONE_OS_VERSION_MIN_REQUIRED >= 120000)
     227        if ([NSHTTPCookieStorage instancesRespondToSelector:@selector(_setCookies:forURL:mainDocumentURL:policyProperties:)])
     228            [[NSHTTPCookieStorage sharedHTTPCookieStorage] _setCookies:cookies forURL:url mainDocumentURL:mainDocumentURL policyProperties:policyProperties(sameSiteInfo, url).get()];
     229        else
     230#endif
     231            [[NSHTTPCookieStorage sharedHTTPCookieStorage] setCookies:cookies forURL:url mainDocumentURL:mainDocumentURL];
     232        return;
     233    }
     234#if (PLATFORM(MAC) && __MAC_OS_X_VERSION_MIN_REQUIRED >= 101400) || (PLATFORM(IOS) && __IPHONE_OS_VERSION_MIN_REQUIRED >= 120000)
     235    if ([NSHTTPCookieStorage instancesRespondToSelector:@selector(_setCookies:forURL:mainDocumentURL:policyProperties:)]) {
     236        // FIXME: Stop creating a new NSHTTPCookieStorage object each time we want to query the cookie jar.
     237        // NetworkStorageSession could instead keep a NSHTTPCookieStorage object for us.
     238        RetainPtr<NSHTTPCookieStorage> nsCookieStorage = adoptNS([[NSHTTPCookieStorage alloc] _initWithCFHTTPCookieStorage:cookieStorage]);
     239        [nsCookieStorage _setCookies:cookies forURL:url mainDocumentURL:mainDocumentURL policyProperties:policyProperties(sameSiteInfo, url).get()];
     240    } else {
     241#endif
     242        auto cfCookies = adoptCF([NSHTTPCookie _ns2cfCookies:cookies]);
     243        CFHTTPCookieStorageSetCookies(cookieStorage, cfCookies.get(), [url _cfurl], [mainDocumentURL _cfurl]);
     244#if (PLATFORM(MAC) && __MAC_OS_X_VERSION_MIN_REQUIRED >= 101400) || (PLATFORM(IOS) && __IPHONE_OS_VERSION_MIN_REQUIRED >= 120000)
     245    }
     246#else
     247    UNUSED_PARAM(sameSiteInfo);
     248#endif
     249}
     250
     251static NSArray *httpCookiesForURL(CFHTTPCookieStorageRef cookieStorage, NSURL *firstParty, const std::optional<SameSiteInfo>& sameSiteInfo, NSURL *url)
     252{
     253    ASSERT(hasProcessPrivilege(ProcessPrivilege::CanAccessRawCookies));
     254    if (!cookieStorage)
     255        cookieStorage = _CFHTTPCookieStorageGetDefault(kCFAllocatorDefault);
     256
     257    // FIXME: Stop creating a new NSHTTPCookieStorage object each time we want to query the cookie jar.
     258    // NetworkStorageSession could instead keep a NSHTTPCookieStorage object for us.
     259    RetainPtr<NSHTTPCookieStorage> nsCookieStorage = adoptNS([[NSHTTPCookieStorage alloc] _initWithCFHTTPCookieStorage:cookieStorage]);
     260    return cookiesForURL(nsCookieStorage.get(), url, firstParty, sameSiteInfo);
     261}
     262
     263static RetainPtr<NSArray> filterCookies(NSArray *unfilteredCookies)
     264{
     265    ASSERT(hasProcessPrivilege(ProcessPrivilege::CanAccessRawCookies));
     266    NSUInteger count = [unfilteredCookies count];
     267    RetainPtr<NSMutableArray> filteredCookies = adoptNS([[NSMutableArray alloc] initWithCapacity:count]);
     268
     269    for (NSUInteger i = 0; i < count; ++i) {
     270        NSHTTPCookie *cookie = (NSHTTPCookie *)[unfilteredCookies objectAtIndex:i];
     271
     272        // <rdar://problem/5632883> On 10.5, NSHTTPCookieStorage would store an empty cookie,
     273        // which would be sent as "Cookie: =". We have a workaround in setCookies() to prevent
     274        // that, but we also need to avoid sending cookies that were previously stored, and
     275        // there's no harm to doing this check because such a cookie is never valid.
     276        if (![[cookie name] length])
     277            continue;
     278
     279        if ([cookie isHTTPOnly])
     280            continue;
     281
     282        [filteredCookies.get() addObject:cookie];
     283    }
     284
     285    return filteredCookies;
     286}
     287
     288#if HAVE(CFNETWORK_STORAGE_PARTITIONING)
     289
     290static NSArray *applyPartitionToCookies(NSString *partition, NSArray *cookies)
     291{
     292    ASSERT(hasProcessPrivilege(ProcessPrivilege::CanAccessRawCookies));
     293
     294    // FIXME 24747739: CFNetwork should expose this key as SPI
     295    static NSString * const partitionKey = @"StoragePartition";
     296
     297    NSMutableArray *partitionedCookies = [NSMutableArray arrayWithCapacity:cookies.count];
     298    for (NSHTTPCookie *cookie in cookies) {
     299        RetainPtr<NSMutableDictionary> properties = adoptNS([cookie.properties mutableCopy]);
     300        [properties setObject:partition forKey:partitionKey];
     301        [partitionedCookies addObject:[NSHTTPCookie cookieWithProperties:properties.get()]];
     302    }
     303
     304    return partitionedCookies;
     305}
     306
     307static bool cookiesAreBlockedForURL(const NetworkStorageSession& session, const URL& firstParty, const URL& url)
     308{
     309    return session.shouldBlockCookies(firstParty, url);
     310}
     311
     312static NSArray *cookiesInPartitionForURL(const NetworkStorageSession& session, const URL& firstParty, const SameSiteInfo& sameSiteInfo, const URL& url, std::optional<uint64_t> frameID, std::optional<uint64_t> pageID)
     313{
     314    ASSERT(hasProcessPrivilege(ProcessPrivilege::CanAccessRawCookies));
     315    String partition = session.cookieStoragePartition(firstParty, url, frameID, pageID);
     316    if (partition.isEmpty())
     317        return nil;
     318
     319    // FIXME: Stop creating a new NSHTTPCookieStorage object each time we want to query the cookie jar.
     320    // NetworkStorageSession could instead keep a NSHTTPCookieStorage object for us.
     321    RetainPtr<NSHTTPCookieStorage> cookieStorage;
     322    if (auto storage = session.cookieStorage())
     323        cookieStorage = adoptNS([[NSHTTPCookieStorage alloc] _initWithCFHTTPCookieStorage:storage.get()]);
     324    else
     325        cookieStorage = [NSHTTPCookieStorage sharedHTTPCookieStorage];
     326    return cookiesForURL(cookieStorage.get(), url, firstParty, sameSiteInfo, partition);
     327}
     328
     329#endif // HAVE(CFNETWORK_STORAGE_PARTITIONING)
     330   
     331static NSArray *cookiesForURL(const NetworkStorageSession& session, const URL& firstParty, const SameSiteInfo& sameSiteInfo, const URL& url, std::optional<uint64_t> frameID, std::optional<uint64_t> pageID)
     332{
     333#if HAVE(CFNETWORK_STORAGE_PARTITIONING)
     334    if (cookiesAreBlockedForURL(session, firstParty, url))
     335        return nil;
     336   
     337    if (NSArray *cookies = cookiesInPartitionForURL(session, firstParty, sameSiteInfo, url, frameID, pageID))
     338        return cookies;
     339#else
     340    UNUSED_PARAM(frameID);
     341    UNUSED_PARAM(pageID);
     342#endif
     343    return httpCookiesForURL(session.cookieStorage().get(), firstParty, sameSiteInfo, url);
     344}
     345
     346enum IncludeHTTPOnlyOrNot { DoNotIncludeHTTPOnly, IncludeHTTPOnly };
     347static std::pair<String, bool> cookiesForSession(const NetworkStorageSession& session, const URL& firstParty, const SameSiteInfo& sameSiteInfo, const URL& url, std::optional<uint64_t> frameID, std::optional<uint64_t> pageID, IncludeHTTPOnlyOrNot includeHTTPOnly, IncludeSecureCookies includeSecureCookies)
     348{
     349    ASSERT(hasProcessPrivilege(ProcessPrivilege::CanAccessRawCookies));
     350
     351    BEGIN_BLOCK_OBJC_EXCEPTIONS;
     352
     353    NSArray *cookies = cookiesForURL(session, firstParty, sameSiteInfo, url, frameID, pageID);
     354    if (![cookies count])
     355        return { String(), false }; // Return a null string, not an empty one that StringBuilder would create below.
     356
     357    StringBuilder cookiesBuilder;
     358    bool didAccessSecureCookies = false;
     359    for (NSHTTPCookie *cookie in cookies) {
     360        if (![[cookie name] length])
     361            continue;
     362
     363        if (!includeHTTPOnly && [cookie isHTTPOnly])
     364            continue;
     365
     366        if ([cookie isSecure]) {
     367            didAccessSecureCookies = true;
     368            if (includeSecureCookies == IncludeSecureCookies::No)
     369                continue;
     370        }
     371
     372        if (!cookiesBuilder.isEmpty())
     373            cookiesBuilder.appendLiteral("; ");
     374
     375        cookiesBuilder.append([cookie name]);
     376        cookiesBuilder.append('=');
     377        cookiesBuilder.append([cookie value]);
     378    }
     379    return { cookiesBuilder.toString(), didAccessSecureCookies };
     380
     381    END_BLOCK_OBJC_EXCEPTIONS;
     382    return { String(), false };
     383}
     384
     385static void deleteAllHTTPCookies(CFHTTPCookieStorageRef cookieStorage)
     386{
     387    ASSERT(hasProcessPrivilege(ProcessPrivilege::CanAccessRawCookies));
     388
     389    if (!cookieStorage) {
     390        NSHTTPCookieStorage *cookieStorage = [NSHTTPCookieStorage sharedHTTPCookieStorage];
     391        NSArray *cookies = [cookieStorage cookies];
     392        if (!cookies)
     393            return;
     394
     395        for (NSHTTPCookie *cookie in cookies)
     396            [cookieStorage deleteCookie:cookie];
     397        return;
     398    }
     399
     400    CFHTTPCookieStorageDeleteAllCookies(cookieStorage);
     401}
     402
     403std::pair<String, bool> NetworkStorageSession::cookiesForDOM(const URL& firstParty, const SameSiteInfo& sameSiteInfo, const URL& url, std::optional<uint64_t> frameID, std::optional<uint64_t> pageID, IncludeSecureCookies includeSecureCookies) const
     404{
     405    return cookiesForSession(*this, firstParty, sameSiteInfo, url, frameID, pageID, DoNotIncludeHTTPOnly, includeSecureCookies);
     406}
     407
     408std::pair<String, bool> NetworkStorageSession::cookieRequestHeaderFieldValue(const URL& firstParty, const SameSiteInfo& sameSiteInfo, const URL& url, std::optional<uint64_t> frameID, std::optional<uint64_t> pageID, IncludeSecureCookies includeSecureCookies) const
     409{
     410    return cookiesForSession(*this, firstParty, sameSiteInfo, url, frameID, pageID, IncludeHTTPOnly, includeSecureCookies);
     411}
     412
     413std::pair<String, bool> NetworkStorageSession::cookieRequestHeaderFieldValue(const CookieRequestHeaderFieldProxy& headerFieldProxy) const
     414{
     415    return cookiesForSession(*this, headerFieldProxy.firstParty, headerFieldProxy.sameSiteInfo, headerFieldProxy.url, headerFieldProxy.frameID, headerFieldProxy.pageID, IncludeHTTPOnly, headerFieldProxy.includeSecureCookies);
     416}
     417
     418void NetworkStorageSession::setCookiesFromDOM(const URL& firstParty, const SameSiteInfo& sameSiteInfo, const URL& url, std::optional<uint64_t> frameID, std::optional<uint64_t> pageID, const String& cookieStr) const
     419{
     420    ASSERT(hasProcessPrivilege(ProcessPrivilege::CanAccessRawCookies));
     421
     422    BEGIN_BLOCK_OBJC_EXCEPTIONS;
     423
     424    // <rdar://problem/5632883> On 10.5, NSHTTPCookieStorage would store an empty cookie,
     425    // which would be sent as "Cookie: =".
     426    if (cookieStr.isEmpty())
     427        return;
     428
     429    // <http://bugs.webkit.org/show_bug.cgi?id=6531>, <rdar://4409034>
     430    // cookiesWithResponseHeaderFields doesn't parse cookies without a value
     431    String cookieString = cookieStr.contains('=') ? cookieStr : cookieStr + "=";
     432
     433    NSURL *cookieURL = url;
     434    NSDictionary *headerFields = [NSDictionary dictionaryWithObject:cookieString forKey:@"Set-Cookie"];
     435
     436#if PLATFORM(MAC)
     437    NSArray *unfilteredCookies = [NSHTTPCookie _parsedCookiesWithResponseHeaderFields:headerFields forURL:cookieURL];
     438#else
     439    NSArray *unfilteredCookies = [NSHTTPCookie cookiesWithResponseHeaderFields:headerFields forURL:cookieURL];
     440#endif
     441
     442    RetainPtr<NSArray> filteredCookies = filterCookies(unfilteredCookies);
     443    ASSERT([filteredCookies.get() count] <= 1);
     444
     445#if HAVE(CFNETWORK_STORAGE_PARTITIONING)
     446    if (shouldBlockCookies(firstParty, url))
     447        return;
     448
     449    String partition = cookieStoragePartition(firstParty, url, frameID, pageID);
     450    if (!partition.isEmpty())
     451        filteredCookies = applyPartitionToCookies(partition, filteredCookies.get());
     452#else
     453    UNUSED_PARAM(frameID);
     454    UNUSED_PARAM(pageID);
     455#endif
     456
     457    setHTTPCookiesForURL(cookieStorage().get(), filteredCookies.get(), cookieURL, firstParty, sameSiteInfo);
     458
     459    END_BLOCK_OBJC_EXCEPTIONS;
     460}
     461
     462static NSHTTPCookieAcceptPolicy httpCookieAcceptPolicy(CFHTTPCookieStorageRef cookieStorage)
     463{
     464    ASSERT(hasProcessPrivilege(ProcessPrivilege::CanAccessRawCookies));
     465
     466    if (!cookieStorage)
     467        return [[NSHTTPCookieStorage sharedHTTPCookieStorage] cookieAcceptPolicy];
     468
     469    return static_cast<NSHTTPCookieAcceptPolicy>(CFHTTPCookieStorageGetCookieAcceptPolicy(cookieStorage));
     470}
     471
     472bool NetworkStorageSession::cookiesEnabled() const
     473{
     474    BEGIN_BLOCK_OBJC_EXCEPTIONS;
     475
     476    NSHTTPCookieAcceptPolicy cookieAcceptPolicy = httpCookieAcceptPolicy(cookieStorage().get());
     477    return cookieAcceptPolicy == NSHTTPCookieAcceptPolicyAlways || cookieAcceptPolicy == NSHTTPCookieAcceptPolicyOnlyFromMainDocumentDomain || cookieAcceptPolicy == NSHTTPCookieAcceptPolicyExclusivelyFromMainDocumentDomain;
     478
     479    END_BLOCK_OBJC_EXCEPTIONS;
     480    return false;
     481}
     482
     483bool NetworkStorageSession::getRawCookies(const URL& firstParty, const SameSiteInfo& sameSiteInfo, const URL& url, std::optional<uint64_t> frameID, std::optional<uint64_t> pageID, Vector<Cookie>& rawCookies) const
     484{
     485    rawCookies.clear();
     486    BEGIN_BLOCK_OBJC_EXCEPTIONS;
     487
     488    NSArray *cookies = cookiesForURL(*this, firstParty, sameSiteInfo, url, frameID, pageID);
     489    NSUInteger count = [cookies count];
     490    rawCookies.reserveCapacity(count);
     491    for (NSUInteger i = 0; i < count; ++i) {
     492        NSHTTPCookie *cookie = (NSHTTPCookie *)[cookies objectAtIndex:i];
     493        rawCookies.uncheckedAppend({ cookie });
     494    }
     495
     496    END_BLOCK_OBJC_EXCEPTIONS;
     497    return true;
     498}
     499
     500void NetworkStorageSession::deleteCookie(const URL& url, const String& cookieName) const
     501{
     502    ASSERT(hasProcessPrivilege(ProcessPrivilege::CanAccessRawCookies));
     503
     504    BEGIN_BLOCK_OBJC_EXCEPTIONS;
     505
     506    RetainPtr<CFHTTPCookieStorageRef> cookieStorage = this->cookieStorage();
     507    NSArray *cookies = httpCookiesForURL(cookieStorage.get(), nil, std::nullopt, url);
     508
     509    NSString *cookieNameString = cookieName;
     510
     511    NSUInteger count = [cookies count];
     512    for (NSUInteger i = 0; i < count; ++i) {
     513        NSHTTPCookie *cookie = (NSHTTPCookie *)[cookies objectAtIndex:i];
     514        if ([[cookie name] isEqualToString:cookieNameString])
     515            deleteHTTPCookie(cookieStorage.get(), cookie);
     516    }
     517
     518    END_BLOCK_OBJC_EXCEPTIONS;
     519}
     520
     521void NetworkStorageSession::getHostnamesWithCookies(HashSet<String>& hostnames)
     522{
     523    BEGIN_BLOCK_OBJC_EXCEPTIONS;
     524
     525    NSArray *cookies = httpCookies(cookieStorage().get());
     526   
     527    for (NSHTTPCookie* cookie in cookies)
     528        hostnames.add([cookie domain]);
     529   
     530    END_BLOCK_OBJC_EXCEPTIONS;
     531}
     532
     533void NetworkStorageSession::deleteAllCookies()
     534{
     535    deleteAllHTTPCookies(cookieStorage().get());
     536}
     537
     538void NetworkStorageSession::deleteCookiesForHostnames(const Vector<String>& hostnames)
     539{
     540    ASSERT(hasProcessPrivilege(ProcessPrivilege::CanAccessRawCookies));
     541
     542    BEGIN_BLOCK_OBJC_EXCEPTIONS;
     543
     544    RetainPtr<CFHTTPCookieStorageRef> cookieStorage = this->cookieStorage();
     545    NSArray *cookies = httpCookies(cookieStorage.get());
     546    if (!cookies)
     547        return;
     548
     549    HashMap<String, Vector<RetainPtr<NSHTTPCookie>>> cookiesByDomain;
     550    for (NSHTTPCookie* cookie in cookies) {
     551        auto& cookies = cookiesByDomain.add(cookie.domain, Vector<RetainPtr<NSHTTPCookie>>()).iterator->value;
     552        cookies.append(cookie);
     553    }
     554
     555    for (const auto& hostname : hostnames) {
     556        auto it = cookiesByDomain.find(hostname);
     557        if (it == cookiesByDomain.end())
     558            continue;
     559
     560        for (auto& cookie : it->value)
     561            deleteHTTPCookie(cookieStorage.get(), cookie.get());
     562    }
     563
     564    [nsCookieStorage() _saveCookies];
     565
     566    END_BLOCK_OBJC_EXCEPTIONS;
     567}
     568
     569void NetworkStorageSession::deleteAllCookiesModifiedSince(WallTime timePoint)
     570{
     571    ASSERT(hasProcessPrivilege(ProcessPrivilege::CanAccessRawCookies));
     572
     573    if (![NSHTTPCookieStorage instancesRespondToSelector:@selector(removeCookiesSinceDate:)])
     574        return;
     575
     576    NSTimeInterval timeInterval = timePoint.secondsSinceEpoch().seconds();
     577    NSDate *date = [NSDate dateWithTimeIntervalSince1970:timeInterval];
     578
     579    auto *storage = nsCookieStorage();
     580
     581    [storage removeCookiesSinceDate:date];
     582    [storage _saveCookies];
     583}
     584
    153585} // namespace WebCore

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

    r230944 r234376  
    1919#pragma once
    2020
    21 #include "PlatformCookieJar.h"
     21#include <wtf/Forward.h>
     22#include <wtf/HashSet.h>
     23#include <wtf/WallTime.h>
     24#include <wtf/text/WTFString.h>
    2225
    2326namespace WebCore {
     27
     28class URL;
     29class NetworkStorageSession;
     30
     31struct Cookie;
     32struct CookieRequestHeaderFieldProxy;
     33struct SameSiteInfo;
     34
     35enum class IncludeSecureCookies;
    2436
    2537class CookieJarCurl {

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

    r228905 r234376  
    3232#include "CookieJarCurlDatabase.h"
    3333#include "CookieJarDB.h"
     34#include "CookieRequestHeaderFieldProxy.h"
    3435#include "CurlContext.h"
    3536#include "FileSystem.h"
    3637#include "NetworkingContext.h"
    3738#include "ResourceHandle.h"
     39#include "URL.h"
    3840
    3941#include <wtf/MainThread.h>
    4042#include <wtf/NeverDestroyed.h>
     43#include <wtf/text/WTFString.h>
    4144
    4245namespace WebCore {
    … …  
    104107}
    105108
     109void NetworkStorageSession::setCookiesFromDOM(const URL& firstParty, const SameSiteInfo& sameSiteInfo, const URL& url, std::optional<uint64_t> frameID, std::optional<uint64_t> pageID, const String& value) const
     110{
     111    cookieStorage().setCookiesFromDOM(*this, firstParty, sameSiteInfo, url, frameID, pageID, value);
     112}
     113
     114bool NetworkStorageSession::cookiesEnabled() const
     115{
     116    return cookieStorage().cookiesEnabled(*this);
     117}
     118
     119std::pair<String, bool> NetworkStorageSession::cookiesForDOM(const URL& firstParty, const SameSiteInfo& sameSiteInfo, const URL& url, std::optional<uint64_t> frameID, std::optional<uint64_t> pageID, IncludeSecureCookies includeSecureCookies) const
     120{
     121    return cookieStorage().cookiesForDOM(*this, firstParty, sameSiteInfo, url, frameID, pageID, includeSecureCookies);
     122}
     123
    106124void NetworkStorageSession::setCookies(const Vector<Cookie>&, const URL&, const URL&)
    107125{
    … …  
    119137}
    120138
     139void NetworkStorageSession::deleteCookie(const URL& url, const String& cookie) const
     140{
     141    cookieStorage().deleteCookie(*this, url, cookie);
     142}
     143
     144void NetworkStorageSession::deleteAllCookies()
     145{
     146    cookieStorage().deleteAllCookies(*this);
     147}
     148
     149void NetworkStorageSession::deleteAllCookiesModifiedSince(WallTime since)
     150{
     151    cookieStorage().deleteAllCookiesModifiedSince(*this, since);
     152}
     153
     154void NetworkStorageSession::deleteCookiesForHostnames(const Vector<String>& cookieHostNames)
     155{
     156    cookieStorage().deleteCookiesForHostnames(*this, cookieHostNames);
     157}
     158
    121159Vector<Cookie> NetworkStorageSession::getAllCookies()
    122160{
    123161    // FIXME: Implement for WebKit to use.
    124162    return { };
     163}
     164
     165void NetworkStorageSession::getHostnamesWithCookies(HashSet<String>& hostnames)
     166{
     167    cookieStorage().getHostnamesWithCookies(*this, hostnames);
    125168}
    126169
    … …  
    131174}
    132175
     176bool NetworkStorageSession::getRawCookies(const URL& firstParty, const SameSiteInfo& sameSiteInfo, const URL& url, std::optional<uint64_t> frameID, std::optional<uint64_t> pageID, Vector<Cookie>& rawCookies) const
     177{
     178    return cookieStorage().getRawCookies(*this, firstParty, sameSiteInfo, url, frameID, pageID, rawCookies);
     179}
     180
    133181void NetworkStorageSession::flushCookieStore()
    134182{
    … …  
    136184}
    137185
     186std::pair<String, bool> NetworkStorageSession::cookieRequestHeaderFieldValue(const URL& firstParty, const SameSiteInfo& sameSiteInfo, const URL& url, std::optional<uint64_t> frameID, std::optional<uint64_t> pageID, IncludeSecureCookies includeSecureCookies) const
     187{
     188    return cookieStorage().cookieRequestHeaderFieldValue(*this, firstParty, sameSiteInfo, url, frameID, pageID, includeSecureCookies);
     189}
     190
     191std::pair<String, bool> NetworkStorageSession::cookieRequestHeaderFieldValue(const CookieRequestHeaderFieldProxy& headerFieldProxy) const
     192{
     193    return cookieStorage().cookieRequestHeaderFieldValue(*this, headerFieldProxy.firstParty, headerFieldProxy.sameSiteInfo, headerFieldProxy.url, headerFieldProxy.frameID, headerFieldProxy.pageID, headerFieldProxy.includeSecureCookies);
     194}
     195
    138196} // namespace WebCore
    139197

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

    r233668 r234376  
    3030#import "AuthenticationMac.h"
    3131#import "Logging.h"
     32#import "NetworkingContext.h"
    3233#import "ResourceHandle.h"
    3334#import "ResourceHandleClient.h"

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

    r232118 r234376  
    3333
    3434#include "Cookie.h"
     35#include "CookieRequestHeaderFieldProxy.h"
    3536#include "GUniquePtrSoup.h"
    3637#include "ResourceHandle.h"
    … …  
    292293}
    293294
     295bool NetworkStorageSession::cookiesEnabled() const
     296{
     297    auto policy = soup_cookie_jar_get_accept_policy(cookieStorage());
     298    return policy == SOUP_COOKIE_JAR_ACCEPT_ALWAYS || policy == SOUP_COOKIE_JAR_ACCEPT_NO_THIRD_PARTY;
     299}
     300
     301static inline bool httpOnlyCookieExists(const GSList* cookies, const gchar* name, const gchar* path)
     302{
     303    for (const GSList* iter = cookies; iter; iter = g_slist_next(iter)) {
     304        SoupCookie* cookie = static_cast<SoupCookie*>(iter->data);
     305        if (!strcmp(soup_cookie_get_name(cookie), name)
     306            && !g_strcmp0(soup_cookie_get_path(cookie), path)) {
     307            if (soup_cookie_get_http_only(cookie))
     308                return true;
     309            break;
     310        }
     311    }
     312    return false;
     313}
     314
     315void NetworkStorageSession::setCookiesFromDOM(const URL& firstParty, const SameSiteInfo&, const URL& url, std::optional<uint64_t> frameID, std::optional<uint64_t> pageID, const String& value) const
     316{
     317    UNUSED_PARAM(frameID);
     318    UNUSED_PARAM(pageID);
     319    GUniquePtr<SoupURI> origin = url.createSoupURI();
     320    if (!origin)
     321        return;
     322
     323    GUniquePtr<SoupURI> firstPartyURI = firstParty.createSoupURI();
     324    if (!firstPartyURI)
     325        return;
     326
     327    // Get existing cookies for this origin.
     328    SoupCookieJar* jar = cookieStorage();
     329    GSList* existingCookies = soup_cookie_jar_get_cookie_list(jar, origin.get(), TRUE);
     330
     331    for (auto& cookieString : value.split('\n')) {
     332        GUniquePtr<SoupCookie> cookie(soup_cookie_parse(cookieString.utf8().data(), origin.get()));
     333
     334        if (!cookie)
     335            continue;
     336
     337        // Make sure the cookie is not httpOnly since such cookies should not be set from JavaScript.
     338        if (soup_cookie_get_http_only(cookie.get()))
     339            continue;
     340
     341        // Make sure we do not overwrite httpOnly cookies from JavaScript.
     342        if (httpOnlyCookieExists(existingCookies, soup_cookie_get_name(cookie.get()), soup_cookie_get_path(cookie.get())))
     343            continue;
     344
     345        soup_cookie_jar_add_cookie_with_first_party(jar, firstPartyURI.get(), cookie.release());
     346    }
     347
     348    soup_cookies_free(existingCookies);
     349}
     350
    294351void NetworkStorageSession::setCookies(const Vector<Cookie>& cookies, const URL&, const URL&)
    295352{
    … …  
    307364    GUniquePtr<SoupCookie> targetCookie(cookie.toSoupCookie());
    308365    soup_cookie_jar_delete_cookie(cookieStorage(), targetCookie.get());
     366}
     367
     368void NetworkStorageSession::deleteCookie(const URL& url, const String& name) const
     369{
     370    GUniquePtr<SoupURI> uri = url.createSoupURI();
     371    if (!uri)
     372        return;
     373
     374    SoupCookieJar* jar = cookieStorage();
     375    GUniquePtr<GSList> cookies(soup_cookie_jar_get_cookie_list(jar, uri.get(), TRUE));
     376    if (!cookies)
     377        return;
     378
     379    CString cookieName = name.utf8();
     380    bool wasDeleted = false;
     381    for (GSList* iter = cookies.get(); iter; iter = g_slist_next(iter)) {
     382        SoupCookie* cookie = static_cast<SoupCookie*>(iter->data);
     383        if (!wasDeleted && cookieName == cookie->name) {
     384            soup_cookie_jar_delete_cookie(jar, cookie);
     385            wasDeleted = true;
     386        }
     387        soup_cookie_free(cookie);
     388    }
     389}
     390
     391void NetworkStorageSession::deleteAllCookies()
     392{
     393    SoupCookieJar* cookieJar = cookieStorage();
     394    GUniquePtr<GSList> cookies(soup_cookie_jar_all_cookies(cookieJar));
     395    for (GSList* item = cookies.get(); item; item = g_slist_next(item)) {
     396        SoupCookie* cookie = static_cast<SoupCookie*>(item->data);
     397        soup_cookie_jar_delete_cookie(cookieJar, cookie);
     398        soup_cookie_free(cookie);
     399    }
     400}
     401
     402void NetworkStorageSession::deleteAllCookiesModifiedSince(WallTime timestamp)
     403{
     404    // FIXME: Add support for deleting cookies modified since the given timestamp. It should probably be added to libsoup.
     405    if (timestamp == WallTime::fromRawSeconds(0))
     406        deleteAllCookies();
     407    else
     408        g_warning("Deleting cookies modified since a given time span is not supported yet");
     409}
     410
     411void NetworkStorageSession::deleteCookiesForHostnames(const Vector<String>& hostnames)
     412{
     413    SoupCookieJar* cookieJar = cookieStorage();
     414
     415    for (const auto& hostname : hostnames) {
     416        CString hostNameString = hostname.utf8();
     417
     418        GUniquePtr<GSList> cookies(soup_cookie_jar_all_cookies(cookieJar));
     419        for (GSList* item = cookies.get(); item; item = g_slist_next(item)) {
     420            SoupCookie* cookie = static_cast<SoupCookie*>(item->data);
     421            if (soup_cookie_domain_matches(cookie, hostNameString.data()))
     422                soup_cookie_jar_delete_cookie(cookieJar, cookie);
     423            soup_cookie_free(cookie);
     424        }
     425    }
     426}
     427
     428void NetworkStorageSession::getHostnamesWithCookies(HashSet<String>& hostnames)
     429{
     430    GUniquePtr<GSList> cookies(soup_cookie_jar_all_cookies(cookieStorage()));
     431    for (GSList* item = cookies.get(); item; item = g_slist_next(item)) {
     432        SoupCookie* cookie = static_cast<SoupCookie*>(item->data);
     433        if (cookie->domain)
     434            hostnames.add(String::fromUTF8(cookie->domain));
     435        soup_cookie_free(cookie);
     436    }
    309437}
    310438
    … …  
    331459}
    332460
     461bool NetworkStorageSession::getRawCookies(const URL& firstParty, const SameSiteInfo&, const URL& url, std::optional<uint64_t> frameID, std::optional<uint64_t> pageID, Vector<Cookie>& rawCookies) const
     462{
     463    UNUSED_PARAM(firstParty);
     464    UNUSED_PARAM(frameID);
     465    UNUSED_PARAM(pageID);
     466    rawCookies.clear();
     467    GUniquePtr<SoupURI> uri = url.createSoupURI();
     468    if (!uri)
     469        return false;
     470
     471    GUniquePtr<GSList> cookies(soup_cookie_jar_get_cookie_list(cookieStorage(), uri.get(), TRUE));
     472    if (!cookies)
     473        return false;
     474
     475    for (GSList* iter = cookies.get(); iter; iter = g_slist_next(iter)) {
     476        SoupCookie* soupCookie = static_cast<SoupCookie*>(iter->data);
     477        Cookie cookie;
     478        cookie.name = String::fromUTF8(soupCookie->name);
     479        cookie.value = String::fromUTF8(soupCookie->value);
     480        cookie.domain = String::fromUTF8(soupCookie->domain);
     481        cookie.path = String::fromUTF8(soupCookie->path);
     482        cookie.created = 0;
     483        cookie.expires = soupCookie->expires ? static_cast<double>(soup_date_to_time_t(soupCookie->expires)) * 1000 : 0;
     484        cookie.httpOnly = soupCookie->http_only;
     485        cookie.secure = soupCookie->secure;
     486        cookie.session = !soupCookie->expires;
     487        rawCookies.append(WTFMove(cookie));
     488        soup_cookie_free(soupCookie);
     489    }
     490
     491    return true;
     492}
     493
     494static std::pair<String, bool> cookiesForSession(const NetworkStorageSession& session, const URL& url, bool forHTTPHeader, IncludeSecureCookies includeSecureCookies)
     495{
     496    GUniquePtr<SoupURI> uri = url.createSoupURI();
     497    if (!uri)
     498        return { { }, false };
     499
     500    GSList* cookies = soup_cookie_jar_get_cookie_list(session.cookieStorage(), uri.get(), forHTTPHeader);
     501    bool didAccessSecureCookies = false;
     502
     503    // libsoup should omit secure cookies itself if the protocol is not https.
     504    if (url.protocolIs("https")) {
     505        GSList* item = cookies;
     506        while (item) {
     507            auto cookie = static_cast<SoupCookie*>(item->data);
     508            if (soup_cookie_get_secure(cookie)) {
     509                didAccessSecureCookies = true;
     510                if (includeSecureCookies == IncludeSecureCookies::No) {
     511                    GSList* next = item->next;
     512                    soup_cookie_free(static_cast<SoupCookie*>(item->data));
     513                    cookies = g_slist_remove_link(cookies, item);
     514                    item = next;
     515                    continue;
     516                }
     517            }
     518            item = item->next;
     519        }
     520    }
     521
     522    if (!cookies)
     523        return { { }, false };
     524
     525    GUniquePtr<char> cookieHeader(soup_cookies_to_cookie_header(cookies));
     526    soup_cookies_free(cookies);
     527
     528    return { String::fromUTF8(cookieHeader.get()), didAccessSecureCookies };
     529}
     530
     531std::pair<String, bool> NetworkStorageSession::cookiesForDOM(const URL& firstParty, const SameSiteInfo&, const URL& url, std::optional<uint64_t> frameID, std::optional<uint64_t> pageID, IncludeSecureCookies includeSecureCookies) const
     532{
     533    UNUSED_PARAM(firstParty);
     534    UNUSED_PARAM(frameID);
     535    UNUSED_PARAM(pageID);
     536    return cookiesForSession(*this, url, false, includeSecureCookies);
     537}
     538
     539std::pair<String, bool> NetworkStorageSession::cookieRequestHeaderFieldValue(const URL& firstParty, const SameSiteInfo&, const URL& url, std::optional<uint64_t> frameID, std::optional<uint64_t> pageID, IncludeSecureCookies includeSecureCookies) const
     540{
     541    UNUSED_PARAM(firstParty);
     542    UNUSED_PARAM(frameID);
     543    UNUSED_PARAM(pageID);
     544    // Secure cookies will still only be included if url's protocol is https.
     545    return cookiesForSession(*this, url, true, includeSecureCookies);
     546}
     547
     548std::pair<String, bool> NetworkStorageSession::cookieRequestHeaderFieldValue(const CookieRequestHeaderFieldProxy& headerFieldProxy) const
     549{
     550    return cookieRequestHeaderFieldValue(headerFieldProxy.firstParty, headerFieldProxy.sameSiteInfo, headerFieldProxy.url, headerFieldProxy.frameID, headerFieldProxy.pageID, headerFieldProxy.includeSecureCookies);
     551}
     552
    333553void NetworkStorageSession::flushCookieStore()
    334554{

  • trunk/Source/WebKit/ChangeLog

    r234375 r234376  
     12018-07-30  Rob Buis  <rbuis@igalia.com>
     2
     3        https://bugs.webkit.org/show_bug.cgi?id=188137
     4        Merge PlatformCookieJar functions into NetworkStorageSession
     5
     6        Adapt callsites to use NetworkStorageSession instead of CookieJar functions.
     7
     8        Reviewed by Alex Christensen.
     9
     10        * NetworkProcess/Cookies/WebCookieManager.cpp:
     11        (WebKit::WebCookieManager::getHostnamesWithCookies):
     12        (WebKit::WebCookieManager::deleteCookiesForHostname):
     13        (WebKit::WebCookieManager::deleteAllCookies):
     14        (WebKit::WebCookieManager::deleteAllCookiesModifiedSince):
     15        * NetworkProcess/NetworkConnectionToWebProcess.cpp:
     16        (WebKit::NetworkConnectionToWebProcess::cookiesForDOM):
     17        (WebKit::NetworkConnectionToWebProcess::setCookiesFromDOM):
     18        (WebKit::NetworkConnectionToWebProcess::cookiesEnabled):
     19        (WebKit::NetworkConnectionToWebProcess::cookieRequestHeaderFieldValue):
     20        (WebKit::NetworkConnectionToWebProcess::getRawCookies):
     21        (WebKit::NetworkConnectionToWebProcess::deleteCookie):
     22        * NetworkProcess/NetworkProcess.cpp:
     23        (WebKit::NetworkProcess::fetchWebsiteData):
     24        (WebKit::NetworkProcess::deleteWebsiteData):
     25        (WebKit::NetworkProcess::deleteWebsiteDataForOrigins):
     26        * NetworkProcess/NetworkResourceLoader.cpp:
     27        (WebKit::logCookieInformationInternal):
     28        * NetworkProcess/cache/NetworkCache.cpp:
     29        * WebProcess/WebCoreSupport/WebPlatformStrategies.cpp:
     30
    1312018-07-30  Alex Christensen  <achristensen@webkit.org>
    232

  • trunk/Source/WebKit/NetworkProcess/Cookies/WebCookieManager.cpp

    r229426 r234376  
    3434#include <WebCore/CookieStorage.h>
    3535#include <WebCore/NetworkStorageSession.h>
    36 #include <WebCore/PlatformCookieJar.h>
    3736#include <WebCore/URL.h>
    3837#include <wtf/MainThread.h>
    … …  
    6160    HashSet<String> hostnames;
    6261    if (auto* storageSession = NetworkStorageSession::storageSession(sessionID))
    63         WebCore::getHostnamesWithCookies(*storageSession, hostnames);
     62        storageSession->getHostnamesWithCookies(hostnames);
    6463
    6564    m_process.send(Messages::WebCookieManagerProxy::DidGetHostnamesWithCookies(copyToVector(hostnames), callbackID), 0);
    … …  
    6968{
    7069    if (auto* storageSession = NetworkStorageSession::storageSession(sessionID))
    71         WebCore::deleteCookiesForHostnames(*storageSession, { hostname });
     70        storageSession->deleteCookiesForHostnames({ hostname });
    7271}
    7372
    … …  
    7675{
    7776    if (auto* storageSession = NetworkStorageSession::storageSession(sessionID))
    78         WebCore::deleteAllCookies(*storageSession);
     77        storageSession->deleteAllCookies();
    7978}
    8079
    … …  
    9089{
    9190    if (auto* storageSession = NetworkStorageSession::storageSession(sessionID))
    92         WebCore::deleteAllCookiesModifiedSince(*storageSession, time);
     91        storageSession->deleteAllCookiesModifiedSince(time);
    9392
    9493    m_process.send(Messages::WebCookieManagerProxy::DidDeleteCookies(callbackID), 0);

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

    r233808 r234376  
    5353#include "WebsiteDataStoreParameters.h"
    5454#include <WebCore/NetworkStorageSession.h>
    55 #include <WebCore/PlatformCookieJar.h>
    5655#include <WebCore/ResourceLoaderOptions.h>
    5756#include <WebCore/ResourceRequest.h>
    … …  
    380379{
    381380    auto& networkStorageSession = storageSession(sessionID);
    382     std::tie(cookieString, secureCookiesAccessed) = WebCore::cookiesForDOM(networkStorageSession, firstParty, sameSiteInfo, url, frameID, pageID, includeSecureCookies);
     381    std::tie(cookieString, secureCookiesAccessed) = networkStorageSession.cookiesForDOM(firstParty, sameSiteInfo, url, frameID, pageID, includeSecureCookies);
    383382#if HAVE(CFNETWORK_STORAGE_PARTITIONING) && !RELEASE_LOG_DISABLED
    384383    if (NetworkProcess::singleton().shouldLogCookieInformation())
    … …  
    390389{
    391390    auto& networkStorageSession = storageSession(sessionID);
    392     WebCore::setCookiesFromDOM(networkStorageSession, firstParty, sameSiteInfo, url, frameID, pageID, cookieString);
     391    networkStorageSession.setCookiesFromDOM(firstParty, sameSiteInfo, url, frameID, pageID, cookieString);
    393392#if HAVE(CFNETWORK_STORAGE_PARTITIONING) && !RELEASE_LOG_DISABLED
    394393    if (NetworkProcess::singleton().shouldLogCookieInformation())
    … …  
    399398void NetworkConnectionToWebProcess::cookiesEnabled(PAL::SessionID sessionID, bool& result)
    400399{
    401     result = WebCore::cookiesEnabled(storageSession(sessionID));
     400    result = storageSession(sessionID).cookiesEnabled();
    402401}
    403402
    404403void NetworkConnectionToWebProcess::cookieRequestHeaderFieldValue(PAL::SessionID sessionID, const URL& firstParty, const SameSiteInfo& sameSiteInfo, const URL& url, std::optional<uint64_t> frameID, std::optional<uint64_t> pageID, IncludeSecureCookies includeSecureCookies, String& cookieString, bool& secureCookiesAccessed)
    405404{
    406     std::tie(cookieString, secureCookiesAccessed) = WebCore::cookieRequestHeaderFieldValue(storageSession(sessionID), firstParty, sameSiteInfo, url, frameID, pageID, includeSecureCookies);
     405    std::tie(cookieString, secureCookiesAccessed) = storageSession(sessionID).cookieRequestHeaderFieldValue(firstParty, sameSiteInfo, url, frameID, pageID, includeSecureCookies);
    407406}
    408407
    409408void NetworkConnectionToWebProcess::getRawCookies(PAL::SessionID sessionID, const URL& firstParty, const SameSiteInfo& sameSiteInfo, const URL& url, std::optional<uint64_t> frameID, std::optional<uint64_t> pageID, Vector<Cookie>& result)
    410409{
    411     WebCore::getRawCookies(storageSession(sessionID), firstParty, sameSiteInfo, url, frameID, pageID, result);
     410    storageSession(sessionID).getRawCookies(firstParty, sameSiteInfo, url, frameID, pageID, result);
    412411}
    413412
    414413void NetworkConnectionToWebProcess::deleteCookie(PAL::SessionID sessionID, const URL& url, const String& cookieName)
    415414{
    416     WebCore::deleteCookie(storageSession(sessionID), url, cookieName);
     415    storageSession(sessionID).deleteCookie(url, cookieName);
    417416}
    418417

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

    r234288 r234376  
    6666#include <WebCore/NetworkStateNotifier.h>
    6767#include <WebCore/NetworkStorageSession.h>
    68 #include <WebCore/PlatformCookieJar.h>
    6968#include <WebCore/ResourceRequest.h>
    7069#include <WebCore/RuntimeApplicationChecks.h>
    … …  
    534533    if (websiteDataTypes.contains(WebsiteDataType::Cookies)) {
    535534        if (auto* networkStorageSession = NetworkStorageSession::storageSession(sessionID))
    536             getHostnamesWithCookies(*networkStorageSession, callbackAggregator->m_websiteData.hostNamesWithCookies);
     535            networkStorageSession->getHostnamesWithCookies(callbackAggregator->m_websiteData.hostNamesWithCookies);
    537536    }
    538537
    … …  
    566565    if (websiteDataTypes.contains(WebsiteDataType::Cookies)) {
    567566        if (auto* networkStorageSession = NetworkStorageSession::storageSession(sessionID))
    568             deleteAllCookiesModifiedSince(*networkStorageSession, modifiedSince);
     567            networkStorageSession->deleteAllCookiesModifiedSince(modifiedSince);
    569568    }
    570569
    … …  
    614613    if (websiteDataTypes.contains(WebsiteDataType::Cookies)) {
    615614        if (auto* networkStorageSession = NetworkStorageSession::storageSession(sessionID))
    616             deleteCookiesForHostnames(*networkStorageSession, cookieHostNames);
     615            networkStorageSession->deleteCookiesForHostnames(cookieHostNames);
    617616    }
    618617

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

    r233720 r234376  
    6060#if HAVE(CFNETWORK_STORAGE_PARTITIONING) && !RELEASE_LOG_DISABLED
    6161#include <WebCore/NetworkStorageSession.h>
    62 #include <WebCore/PlatformCookieJar.h>
    6362#endif
    6463
    … …  
    10151014
    10161015    Vector<WebCore::Cookie> cookies;
    1017     if (!WebCore::getRawCookies(networkStorageSession, partition, sameSiteInfo, url, frameID, pageID, cookies))
     1016    if (!networkStorageSession.getRawCookies(partition, sameSiteInfo, url, frameID, pageID, cookies))
    10181017        return;
    10191018

  • trunk/Source/WebKit/NetworkProcess/cache/NetworkCache.cpp

    r233738 r234376  
    3636#include <WebCore/LowPowerModeNotifier.h>
    3737#include <WebCore/NetworkStorageSession.h>
    38 #include <WebCore/PlatformCookieJar.h>
    3938#include <WebCore/ResourceRequest.h>
    4039#include <WebCore/ResourceResponse.h>

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

    r233753 r234376  
    5555#include <WebCore/PageGroup.h>
    5656#include <WebCore/PasteboardItemInfo.h>
    57 #include <WebCore/PlatformCookieJar.h>
    5857#include <WebCore/PlatformPasteboard.h>
    5958#include <WebCore/ProgressTracker.h>

  • trunk/Source/WebKitLegacy/mac/ChangeLog

    r234348 r234376  
     12018-07-30  Rob Buis  <rbuis@igalia.com>
     2
     3        Merge PlatformCookieJar functions into NetworkStorageSession
     4        https://bugs.webkit.org/show_bug.cgi?id=188137
     5
     6        Adapt callsites to use NetworkStorageSession instead of CookieJar functions.
     7
     8        Reviewed by Alex Christensen.
     9
     10        * WebCoreSupport/WebPlatformStrategies.mm:
     11        (WebPlatformStrategies::cookiesForDOM):
     12        (WebPlatformStrategies::setCookiesFromDOM):
     13        (WebPlatformStrategies::cookiesEnabled):
     14        (WebPlatformStrategies::cookieRequestHeaderFieldValue):
     15        (WebPlatformStrategies::getRawCookies):
     16        (WebPlatformStrategies::deleteCookie):
     17        * WebView/WebPreferences.mm:
     18        (+[WebPreferences _clearNetworkLoaderSession]):
     19
    1202018-07-28  Darin Adler  <darin@apple.com>
    221

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

    r233753 r234376  
    3434#import <WebCore/NetworkStorageSession.h>
    3535#import <WebCore/PasteboardItemInfo.h>
    36 #import <WebCore/PlatformCookieJar.h>
    3736#import <WebCore/PlatformPasteboard.h>
    3837#import <WebCore/SharedBuffer.h>
    … …  
    7675std::pair<String, bool> WebPlatformStrategies::cookiesForDOM(const NetworkStorageSession& session, const URL& firstParty, const SameSiteInfo& sameSiteInfo, const URL& url, std::optional<uint64_t> frameID, std::optional<uint64_t> pageID, IncludeSecureCookies includeSecureCookies)
    7776{
    78     return WebCore::cookiesForDOM(session, firstParty, sameSiteInfo, url, frameID, pageID, includeSecureCookies);
     77    return session.cookiesForDOM(firstParty, sameSiteInfo, url, frameID, pageID, includeSecureCookies);
    7978}
    8079
    8180void WebPlatformStrategies::setCookiesFromDOM(const NetworkStorageSession& session, const URL& firstParty, const SameSiteInfo& sameSiteInfo, const URL& url, std::optional<uint64_t> frameID, std::optional<uint64_t> pageID, const String& cookieString)
    8281{
    83     WebCore::setCookiesFromDOM(session, firstParty, sameSiteInfo, url, frameID, pageID, cookieString);
     82    session.setCookiesFromDOM(firstParty, sameSiteInfo, url, frameID, pageID, cookieString);
    8483}
    8584
    8685bool WebPlatformStrategies::cookiesEnabled(const NetworkStorageSession& session)
    8786{
    88     return WebCore::cookiesEnabled(session);
     87    return session.cookiesEnabled();
    8988}
    9089
    9190std::pair<String, bool> WebPlatformStrategies::cookieRequestHeaderFieldValue(const NetworkStorageSession& session, const URL& firstParty, const SameSiteInfo& sameSiteInfo, const URL& url, std::optional<uint64_t> frameID, std::optional<uint64_t> pageID, IncludeSecureCookies includeSecureCookies)
    9291{
    93     return WebCore::cookieRequestHeaderFieldValue(session, firstParty, sameSiteInfo, url, frameID, pageID, includeSecureCookies);
     92    return session.cookieRequestHeaderFieldValue(firstParty, sameSiteInfo, url, frameID, pageID, includeSecureCookies);
    9493}
    9594
    … …  
    9796{
    9897    auto& session = sessionID.isEphemeral() ? WebFrameNetworkingContext::ensurePrivateBrowsingSession() : NetworkStorageSession::defaultStorageSession();
    99     return WebCore::cookieRequestHeaderFieldValue(session, firstParty, sameSiteInfo, url, frameID, pageID, includeSecureCookies);
     98    return session.cookieRequestHeaderFieldValue(firstParty, sameSiteInfo, url, frameID, pageID, includeSecureCookies);
    10099}
    101100
    102101bool WebPlatformStrategies::getRawCookies(const NetworkStorageSession& session, const URL& firstParty, const SameSiteInfo& sameSiteInfo, const URL& url, std::optional<uint64_t> frameID, std::optional<uint64_t> pageID, Vector<Cookie>& rawCookies)
    103102{
    104     return WebCore::getRawCookies(session, firstParty, sameSiteInfo, url, frameID, pageID, rawCookies);
     103    return session.getRawCookies(firstParty, sameSiteInfo, url, frameID, pageID, rawCookies);
    105104}
    106105
    107106void WebPlatformStrategies::deleteCookie(const NetworkStorageSession& session, const URL& url, const String& cookieName)
    108107{
    109     WebCore::deleteCookie(session, url, cookieName);
     108    session.deleteCookie(url, cookieName);
    110109}
    111110

  • trunk/Source/WebKitLegacy/mac/WebView/WebPreferences.mm

    r233869 r234376  
    4343#import <WebCore/DeprecatedGlobalSettings.h>
    4444#import <WebCore/NetworkStorageSession.h>
    45 #import <WebCore/PlatformCookieJar.h>
    4645#import <WebCore/RuntimeApplicationChecks.h>
    4746#import <WebCore/Settings.h>
    … …  
    18781877+ (void)_clearNetworkLoaderSession
    18791878{
    1880     WebCore::deleteAllCookies(NetworkStorageSession::defaultStorageSession());
     1879    NetworkStorageSession::defaultStorageSession().deleteAllCookies();
    18811880}
    18821881

  • trunk/Source/WebKitLegacy/win/ChangeLog

    r234278 r234376  
     12018-07-30  Rob Buis  <rbuis@igalia.com>
     2
     3        https://bugs.webkit.org/show_bug.cgi?id=188137
     4        Merge PlatformCookieJar functions into NetworkStorageSession
     5
     6        Adapt callsites to use NetworkStorageSession instead of CookieJar functions.
     7
     8        Reviewed by Alex Christensen.
     9
     10        * WebCoreSupport/WebPlatformStrategies.cpp:
     11        (WebPlatformStrategies::cookiesForDOM):
     12        (WebPlatformStrategies::setCookiesFromDOM):
     13        (WebPlatformStrategies::cookiesEnabled):
     14        (WebPlatformStrategies::cookieRequestHeaderFieldValue):
     15        (WebPlatformStrategies::getRawCookies):
     16        (WebPlatformStrategies::deleteCookie):
     17        * WebPreferences.cpp:
     18        (WebPreferences::clearNetworkLoaderSession):
     19
    1202018-07-26  Ross Kirsling  <ross.kirsling@sony.com>
    221

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

    r230944 r234376  
    3333#include <WebCore/Page.h>
    3434#include <WebCore/PageGroup.h>
    35 #include <WebCore/PlatformCookieJar.h>
    3635
    3736#if USE(CFURLCONNECTION)
    … …  
    7372std::pair<String, bool> WebPlatformStrategies::cookiesForDOM(const NetworkStorageSession& session, const URL& firstParty, const SameSiteInfo& sameSiteInfo, const URL& url, std::optional<uint64_t> frameID, std::optional<uint64_t> pageID, IncludeSecureCookies includeSecureCookies)
    7473{
    75     return WebCore::cookiesForDOM(session, firstParty, sameSiteInfo, url, frameID, pageID, includeSecureCookies);
     74    return session.cookiesForDOM(firstParty, sameSiteInfo, url, frameID, pageID, includeSecureCookies);
    7675}
    7776
    7877void WebPlatformStrategies::setCookiesFromDOM(const NetworkStorageSession& session, const URL& firstParty, const SameSiteInfo& sameSiteInfo, const URL& url, std::optional<uint64_t> frameID, std::optional<uint64_t> pageID, const String& cookieString)
    7978{
    80     WebCore::setCookiesFromDOM(session, firstParty, sameSiteInfo, url, frameID, pageID, cookieString);
     79    session.setCookiesFromDOM(firstParty, sameSiteInfo, url, frameID, pageID, cookieString);
    8180}
    8281
    8382bool WebPlatformStrategies::cookiesEnabled(const NetworkStorageSession& session)
    8483{
    85     return WebCore::cookiesEnabled(session);
     84    return session.cookiesEnabled();
    8685}
    8786
    8887std::pair<String, bool> WebPlatformStrategies::cookieRequestHeaderFieldValue(const NetworkStorageSession& session, const URL& firstParty, const SameSiteInfo& sameSiteInfo, const URL& url, std::optional<uint64_t> frameID, std::optional<uint64_t> pageID, IncludeSecureCookies includeSecureCookies)
    8988{
    90     return WebCore::cookieRequestHeaderFieldValue(session, firstParty, sameSiteInfo, url, frameID, pageID, includeSecureCookies);
     89    return session.cookieRequestHeaderFieldValue(firstParty, sameSiteInfo, url, frameID, pageID, includeSecureCookies);
    9190}
    9291
    … …  
    9493{
    9594    auto& session = sessionID.isEphemeral() ? WebFrameNetworkingContext::ensurePrivateBrowsingSession() : NetworkStorageSession::defaultStorageSession();
    96     return WebCore::cookieRequestHeaderFieldValue(session, firstParty, sameSiteInfo, url, frameID, pageID, includeSecureCookies);
     95    return session.cookieRequestHeaderFieldValue(firstParty, sameSiteInfo, url, frameID, pageID, includeSecureCookies);
    9796}
    9897
    9998bool WebPlatformStrategies::getRawCookies(const NetworkStorageSession& session, const URL& firstParty, const SameSiteInfo& sameSiteInfo, const URL& url, std::optional<uint64_t> frameID, std::optional<uint64_t> pageID, Vector<Cookie>& rawCookies)
    10099{
    101     return WebCore::getRawCookies(session, firstParty, sameSiteInfo, url, frameID, pageID, rawCookies);
     100    return session.getRawCookies(firstParty, sameSiteInfo, url, frameID, pageID, rawCookies);
    102101}
    103102
    104103void WebPlatformStrategies::deleteCookie(const NetworkStorageSession& session, const URL& url, const String& cookieName)
    105104{
    106     WebCore::deleteCookie(session, url, cookieName);
     105    session.deleteCookie(url, cookieName);
    107106}

  • trunk/Source/WebKitLegacy/win/WebPreferences.cpp

    r233687 r234376  
    4343#include <WebCore/LocalizedStrings.h>
    4444#include <WebCore/NetworkStorageSession.h>
    45 #include <WebCore/PlatformCookieJar.h>
    4645#include <limits>
    4746#include <shlobj.h>
    … …  
    21212120HRESULT WebPreferences::clearNetworkLoaderSession()
    21222121{
    2123     WebCore::deleteAllCookies(NetworkStorageSession::defaultStorageSession());
     2122    NetworkStorageSession::defaultStorageSession().deleteAllCookies();
    21242123    return S_OK;
    21252124}
Note: See TracChangeset for help on using the changeset viewer.