Changeset 210729 in webkit


Ignore:
Timestamp:
Jan 13, 2017 12:24:54 AM (7 years ago)
Author:
Carlos Garcia Campos
Message:

[SOUP] Simplify cookie storage handling
​https://bugs.webkit.org/show_bug.cgi?id=166967

Reviewed by Sergio Villar Senin.

Source/WebCore:

We currently have a global cookie storage, and several create() methods in SoupNetworkSession to create sessions
with different cookie jars. This could be simplified by moving the cookie storage handling to
NetworkStorageSession and removing all create() methods from SoupNetworkSession. This patch also removes the
default SoupNetworkSession in favor of using the default NetworkStorageSession.

  • platform/network/NetworkStorageSession.h: Add a default cookie storage to be used when the

NetworkStorageSession doesn't have a platform soup session.

  • platform/network/soup/CookieJarSoup.cpp: Remove the global cookie storage handling.

(WebCore::setCookiesFromDOM): Use NetworkStorageSession::cookieStorage() instead.
(WebCore::cookiesForSession): Ditto.
(WebCore::cookiesEnabled): Check the policy instead like all other ports do, since now we will always have a
default shared cookie jar.
(WebCore::getRawCookies): Use NetworkStorageSession::cookieStorage() instead.
(WebCore::deleteCookie): Ditto.
(WebCore::addCookie): Ditto.
(WebCore::getHostnamesWithCookies): Ditto.
(WebCore::deleteCookiesForHostnames): Ditto.
(WebCore::deleteAllCookies): Ditto.

  • platform/network/soup/CookieJarSoup.h: Removed.
  • platform/network/soup/CookieStorageSoup.cpp:

(WebCore::soupCookiesChanged): Use the cookie storage from the NetworkStorageSession::defaultStorageSession().
(WebCore::startObservingCookieChanges): Ditto.
(WebCore::stopObservingCookieChanges): Ditto.

  • platform/network/soup/DNSSoup.cpp:

(WebCore::DNSResolveQueue::updateIsUsingProxy): Get the SoupSession from the NetworkStorageSession::defaultStorageSession().
(WebCore::DNSResolveQueue::platformResolve): Ditto.

  • platform/network/soup/NetworkStorageSessionSoup.cpp:

(WebCore::NetworkStorageSession::NetworkStorageSession):
(WebCore::NetworkStorageSession::ensurePrivateBrowsingSession): Create a new SoupNetworkSession without
providing a cookie storage to ensure it creates its own private one.
(WebCore::NetworkStorageSession::switchToNewTestingSession): Ditto.
(WebCore::NetworkStorageSession::soupNetworkSession): Create the SoupNetworkSession on demand passing the global
shared cookie storage.
(WebCore::NetworkStorageSession::cookieStorage): Return the cookie storage from the SoupNetworkSession if we
have one, otherwise create the global shared one and return it.

  • platform/network/soup/ResourceHandleSoup.cpp:

(WebCore::sessionFromContext): Get the SoupSession from the NetworkStorageSession::defaultStorageSession().

  • platform/network/soup/SoupNetworkSession.cpp:

(WebCore::SoupNetworkSession::SoupNetworkSession): Remove all create methods and the unused constructor that
receives a SoupSession. Allow to pass a nullptr SoupCookieJar and create one in such case.

  • platform/network/soup/SoupNetworkSession.h:

Source/WebKit2:

Get the SoupSession from NetworkStorageSession::defaultStorageSession().

  • NetworkProcess/CustomProtocols/soup/CustomProtocolManagerSoup.cpp:

(WebKit::CustomProtocolManager::registerScheme): Get the SoupSession from NetworkStorageSession::defaultStorageSession().

  • NetworkProcess/efl/NetworkProcessMainEfl.cpp: Ditto.
  • NetworkProcess/soup/NetworkProcessSoup.cpp:

(WebKit::NetworkProcess::userPreferredLanguagesChanged): Ditto.
(WebKit::NetworkProcess::platformInitializeNetworkProcess): SoupNetworkSession::clearOldSoupCache is static.

  • WebProcess/Cookies/soup/WebCookieManagerSoup.cpp:

(WebKit::WebCookieManager::platformGetHTTPCookieAcceptPolicy): Use the cookie storage from NetworkStorageSession::defaultStorageSession().
(WebKit::WebCookieManager::setCookiePersistentStorage): Ditto.

  • WebProcess/WebCoreSupport/soup/WebFrameNetworkingContext.cpp:

(WebKit::WebFrameNetworkingContext::setCookieAcceptPolicyForAllContexts): Ditto.

  • WebProcess/efl/WebProcessMainEfl.cpp:
Location:
trunk/Source
Files:
1 deleted
16 edited

Legend:

Unmodified
Added
Removed

  • trunk/Source/WebCore/ChangeLog

    r210727 r210729  
     12017-01-13  Carlos Garcia Campos  <cgarcia@igalia.com>
     2
     3        [SOUP] Simplify cookie storage handling
     4        https://bugs.webkit.org/show_bug.cgi?id=166967
     5
     6        Reviewed by Sergio Villar Senin.
     7
     8        We currently have a global cookie storage, and several create() methods in SoupNetworkSession to create sessions
     9        with different cookie jars. This could be simplified by moving the cookie storage handling to
     10        NetworkStorageSession and removing all create() methods from SoupNetworkSession. This patch also removes the
     11        default SoupNetworkSession in favor of using the default NetworkStorageSession.
     12
     13        * platform/network/NetworkStorageSession.h: Add a default cookie storage to be used when the
     14        NetworkStorageSession doesn't have a platform soup session.
     15        * platform/network/soup/CookieJarSoup.cpp: Remove the global cookie storage handling.
     16        (WebCore::setCookiesFromDOM): Use NetworkStorageSession::cookieStorage() instead.
     17        (WebCore::cookiesForSession): Ditto.
     18        (WebCore::cookiesEnabled): Check the policy instead like all other ports do, since now we will always have a
     19        default shared cookie jar.
     20        (WebCore::getRawCookies): Use NetworkStorageSession::cookieStorage() instead.
     21        (WebCore::deleteCookie): Ditto.
     22        (WebCore::addCookie): Ditto.
     23        (WebCore::getHostnamesWithCookies): Ditto.
     24        (WebCore::deleteCookiesForHostnames): Ditto.
     25        (WebCore::deleteAllCookies): Ditto.
     26        * platform/network/soup/CookieJarSoup.h: Removed.
     27        * platform/network/soup/CookieStorageSoup.cpp:
     28        (WebCore::soupCookiesChanged): Use the cookie storage from the NetworkStorageSession::defaultStorageSession().
     29        (WebCore::startObservingCookieChanges): Ditto.
     30        (WebCore::stopObservingCookieChanges): Ditto.
     31        * platform/network/soup/DNSSoup.cpp:
     32        (WebCore::DNSResolveQueue::updateIsUsingProxy): Get the SoupSession from the NetworkStorageSession::defaultStorageSession().
     33        (WebCore::DNSResolveQueue::platformResolve): Ditto.
     34        * platform/network/soup/NetworkStorageSessionSoup.cpp:
     35        (WebCore::NetworkStorageSession::NetworkStorageSession):
     36        (WebCore::NetworkStorageSession::ensurePrivateBrowsingSession): Create a new SoupNetworkSession without
     37        providing a cookie storage to ensure it creates its own private one.
     38        (WebCore::NetworkStorageSession::switchToNewTestingSession): Ditto.
     39        (WebCore::NetworkStorageSession::soupNetworkSession): Create the SoupNetworkSession on demand passing the global
     40        shared cookie storage.
     41        (WebCore::NetworkStorageSession::cookieStorage): Return the cookie storage from the SoupNetworkSession if we
     42        have one, otherwise create the global shared one and return it.
     43        * platform/network/soup/ResourceHandleSoup.cpp:
     44        (WebCore::sessionFromContext): Get the SoupSession from the NetworkStorageSession::defaultStorageSession().
     45        * platform/network/soup/SoupNetworkSession.cpp:
     46        (WebCore::SoupNetworkSession::SoupNetworkSession): Remove all create methods and the unused constructor that
     47        receives a SoupSession. Allow to pass a nullptr SoupCookieJar and create one in such case.
     48        * platform/network/soup/SoupNetworkSession.h:
     49
    1502017-01-12  Tim Horton  <timothy_horton@apple.com>
    251

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

    r207151 r210729  
    3838#include <wtf/Function.h>
    3939#include <wtf/glib/GRefPtr.h>
     40typedef struct _SoupCookieJar SoupCookieJar;
    4041#endif
    4142
    … …  
    6869    WEBCORE_EXPORT static void setCookieStoragePartitioningEnabled(bool);
    6970#elif USE(SOUP)
    70     NetworkStorageSession(SessionID, std::unique_ptr<SoupNetworkSession>);
     71    NetworkStorageSession(SessionID, std::unique_ptr<SoupNetworkSession>&&);
    7172    ~NetworkStorageSession();
    7273
    7374    SoupNetworkSession& soupNetworkSession() const;
     75    SoupCookieJar* cookieStorage() const;
    7476    void getCredentialFromPersistentStorage(const ProtectionSpace&, Function<void (Credential&&)> completionHandler);
    7577    void saveCredentialToPersistentStorage(const ProtectionSpace&, const Credential&);
    … …  
    8890    RetainPtr<CFURLStorageSessionRef> m_platformSession;
    8991#elif USE(SOUP)
    90     std::unique_ptr<SoupNetworkSession> m_session;
     92    mutable std::unique_ptr<SoupNetworkSession> m_session;
     93    mutable GRefPtr<SoupCookieJar> m_cookieStorage;
    9194#if USE(LIBSECRET)
    9295    Function<void (Credential&&)> m_persisentStorageCompletionHandler;

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

    r204327 r210729  
    2323#if USE(SOUP)
    2424
    25 #include "CookieJarSoup.h"
    26 
    2725#include "Cookie.h"
    2826#include "GUniquePtrSoup.h"
    … …  
    3836namespace WebCore {
    3937
    40 static SoupCookieJar* cookieJarForSession(const NetworkStorageSession& session)
    41 {
    42     return session.soupNetworkSession().cookieJar();
    43 }
    44 
    45 static GRefPtr<SoupCookieJar>& defaultCookieJar()
    46 {
    47     DEPRECATED_DEFINE_STATIC_LOCAL(GRefPtr<SoupCookieJar>, cookieJar, ());
    48     return cookieJar;
    49 }
    50 
    51 SoupCookieJar* soupCookieJar()
    52 {
    53     if (GRefPtr<SoupCookieJar>& jar = defaultCookieJar())
    54         return jar.get();
    55 
    56     SoupCookieJar* jar = soup_cookie_jar_new();
    57     soup_cookie_jar_set_accept_policy(jar, SOUP_COOKIE_JAR_ACCEPT_NO_THIRD_PARTY);
    58     setSoupCookieJar(jar);
    59     return jar;
    60 }
    61 
    62 SoupCookieJar* createPrivateBrowsingCookieJar()
    63 {
    64     SoupCookieJar* jar = soup_cookie_jar_new();
    65 
    66     soup_cookie_jar_set_accept_policy(jar, SOUP_COOKIE_JAR_ACCEPT_NO_THIRD_PARTY);
    67 
    68     return jar;
    69 }
    70 
    71 void setSoupCookieJar(SoupCookieJar* jar)
    72 {
    73     defaultCookieJar() = jar;
    74 }
    75 
    7638static inline bool httpOnlyCookieExists(const GSList* cookies, const gchar* name, const gchar* path)
    7739{
    … …  
    9052void setCookiesFromDOM(const NetworkStorageSession& session, const URL& firstParty, const URL& url, const String& value)
    9153{
    92     SoupCookieJar* jar = cookieJarForSession(session);
    93     if (!jar)
    94         return;
     54    SoupCookieJar* jar = session.cookieStorage();
    9555
    9656    GUniquePtr<SoupURI> origin = url.createSoupURI();
    … …  
    12484static String cookiesForSession(const NetworkStorageSession& session, const URL& url, bool forHTTPHeader)
    12585{
    126     SoupCookieJar* jar = cookieJarForSession(session);
    127     if (!jar)
    128         return String();
    129 
    13086    GUniquePtr<SoupURI> uri = url.createSoupURI();
    131     GUniquePtr<char> cookies(soup_cookie_jar_get_cookies(jar, uri.get(), forHTTPHeader));
     87    GUniquePtr<char> cookies(soup_cookie_jar_get_cookies(session.cookieStorage(), uri.get(), forHTTPHeader));
    13288    return String::fromUTF8(cookies.get());
    13389}
    … …  
    145101bool cookiesEnabled(const NetworkStorageSession& session, const URL& /*firstParty*/, const URL& /*url*/)
    146102{
    147     return !!cookieJarForSession(session);
     103    auto policy = soup_cookie_jar_get_accept_policy(session.cookieStorage());
     104    return policy == SOUP_COOKIE_JAR_ACCEPT_ALWAYS || policy == SOUP_COOKIE_JAR_ACCEPT_NO_THIRD_PARTY;
    148105}
    149106
    … …  
    151108{
    152109    rawCookies.clear();
    153     SoupCookieJar* jar = cookieJarForSession(session);
    154     if (!jar)
    155         return false;
    156 
    157110    GUniquePtr<SoupURI> uri = url.createSoupURI();
    158     GUniquePtr<GSList> cookies(soup_cookie_jar_get_cookie_list(jar, uri.get(), TRUE));
     111    GUniquePtr<GSList> cookies(soup_cookie_jar_get_cookie_list(session.cookieStorage(), uri.get(), TRUE));
    159112    if (!cookies)
    160113        return false;
    … …  
    173126void deleteCookie(const NetworkStorageSession& session, const URL& url, const String& name)
    174127{
    175     SoupCookieJar* jar = cookieJarForSession(session);
    176     if (!jar)
    177         return;
     128    SoupCookieJar* jar = session.cookieStorage();
    178129
    179130    GUniquePtr<SoupURI> uri = url.createSoupURI();
    … …  
    218169void addCookie(const NetworkStorageSession& session, const URL&, const Cookie& cookie)
    219170{
    220     soup_cookie_jar_add_cookie(cookieJarForSession(session), toSoupCookie(cookie));
     171    soup_cookie_jar_add_cookie(session.cookieStorage(), toSoupCookie(cookie));
    221172}
    222173
    223174void getHostnamesWithCookies(const NetworkStorageSession& session, HashSet<String>& hostnames)
    224175{
    225     SoupCookieJar* cookieJar = cookieJarForSession(session);
    226     GUniquePtr<GSList> cookies(soup_cookie_jar_all_cookies(cookieJar));
     176    GUniquePtr<GSList> cookies(soup_cookie_jar_all_cookies(session.cookieStorage()));
    227177    for (GSList* item = cookies.get(); item; item = g_slist_next(item)) {
    228178        SoupCookie* cookie = static_cast<SoupCookie*>(item->data);
    … …  
    235185void deleteCookiesForHostnames(const NetworkStorageSession& session, const Vector<String>& hostnames)
    236186{
     187    SoupCookieJar* cookieJar = session.cookieStorage();
     188
    237189    for (const auto& hostname : hostnames) {
    238190        CString hostNameString = hostname.utf8();
    239         SoupCookieJar* cookieJar = cookieJarForSession(session);
     191
    240192        GUniquePtr<GSList> cookies(soup_cookie_jar_all_cookies(cookieJar));
    241193        for (GSList* item = cookies.get(); item; item = g_slist_next(item)) {
    … …  
    250202void deleteAllCookies(const NetworkStorageSession& session)
    251203{
    252     SoupCookieJar* cookieJar = cookieJarForSession(session);
     204    SoupCookieJar* cookieJar = session.cookieStorage();
    253205    GUniquePtr<GSList> cookies(soup_cookie_jar_all_cookies(cookieJar));
    254206    for (GSList* item = cookies.get(); item; item = g_slist_next(item)) {

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

    r165996 r210729  
    2222#if USE(SOUP)
    2323
    24 #include "CookieJarSoup.h"
    25 #include "NotImplemented.h"
    26 
    27 #include <stdio.h>
     24#include "NetworkStorageSession.h"
     25#include <libsoup/soup.h>
    2826
    2927namespace WebCore {
    … …  
    3129static CookieChangeCallbackPtr cookieChangeCallback;
    3230
    33 static void soupCookiesChanged(SoupCookieJar* jar, SoupCookie*, SoupCookie*, gpointer)
     31static void soupCookiesChanged(SoupCookieJar* jar)
    3432{
    35     if (jar != soupCookieJar())
     33    if (jar != NetworkStorageSession::defaultStorageSession().cookieStorage())
    3634        return;
    3735    cookieChangeCallback();
    … …  
    4341    cookieChangeCallback = callback;
    4442
    45     g_signal_connect(soupCookieJar(), "changed", G_CALLBACK(soupCookiesChanged), 0);
     43    g_signal_connect(NetworkStorageSession::defaultStorageSession().cookieStorage(), "changed", G_CALLBACK(soupCookiesChanged), 0);
    4644}
    4745
    4846void stopObservingCookieChanges()
    4947{
    50     g_signal_handlers_disconnect_by_func(soupCookieJar(), reinterpret_cast<void*>(soupCookiesChanged), 0);
    51     cookieChangeCallback = 0;
     48    g_signal_handlers_disconnect_by_func(NetworkStorageSession::defaultStorageSession().cookieStorage(), reinterpret_cast<void*>(soupCookiesChanged), nullptr);
     49    cookieChangeCallback = nullptr;
    5250}
    5351

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

    r194323 r210729  
    3131#if USE(SOUP)
    3232
     33#include "NetworkStorageSession.h"
    3334#include "SoupNetworkSession.h"
    3435#include <libsoup/soup.h>
    … …  
    7980{
    8081    GRefPtr<GProxyResolver> resolver;
    81     g_object_get(SoupNetworkSession::defaultSession().soupSession(), "proxy-resolver", &resolver.outPtr(), nullptr);
     82    g_object_get(NetworkStorageSession::defaultStorageSession().soupNetworkSession().soupSession(), "proxy-resolver", &resolver.outPtr(), nullptr);
    8283    ASSERT(resolver);
    8384
    … …  
    9596    ASSERT(isMainThread());
    9697
    97     soup_session_prefetch_dns(SoupNetworkSession::defaultSession().soupSession(), hostname.utf8().data(), nullptr, resolvedCallback, nullptr);
     98    soup_session_prefetch_dns(NetworkStorageSession::defaultStorageSession().soupNetworkSession().soupSession(), hostname.utf8().data(), nullptr, resolvedCallback, nullptr);
    9899}
    99100

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

    r206731 r210729  
    4848namespace WebCore {
    4949
    50 NetworkStorageSession::NetworkStorageSession(SessionID sessionID, std::unique_ptr<SoupNetworkSession> session)
     50NetworkStorageSession::NetworkStorageSession(SessionID sessionID, std::unique_ptr<SoupNetworkSession>&& session)
    5151    : m_sessionID(sessionID)
    5252    , m_session(WTFMove(session))
    … …  
    7777void NetworkStorageSession::ensurePrivateBrowsingSession(SessionID sessionID, const String&)
    7878{
    79     auto session = std::make_unique<NetworkStorageSession>(sessionID, SoupNetworkSession::createPrivateBrowsingSession());
    8079    ASSERT(sessionID != SessionID::defaultSessionID());
    8180    ASSERT(!globalSessionMap().contains(sessionID));
    82     globalSessionMap().add(sessionID, WTFMove(session));
     81    globalSessionMap().add(sessionID, std::make_unique<NetworkStorageSession>(sessionID, std::make_unique<SoupNetworkSession>()));
    8382}
    8483
    8584void NetworkStorageSession::switchToNewTestingSession()
    8685{
    87     defaultSession() = std::make_unique<NetworkStorageSession>(SessionID::defaultSessionID(), SoupNetworkSession::createTestingSession());
     86    defaultSession() = std::make_unique<NetworkStorageSession>(SessionID::defaultSessionID(), std::make_unique<SoupNetworkSession>());
     87    // FIXME: Creating a testing session is losing soup session values set when initializing the network process.
     88    g_object_set(defaultSession()->soupNetworkSession().soupSession(), "accept-language", "en-us", nullptr);
    8889}
    8990
    9091SoupNetworkSession& NetworkStorageSession::soupNetworkSession() const
    9192{
    92     return m_session ? *m_session : SoupNetworkSession::defaultSession();
     93    if (!m_session)
     94        m_session = std::make_unique<SoupNetworkSession>(cookieStorage());
     95    return *m_session;
     96}
     97
     98SoupCookieJar* NetworkStorageSession::cookieStorage() const
     99{
     100    if (m_session) {
     101        m_cookieStorage = nullptr;
     102        ASSERT(m_session->cookieJar());
     103        return m_session->cookieJar();
     104    }
     105
     106    if (!m_cookieStorage) {
     107        m_cookieStorage = adoptGRef(soup_cookie_jar_new());
     108        soup_cookie_jar_set_accept_policy(m_cookieStorage.get(), SOUP_COOKIE_JAR_ACCEPT_NO_THIRD_PARTY);
     109    }
     110    return m_cookieStorage.get();
    93111}
    94112

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

    r208732 r210729  
    3232#if USE(SOUP)
    3333
    34 #include "CookieJarSoup.h"
    3534#include "CredentialStorage.h"
    3635#include "FileSystem.h"
    … …  
    8281{
    8382    if (!context || !context->isValid())
    84         return SoupNetworkSession::defaultSession().soupSession();
     83        return NetworkStorageSession::defaultStorageSession().soupNetworkSession().soupSession();
    8584    return context->storageSession().soupNetworkSession().soupSession();
    8685}

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

    r206850 r210729  
    3131
    3232#include "AuthenticationChallenge.h"
    33 #include "CookieJarSoup.h"
    3433#include "CryptoDigest.h"
    3534#include "FileSystem.h"
    … …  
    9493}
    9594
    96 SoupNetworkSession& SoupNetworkSession::defaultSession()
    97 {
    98     static NeverDestroyed<SoupNetworkSession> networkSession(soupCookieJar());
    99     return networkSession;
    100 }
    101 
    102 std::unique_ptr<SoupNetworkSession> SoupNetworkSession::createPrivateBrowsingSession()
    103 {
    104     return std::unique_ptr<SoupNetworkSession>(new SoupNetworkSession(soupCookieJar()));
    105 }
    106 
    107 std::unique_ptr<SoupNetworkSession> SoupNetworkSession::createTestingSession()
    108 {
    109     auto cookieJar = adoptGRef(createPrivateBrowsingCookieJar());
    110     auto newSoupSession = std::unique_ptr<SoupNetworkSession>(new SoupNetworkSession(cookieJar.get()));
    111     // FIXME: Creating a testing session is losing soup session values set when initializing the network process.
    112     g_object_set(newSoupSession->soupSession(), "accept-language", "en-us", nullptr);
    113     return newSoupSession;
    114 }
    115 
    116 std::unique_ptr<SoupNetworkSession> SoupNetworkSession::createForSoupSession(SoupSession* soupSession)
    117 {
    118     return std::unique_ptr<SoupNetworkSession>(new SoupNetworkSession(soupSession));
    119 }
    120 
    12195static void authenticateCallback(SoupSession*, SoupMessage* soupMessage, SoupAuth* soupAuth, gboolean retrying)
    12296{
    … …  
    147121    static const int maxConnectionsPerHost = 6;
    148122
     123    GRefPtr<SoupCookieJar> jar = cookieJar;
     124    if (!jar) {
     125        jar = adoptGRef(soup_cookie_jar_new());
     126        soup_cookie_jar_set_accept_policy(jar.get(), SOUP_COOKIE_JAR_ACCEPT_NO_THIRD_PARTY);
     127    }
     128
    149129    g_object_set(m_soupSession.get(),
    150130        SOUP_SESSION_MAX_CONNS, maxConnections,
    … …  
    153133        SOUP_SESSION_ADD_FEATURE_BY_TYPE, SOUP_TYPE_CONTENT_SNIFFER,
    154134        SOUP_SESSION_ADD_FEATURE_BY_TYPE, SOUP_TYPE_PROXY_RESOLVER_DEFAULT,
    155         SOUP_SESSION_ADD_FEATURE, cookieJar,
     135        SOUP_SESSION_ADD_FEATURE, jar.get(),
    156136        SOUP_SESSION_USE_THREAD_CONTEXT, TRUE,
    157137        SOUP_SESSION_SSL_USE_SYSTEM_CA_FILE, TRUE,
    … …  
    173153    g_signal_connect(m_soupSession.get(), "request-started", G_CALLBACK(requestStartedCallback), nullptr);
    174154#endif
    175 }
    176 
    177 SoupNetworkSession::SoupNetworkSession(SoupSession* soupSession)
    178     : m_soupSession(soupSession)
    179 {
    180     setupLogger();
    181155}
    182156

  • trunk/Source/WebCore/platform/network/soup/SoupNetworkSession.h

    r207232 r210729  
    4747    WTF_MAKE_NONCOPYABLE(SoupNetworkSession); WTF_MAKE_FAST_ALLOCATED;
    4848public:
     49    SoupNetworkSession(SoupCookieJar* = nullptr);
    4950    ~SoupNetworkSession();
    50 
    51     static SoupNetworkSession& defaultSession();
    52     static std::unique_ptr<SoupNetworkSession> createPrivateBrowsingSession();
    53     static std::unique_ptr<SoupNetworkSession> createTestingSession();
    54     static std::unique_ptr<SoupNetworkSession> createForSoupSession(SoupSession*);
    5551
    5652    SoupSession* soupSession() const { return m_soupSession.get(); }
    … …  
    7066
    7167private:
    72     friend class NeverDestroyed<SoupNetworkSession>;
    73 
    74     SoupNetworkSession(SoupCookieJar*);
    75     SoupNetworkSession(SoupSession*);
    76 
    7768    void setHTTPProxy(const char* httpProxy, const char* httpProxyExceptions);
    7869

  • trunk/Source/WebKit2/ChangeLog

    r210728 r210729  
     12017-01-13  Carlos Garcia Campos  <cgarcia@igalia.com>
     2
     3        [SOUP] Simplify cookie storage handling
     4        https://bugs.webkit.org/show_bug.cgi?id=166967
     5
     6        Reviewed by Sergio Villar Senin.
     7
     8        Get the SoupSession from NetworkStorageSession::defaultStorageSession().
     9
     10        * NetworkProcess/CustomProtocols/soup/CustomProtocolManagerSoup.cpp:
     11        (WebKit::CustomProtocolManager::registerScheme): Get the SoupSession from NetworkStorageSession::defaultStorageSession().
     12        * NetworkProcess/efl/NetworkProcessMainEfl.cpp: Ditto.
     13        * NetworkProcess/soup/NetworkProcessSoup.cpp:
     14        (WebKit::NetworkProcess::userPreferredLanguagesChanged): Ditto.
     15        (WebKit::NetworkProcess::platformInitializeNetworkProcess): SoupNetworkSession::clearOldSoupCache is static.
     16        * WebProcess/Cookies/soup/WebCookieManagerSoup.cpp:
     17        (WebKit::WebCookieManager::platformGetHTTPCookieAcceptPolicy): Use the cookie storage from NetworkStorageSession::defaultStorageSession().
     18        (WebKit::WebCookieManager::setCookiePersistentStorage): Ditto.
     19        * WebProcess/WebCoreSupport/soup/WebFrameNetworkingContext.cpp:
     20        (WebKit::WebFrameNetworkingContext::setCookieAcceptPolicyForAllContexts): Ditto.
     21        * WebProcess/efl/WebProcessMainEfl.cpp:
     22
    1232017-01-12  Carlos Garcia Campos  <cgarcia@igalia.com>
    224

  • trunk/Source/WebKit2/NetworkProcess/CustomProtocols/soup/CustomProtocolManagerSoup.cpp

    r210374 r210729  
    2525#include "NetworkProcess.h"
    2626#include "WebKitSoupRequestInputStream.h"
     27#include <WebCore/NetworkStorageSession.h>
    2728#include <WebCore/NotImplemented.h>
    2829#include <WebCore/ResourceError.h>
    … …  
    9192    auto* genericRequestClass = static_cast<SoupRequestClass*>(g_type_class_ref(WEBKIT_TYPE_SOUP_REQUEST_GENERIC));
    9293    genericRequestClass->schemes = const_cast<const char**>(reinterpret_cast<char**>(m_registeredSchemes->pdata));
    93     soup_session_add_feature_by_type(SoupNetworkSession::defaultSession().soupSession(), WEBKIT_TYPE_SOUP_REQUEST_GENERIC);
     94    soup_session_add_feature_by_type(NetworkStorageSession::defaultStorageSession().soupNetworkSession().soupSession(), WEBKIT_TYPE_SOUP_REQUEST_GENERIC);
    9495}
    9596

  • trunk/Source/WebKit2/NetworkProcess/efl/NetworkProcessMainEfl.cpp

    r205556 r210729  
    3131#include "NetworkProcess.h"
    3232#include <Ecore.h>
     33#include <WebCore/NetworkStorageSession.h>
    3334#include <WebCore/SoupNetworkSession.h>
    3435#include <libsoup/soup.h>
    … …  
    4849            return false;
    4950
    50         SoupNetworkSession::defaultSession().setupHTTPProxyFromEnvironment();
     51        NetworkStorageSession::defaultStorageSession().soupNetworkSession().setupHTTPProxyFromEnvironment();
    5152        return true;
    5253    }

  • trunk/Source/WebKit2/NetworkProcess/soup/NetworkProcessSoup.cpp

    r206807 r210729  
    3434#include <WebCore/CertificateInfo.h>
    3535#include <WebCore/FileSystem.h>
     36#include <WebCore/NetworkStorageSession.h>
    3637#include <WebCore/NotImplemented.h>
    3738#include <WebCore/ResourceHandle.h>
    … …  
    4849void NetworkProcess::userPreferredLanguagesChanged(const Vector<String>& languages)
    4950{
    50     SoupNetworkSession::defaultSession().setAcceptLanguages(languages);
     51    NetworkStorageSession::defaultStorageSession().soupNetworkSession().setAcceptLanguages(languages);
    5152}
    5253
    … …  
    5657    m_diskCacheDirectory = parameters.diskCacheDirectory;
    5758
    58     SoupNetworkSession::defaultSession().clearOldSoupCache(WebCore::directoryName(m_diskCacheDirectory));
     59    SoupNetworkSession::clearOldSoupCache(WebCore::directoryName(m_diskCacheDirectory));
    5960
    6061    NetworkCache::Cache::Parameters cacheParameters {

  • trunk/Source/WebKit2/WebProcess/Cookies/soup/WebCookieManagerSoup.cpp

    r185502 r210729  
    3030#include "WebFrameNetworkingContext.h"
    3131#include "WebKitSoupCookieJarSqlite.h"
    32 #include <WebCore/CookieJarSoup.h>
     32#include <WebCore/NetworkStorageSession.h>
    3333#include <WebCore/SoupNetworkSession.h>
    3434#include <libsoup/soup.h>
    … …  
    4747HTTPCookieAcceptPolicy WebCookieManager::platformGetHTTPCookieAcceptPolicy()
    4848{
    49     SoupCookieJar* cookieJar = WebCore::soupCookieJar();
    50     SoupCookieJarAcceptPolicy soupPolicy;
     49    switch (soup_cookie_jar_get_accept_policy(NetworkStorageSession::defaultStorageSession().cookieStorage())) {
     50    case SOUP_COOKIE_JAR_ACCEPT_ALWAYS:
     51        return HTTPCookieAcceptPolicyAlways;
     52    case SOUP_COOKIE_JAR_ACCEPT_NEVER:
     53        return HTTPCookieAcceptPolicyNever;
     54    case SOUP_COOKIE_JAR_ACCEPT_NO_THIRD_PARTY:
     55        return HTTPCookieAcceptPolicyOnlyFromMainDocumentDomain;
     56    }
    5157
    52     HTTPCookieAcceptPolicy policy;
    53 
    54     soupPolicy = soup_cookie_jar_get_accept_policy(cookieJar);
    55     switch (soupPolicy) {
    56     case SOUP_COOKIE_JAR_ACCEPT_ALWAYS:
    57         policy = HTTPCookieAcceptPolicyAlways;
    58         break;
    59     case SOUP_COOKIE_JAR_ACCEPT_NEVER:
    60         policy = HTTPCookieAcceptPolicyNever;
    61         break;
    62     case SOUP_COOKIE_JAR_ACCEPT_NO_THIRD_PARTY:
    63         policy = HTTPCookieAcceptPolicyOnlyFromMainDocumentDomain;
    64         break;
    65     default:
    66         policy = HTTPCookieAcceptPolicyAlways;
    67     }
    68     return policy;
     58    ASSERT_NOT_REACHED();
     59    return HTTPCookieAcceptPolicyOnlyFromMainDocumentDomain;
    6960}
    7061
    … …  
    8374    }
    8475
    85     soup_cookie_jar_set_accept_policy(jar.get(), soup_cookie_jar_get_accept_policy(WebCore::soupCookieJar()));
    86     SoupNetworkSession::defaultSession().setCookieJar(jar.get());
    87     WebCore::setSoupCookieJar(jar.get());
     76    auto& storageSession = NetworkStorageSession::defaultStorageSession();
     77    soup_cookie_jar_set_accept_policy(jar.get(), soup_cookie_jar_get_accept_policy(storageSession.cookieStorage()));
     78    storageSession.soupNetworkSession().setCookieJar(jar.get());
    8879}
    8980

  • trunk/Source/WebKit2/WebProcess/WebCoreSupport/soup/WebFrameNetworkingContext.cpp

    r210728 r210729  
    3232#include "WebFrame.h"
    3333#include "WebPage.h"
    34 #include <WebCore/CookieJarSoup.h>
    3534#include <WebCore/NetworkStorageSession.h>
    3635#include <WebCore/SessionID.h>
    … …  
    6968    }
    7069
    71     SoupCookieJar* cookieJar = WebCore::soupCookieJar();
    72     soup_cookie_jar_set_accept_policy(cookieJar, soupPolicy);
     70    soup_cookie_jar_set_accept_policy(NetworkStorageSession::defaultStorageSession().cookieStorage(), soupPolicy);
    7371
    7472    NetworkStorageSession::forEach([&] (const NetworkStorageSession& session) {
    75         soup_cookie_jar_set_accept_policy(session.soupNetworkSession().cookieJar(), soupPolicy);
     73        soup_cookie_jar_set_accept_policy(session.cookieStorage(), soupPolicy);
    7674    });
    7775}

  • trunk/Source/WebKit2/WebProcess/efl/WebProcessMainEfl.cpp

    r205556 r210729  
    3333#include <Edje.h>
    3434#include <Efreet.h>
     35#include <WebCore/NetworkStorageSession.h>
    3536#include <WebCore/SoupNetworkSession.h>
    3637#include <libsoup/soup.h>
    … …  
    99100            return false;
    100101
    101         SoupNetworkSession::defaultSession().setupHTTPProxyFromEnvironment();
     102        NetworkStorageSession::defaultStorageSession().soupNetworkSession().setupHTTPProxyFromEnvironment();
    102103        return true;
    103104    }
Note: See TracChangeset for help on using the changeset viewer.