Changeset 212283 in webkit


Ignore:
Timestamp:
Feb 14, 2017 2:43:14 AM (7 years ago)
Author:
Carlos Garcia Campos
Message:

CookieManager only works with the default session
​https://bugs.webkit.org/show_bug.cgi?id=168229

Reviewed by Alex Christensen.

Source/WebCore:

Update cookie observer API to use a std::function instead of a function pointer and make it work with multiple
sessions in the backends that support it.

  • platform/network/CookieStorage.h:
  • platform/network/cf/CookieStorageCFNet.cpp:

(WebCore::cookieChangeCallbackMap):
(WebCore::notifyCookiesChanged):
(WebCore::startObservingCookieChanges):
(WebCore::stopObservingCookieChanges):

  • platform/network/mac/CookieStorageMac.mm:

(-[WebCookieStorageObjCAdapter startListeningForCookieChangeNotificationsWithCallback:]):
(-[WebCookieStorageObjCAdapter stopListeningForCookieChangeNotifications]):
(WebCore::startObservingCookieChanges):
(WebCore::stopObservingCookieChanges):

  • platform/network/soup/CookieStorageSoup.cpp:

(WebCore::cookieChangeCallbackMap):
(WebCore::soupCookiesChanged):
(WebCore::startObservingCookieChanges):
(WebCore::stopObservingCookieChanges):

Source/WebKit2:

Make CookieManager session aware by adding a SessionID parameter to all its functions, and update all the callers
to pass the default session ID, preserving the current
behavior. WebCookieManagerProxy::startObservingCookieChanges() now also receives an optional callback to be
called on every change.

  • UIProcess/API/C/WKCookieManager.cpp:

(WKCookieManagerGetHostnamesWithCookies):
(WKCookieManagerDeleteCookiesForHostname):
(WKCookieManagerDeleteAllCookies):
(WKCookieManagerDeleteAllCookiesModifiedAfterDate):
(WKCookieManagerStartObservingCookieChanges):
(WKCookieManagerStopObservingCookieChanges):

  • UIProcess/API/gtk/WebKitCookieManager.cpp:

(_WebKitCookieManagerPrivate::~_WebKitCookieManagerPrivate):
(webkitCookieManagerCreate):
(webkit_cookie_manager_set_persistent_storage):
(webkit_cookie_manager_get_domains_with_cookies):
(webkit_cookie_manager_delete_cookies_for_domain):
(webkit_cookie_manager_delete_all_cookies):

  • UIProcess/Automation/WebAutomationSession.cpp:

(WebKit::WebAutomationSession::addSingleCookie):
(WebKit::WebAutomationSession::deleteAllCookies):

  • UIProcess/WebCookieManagerProxy.cpp:

(WebKit::WebCookieManagerProxy::getHostnamesWithCookies):
(WebKit::WebCookieManagerProxy::deleteCookiesForHostname):
(WebKit::WebCookieManagerProxy::deleteAllCookies):
(WebKit::WebCookieManagerProxy::deleteAllCookiesModifiedSince):
(WebKit::WebCookieManagerProxy::addCookie):
(WebKit::WebCookieManagerProxy::startObservingCookieChanges):
(WebKit::WebCookieManagerProxy::stopObservingCookieChanges):
(WebKit::WebCookieManagerProxy::cookiesDidChange):

  • UIProcess/WebCookieManagerProxy.h:
  • UIProcess/WebCookieManagerProxy.messages.in:
  • WebProcess/Cookies/WebCookieManager.cpp:

(WebKit::WebCookieManager::WebCookieManager):
(WebKit::WebCookieManager::getHostnamesWithCookies):
(WebKit::WebCookieManager::deleteCookiesForHostname):
(WebKit::WebCookieManager::deleteAllCookies):
(WebKit::WebCookieManager::deleteAllCookiesModifiedSince):
(WebKit::WebCookieManager::addCookie):
(WebKit::WebCookieManager::startObservingCookieChanges):
(WebKit::WebCookieManager::stopObservingCookieChanges):

  • WebProcess/Cookies/WebCookieManager.h:
  • WebProcess/Cookies/WebCookieManager.messages.in:
Location:
trunk/Source
Files:
15 edited

Legend:

Unmodified
Added
Removed

  • trunk/Source/WebCore/ChangeLog

    r212280 r212283  
     12017-02-14  Carlos Garcia Campos  <cgarcia@igalia.com>
     2
     3        CookieManager only works with the default session
     4        https://bugs.webkit.org/show_bug.cgi?id=168229
     5
     6        Reviewed by Alex Christensen.
     7
     8        Update cookie observer API to use a std::function instead of a function pointer and make it work with multiple
     9        sessions in the backends that support it.
     10
     11        * platform/network/CookieStorage.h:
     12        * platform/network/cf/CookieStorageCFNet.cpp:
     13        (WebCore::cookieChangeCallbackMap):
     14        (WebCore::notifyCookiesChanged):
     15        (WebCore::startObservingCookieChanges):
     16        (WebCore::stopObservingCookieChanges):
     17        * platform/network/mac/CookieStorageMac.mm:
     18        (-[WebCookieStorageObjCAdapter startListeningForCookieChangeNotificationsWithCallback:]):
     19        (-[WebCookieStorageObjCAdapter stopListeningForCookieChangeNotifications]):
     20        (WebCore::startObservingCookieChanges):
     21        (WebCore::stopObservingCookieChanges):
     22        * platform/network/soup/CookieStorageSoup.cpp:
     23        (WebCore::cookieChangeCallbackMap):
     24        (WebCore::soupCookiesChanged):
     25        (WebCore::startObservingCookieChanges):
     26        (WebCore::stopObservingCookieChanges):
     27
    1282017-02-13  Antoine Quint  <graouts@apple.com>
    229

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

    r172849 r212283  
    2424 */
    2525
    26 #ifndef CookieStorage_h
    27 #define CookieStorage_h
     26#pragma once
     27
     28#include <functional>
    2829
    2930namespace WebCore {
    3031
    31 // These are always observing the shared cookie storage, even when in private browsing mode.
     32class NetworkStorageSession;
    3233
    33 typedef void(*CookieChangeCallbackPtr)();
    34 WEBCORE_EXPORT void startObservingCookieChanges(CookieChangeCallbackPtr);
    35 WEBCORE_EXPORT void stopObservingCookieChanges();
     34WEBCORE_EXPORT void startObservingCookieChanges(const NetworkStorageSession&, std::function<void ()>&&);
     35WEBCORE_EXPORT void stopObservingCookieChanges(const NetworkStorageSession&);
    3636
    3737}
    3838
    39 #endif

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

    r188787 r212283  
    2828
    2929#include "NetworkStorageSession.h"
     30#include <wtf/HashMap.h>
    3031#include <wtf/MainThread.h>
     32#include <wtf/NeverDestroyed.h>
    3133
    3234#if PLATFORM(COCOA)
    … …  
    4244#if PLATFORM(WIN)
    4345
    44 static CookieChangeCallbackPtr cookieChangeCallback;
     46static HashMap<CFHTTPCookieStorageRef, std::function<void ()>>& cookieChangeCallbackMap()
     47{
     48    static NeverDestroyed<HashMap<CFHTTPCookieStorageRef, std::function<void ()>>> map;
     49    return map;
     50}
    4551
    46 static void notifyCookiesChanged(CFHTTPCookieStorageRef, void *)
     52static void notifyCookiesChanged(CFHTTPCookieStorageRef cookieStorage, void *)
    4753{
    48     callOnMainThread([] {
    49         cookieChangeCallback();
     54    callOnMainThread([cookieStorage] {
     55        if (auto callback = cookieChangeCallbackMap().get(cookieStorage))
     56            callback();
    5057    });
    5158}
    … …  
    6269}
    6370
    64 void startObservingCookieChanges(CookieChangeCallbackPtr callback)
     71void startObservingCookieChanges(const NetworkStorageSession& storageSession, std::function<void ()>&& callback)
    6572{
    6673    ASSERT(isMainThread());
    67 
    68     ASSERT(!cookieChangeCallback);
    69     cookieChangeCallback = callback;
    7074
    7175    CFRunLoopRef runLoop = cookieStorageObserverRunLoop();
    7276    ASSERT(runLoop);
    7377
    74     RetainPtr<CFHTTPCookieStorageRef> cookieStorage = NetworkStorageSession::defaultStorageSession().cookieStorage();
     78    RetainPtr<CFHTTPCookieStorageRef> cookieStorage = storageSession.cookieStorage();
    7579    ASSERT(cookieStorage);
     80
     81    ASSERT(cookieChangeCallbackMap().contains(cookieStorage.get()));
     82    cookieChangeCallbackMap().add(cookieStorage.get(), WTFMove(callback));
    7683
    7784    CFHTTPCookieStorageScheduleWithRunLoop(cookieStorage.get(), runLoop, kCFRunLoopCommonModes);
    … …  
    7986}
    8087
    81 void stopObservingCookieChanges()
     88void stopObservingCookieChanges(const NetworkStorageSession& storageSession)
    8289{
    8390    ASSERT(isMainThread());
    84 
    85     cookieChangeCallback = 0;
    8691
    8792    CFRunLoopRef runLoop = cookieStorageObserverRunLoop();
    8893    ASSERT(runLoop);
    8994
    90     RetainPtr<CFHTTPCookieStorageRef> cookieStorage = NetworkStorageSession::defaultStorageSession().cookieStorage();
     95    RetainPtr<CFHTTPCookieStorageRef> cookieStorage = storageSession.cookieStorage();
    9196    ASSERT(cookieStorage);
     97
     98    cookieChangeCallbackMap().remove(cookieStorage.get());
    9299
    93100    CFHTTPCookieStorageRemoveObserver(cookieStorage.get(), runLoop, kCFRunLoopDefaultMode, notifyCookiesChanged, 0);

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

    r204466 r212283  
    3232
    3333@interface WebCookieStorageObjCAdapter : NSObject {
    34     CookieChangeCallbackPtr m_cookieChangeCallback;
     34    std::function<void ()> m_cookieChangeCallback;
    3535}
    3636-(void)notifyCookiesChangedOnMainThread;
    3737-(void)cookiesChangedNotificationHandler:(NSNotification *)notification;
    38 -(void)startListeningForCookieChangeNotificationsWithCallback:(CookieChangeCallbackPtr)callback;
     38-(void)startListeningForCookieChangeNotificationsWithCallback:(std::function<void ()>&&)callback;
    3939-(void)stopListeningForCookieChangeNotifications;
    4040@end
    … …  
    5454}
    5555
    56 -(void)startListeningForCookieChangeNotificationsWithCallback:(CookieChangeCallbackPtr)callback
     56-(void)startListeningForCookieChangeNotificationsWithCallback:(std::function<void ()>&&)callback
    5757{
    5858    ASSERT(!m_cookieChangeCallback);
    59     m_cookieChangeCallback = callback;
     59    m_cookieChangeCallback = WTFMove(callback);
    6060    [[NSNotificationCenter defaultCenter] addObserver:self selector:@selector(cookiesChangedNotificationHandler:) name:NSHTTPCookieManagerCookiesChangedNotification object:[NSHTTPCookieStorage sharedHTTPCookieStorage]];
    6161}
    … …  
    6464{
    6565    [[NSNotificationCenter defaultCenter] removeObserver:self name:NSHTTPCookieManagerCookiesChangedNotification object:nil];
    66     m_cookieChangeCallback = 0;
     66    m_cookieChangeCallback = nullptr;
    6767}
    6868
    … …  
    7373static WebCookieStorageObjCAdapter *cookieStorageAdapter;
    7474
    75 void startObservingCookieChanges(CookieChangeCallbackPtr callback)
     75void startObservingCookieChanges(const NetworkStorageSession&, std::function<void ()>&& callback)
    7676{
    7777    if (!cookieStorageAdapter)
    7878        cookieStorageAdapter = [[WebCookieStorageObjCAdapter alloc] init];
    79     [cookieStorageAdapter startListeningForCookieChangeNotificationsWithCallback:callback];
     79    [cookieStorageAdapter startListeningForCookieChangeNotificationsWithCallback:WTFMove(callback)];
    8080}
    8181
    82 void stopObservingCookieChanges()
     82void stopObservingCookieChanges(const NetworkStorageSession&)
    8383{
    8484    // cookieStorageAdapter can be nil here, if the WebProcess crashed and was restarted between

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

    r210729 r212283  
    2424#include "NetworkStorageSession.h"
    2525#include <libsoup/soup.h>
     26#include <wtf/HashMap.h>
     27#include <wtf/NeverDestroyed.h>
    2628
    2729namespace WebCore {
    2830
    29 static CookieChangeCallbackPtr cookieChangeCallback;
     31static HashMap<SoupCookieJar*, std::function<void ()>>& cookieChangeCallbackMap()
     32{
     33    static NeverDestroyed<HashMap<SoupCookieJar*, std::function<void ()>>> map;
     34    return map;
     35}
    3036
    3137static void soupCookiesChanged(SoupCookieJar* jar)
    3238{
    33     if (jar != NetworkStorageSession::defaultStorageSession().cookieStorage())
    34         return;
    35     cookieChangeCallback();
     39    if (auto callback = cookieChangeCallbackMap().get(jar))
     40        callback();
    3641}
    3742
    38 void startObservingCookieChanges(CookieChangeCallbackPtr callback)
     43void startObservingCookieChanges(const NetworkStorageSession& storageSession, std::function<void ()>&& callback)
    3944{
    40     ASSERT(!cookieChangeCallback);
    41     cookieChangeCallback = callback;
    42 
    43     g_signal_connect(NetworkStorageSession::defaultStorageSession().cookieStorage(), "changed", G_CALLBACK(soupCookiesChanged), 0);
     45    auto* jar = storageSession.cookieStorage();
     46    ASSERT(!cookieChangeCallbackMap().contains(jar));
     47    cookieChangeCallbackMap().add(jar, WTFMove(callback));
     48    g_signal_connect(jar, "changed", G_CALLBACK(soupCookiesChanged), nullptr);
    4449}
    4550
    46 void stopObservingCookieChanges()
     51void stopObservingCookieChanges(const NetworkStorageSession& storageSession)
    4752{
    48     g_signal_handlers_disconnect_by_func(NetworkStorageSession::defaultStorageSession().cookieStorage(), reinterpret_cast<void*>(soupCookiesChanged), nullptr);
    49     cookieChangeCallback = nullptr;
     53    auto* jar = storageSession.cookieStorage();
     54    ASSERT(cookieChangeCallbackMap().contains(jar));
     55    cookieChangeCallbackMap().remove(jar);
     56    g_signal_handlers_disconnect_by_func(jar, reinterpret_cast<void*>(soupCookiesChanged), nullptr);
    5057}
    5158

  • trunk/Source/WebKit2/ChangeLog

    r212281 r212283  
     12017-02-14  Carlos Garcia Campos  <cgarcia@igalia.com>
     2
     3        CookieManager only works with the default session
     4        https://bugs.webkit.org/show_bug.cgi?id=168229
     5
     6        Reviewed by Alex Christensen.
     7
     8        Make CookieManager session aware by adding a SessionID parameter to all its functions, and update all the callers
     9        to pass the default session ID, preserving the current
     10        behavior. WebCookieManagerProxy::startObservingCookieChanges() now also receives an optional callback to be
     11        called on every change.
     12
     13        * UIProcess/API/C/WKCookieManager.cpp:
     14        (WKCookieManagerGetHostnamesWithCookies):
     15        (WKCookieManagerDeleteCookiesForHostname):
     16        (WKCookieManagerDeleteAllCookies):
     17        (WKCookieManagerDeleteAllCookiesModifiedAfterDate):
     18        (WKCookieManagerStartObservingCookieChanges):
     19        (WKCookieManagerStopObservingCookieChanges):
     20        * UIProcess/API/gtk/WebKitCookieManager.cpp:
     21        (_WebKitCookieManagerPrivate::~_WebKitCookieManagerPrivate):
     22        (webkitCookieManagerCreate):
     23        (webkit_cookie_manager_set_persistent_storage):
     24        (webkit_cookie_manager_get_domains_with_cookies):
     25        (webkit_cookie_manager_delete_cookies_for_domain):
     26        (webkit_cookie_manager_delete_all_cookies):
     27        * UIProcess/Automation/WebAutomationSession.cpp:
     28        (WebKit::WebAutomationSession::addSingleCookie):
     29        (WebKit::WebAutomationSession::deleteAllCookies):
     30        * UIProcess/WebCookieManagerProxy.cpp:
     31        (WebKit::WebCookieManagerProxy::getHostnamesWithCookies):
     32        (WebKit::WebCookieManagerProxy::deleteCookiesForHostname):
     33        (WebKit::WebCookieManagerProxy::deleteAllCookies):
     34        (WebKit::WebCookieManagerProxy::deleteAllCookiesModifiedSince):
     35        (WebKit::WebCookieManagerProxy::addCookie):
     36        (WebKit::WebCookieManagerProxy::startObservingCookieChanges):
     37        (WebKit::WebCookieManagerProxy::stopObservingCookieChanges):
     38        (WebKit::WebCookieManagerProxy::cookiesDidChange):
     39        * UIProcess/WebCookieManagerProxy.h:
     40        * UIProcess/WebCookieManagerProxy.messages.in:
     41        * WebProcess/Cookies/WebCookieManager.cpp:
     42        (WebKit::WebCookieManager::WebCookieManager):
     43        (WebKit::WebCookieManager::getHostnamesWithCookies):
     44        (WebKit::WebCookieManager::deleteCookiesForHostname):
     45        (WebKit::WebCookieManager::deleteAllCookies):
     46        (WebKit::WebCookieManager::deleteAllCookiesModifiedSince):
     47        (WebKit::WebCookieManager::addCookie):
     48        (WebKit::WebCookieManager::startObservingCookieChanges):
     49        (WebKit::WebCookieManager::stopObservingCookieChanges):
     50        * WebProcess/Cookies/WebCookieManager.h:
     51        * WebProcess/Cookies/WebCookieManager.messages.in:
     52
    1532017-02-14  Tomas Popela  <tpopela@redhat.com>
    254

  • trunk/Source/WebKit2/UIProcess/API/C/WKCookieManager.cpp

    r176963 r212283  
    4444void WKCookieManagerGetHostnamesWithCookies(WKCookieManagerRef cookieManagerRef, void* context, WKCookieManagerGetCookieHostnamesFunction callback)
    4545{
    46     toImpl(cookieManagerRef)->getHostnamesWithCookies(toGenericCallbackFunction(context, callback));
     46    toImpl(cookieManagerRef)->getHostnamesWithCookies(WebCore::SessionID::defaultSessionID(), toGenericCallbackFunction(context, callback));
    4747}
    4848
    4949void WKCookieManagerDeleteCookiesForHostname(WKCookieManagerRef cookieManagerRef, WKStringRef hostname)
    5050{
    51     toImpl(cookieManagerRef)->deleteCookiesForHostname(toImpl(hostname)->string());
     51    toImpl(cookieManagerRef)->deleteCookiesForHostname(WebCore::SessionID::defaultSessionID(), toImpl(hostname)->string());
    5252}
    5353
    5454void WKCookieManagerDeleteAllCookies(WKCookieManagerRef cookieManagerRef)
    5555{
    56     toImpl(cookieManagerRef)->deleteAllCookies();
     56    toImpl(cookieManagerRef)->deleteAllCookies(WebCore::SessionID::defaultSessionID());
    5757}
    5858
    … …  
    6262
    6363    auto time = system_clock::time_point(duration_cast<system_clock::duration>(duration<double>(date)));
    64     toImpl(cookieManagerRef)->deleteAllCookiesModifiedSince(time);
     64    toImpl(cookieManagerRef)->deleteAllCookiesModifiedSince(WebCore::SessionID::defaultSessionID(), time);
    6565}
    6666
    … …  
    7777void WKCookieManagerStartObservingCookieChanges(WKCookieManagerRef cookieManager)
    7878{
    79     toImpl(cookieManager)->startObservingCookieChanges();
     79    toImpl(cookieManager)->startObservingCookieChanges(WebCore::SessionID::defaultSessionID());
    8080}
    8181
    8282void WKCookieManagerStopObservingCookieChanges(WKCookieManagerRef cookieManager)
    8383{
    84     toImpl(cookieManager)->stopObservingCookieChanges();
     84    toImpl(cookieManager)->stopObservingCookieChanges(WebCore::SessionID::defaultSessionID());
    8585}

  • trunk/Source/WebKit2/UIProcess/API/gtk/WebKitCookieManager.cpp

    r185502 r212283  
    5656    ~_WebKitCookieManagerPrivate()
    5757    {
    58         webCookieManager->stopObservingCookieChanges();
     58        webCookieManager->stopObservingCookieChanges(WebCore::SessionID::defaultSessionID());
    5959    }
    6060
    … …  
    146146    };
    147147    WKCookieManagerSetClient(toAPI(webCookieManager), &wkCookieManagerClient.base);
    148     manager->priv->webCookieManager->startObservingCookieChanges();
     148    manager->priv->webCookieManager->startObservingCookieChanges(WebCore::SessionID::defaultSessionID());
    149149
    150150    return manager;
    … …  
    170170    g_return_if_fail(filename);
    171171
    172     manager->priv->webCookieManager->stopObservingCookieChanges();
     172    manager->priv->webCookieManager->stopObservingCookieChanges(WebCore::SessionID::defaultSessionID());
    173173    manager->priv->webCookieManager->setCookiePersistentStorage(String::fromUTF8(filename), toSoupCookiePersistentStorageType(storage));
    174     manager->priv->webCookieManager->startObservingCookieChanges();
     174    manager->priv->webCookieManager->startObservingCookieChanges(WebCore::SessionID::defaultSessionID());
    175175}
    176176
    … …  
    270270
    271271    GTask* task = g_task_new(manager, cancellable, callback, userData);
    272     manager->priv->webCookieManager->getHostnamesWithCookies(toGenericCallbackFunction(task, webkitCookieManagerGetDomainsWithCookiesCallback));
     272    manager->priv->webCookieManager->getHostnamesWithCookies(WebCore::SessionID::defaultSessionID(), toGenericCallbackFunction(task, webkitCookieManagerGetDomainsWithCookiesCallback));
    273273}
    274274
    … …  
    306306    g_return_if_fail(domain);
    307307
    308     manager->priv->webCookieManager->deleteCookiesForHostname(String::fromUTF8(domain));
     308    manager->priv->webCookieManager->deleteCookiesForHostname(WebCore::SessionID::defaultSessionID(), String::fromUTF8(domain));
    309309}
    310310
    … …  
    319319    g_return_if_fail(WEBKIT_IS_COOKIE_MANAGER(manager));
    320320
    321     manager->priv->webCookieManager->deleteAllCookies();
    322 }
     321    manager->priv->webCookieManager->deleteAllCookies(WebCore::SessionID::defaultSessionID());
     322}

  • trunk/Source/WebKit2/UIProcess/Automation/WebAutomationSession.cpp

    r212115 r212283  
    728728
    729729    WebCookieManagerProxy* cookieManager = m_processPool->supplement<WebCookieManagerProxy>();
    730     cookieManager->addCookie(cookie, activeURL.host());
     730    cookieManager->addCookie(WebCore::SessionID::defaultSessionID(), cookie, activeURL.host());
    731731
    732732    callback->sendSuccess();
    … …  
    743743
    744744    WebCookieManagerProxy* cookieManager = m_processPool->supplement<WebCookieManagerProxy>();
    745     cookieManager->deleteCookiesForHostname(activeURL.host());
     745    cookieManager->deleteCookiesForHostname(WebCore::SessionID::defaultSessionID(), activeURL.host());
    746746}
    747747

  • trunk/Source/WebKit2/UIProcess/WebCookieManagerProxy.cpp

    r202242 r212283  
    9494}
    9595
    96 void WebCookieManagerProxy::getHostnamesWithCookies(std::function<void (API::Array*, CallbackBase::Error)> callbackFunction)
     96void WebCookieManagerProxy::getHostnamesWithCookies(WebCore::SessionID sessionID, std::function<void (API::Array*, CallbackBase::Error)> callbackFunction)
    9797{
    9898    auto callback = ArrayCallback::create(WTFMove(callbackFunction));
    … …  
    100100    m_arrayCallbacks.set(callbackID, WTFMove(callback));
    101101
    102     processPool()->sendToNetworkingProcessRelaunchingIfNecessary(Messages::WebCookieManager::GetHostnamesWithCookies(callbackID));
     102    processPool()->sendToNetworkingProcessRelaunchingIfNecessary(Messages::WebCookieManager::GetHostnamesWithCookies(sessionID, callbackID));
    103103}
    104    
     104
    105105void WebCookieManagerProxy::didGetHostnamesWithCookies(const Vector<String>& hostnames, uint64_t callbackID)
    106106{
    … …  
    114114}
    115115
    116 void WebCookieManagerProxy::deleteCookiesForHostname(const String& hostname)
     116void WebCookieManagerProxy::deleteCookiesForHostname(WebCore::SessionID sessionID, const String& hostname)
    117117{
    118     processPool()->sendToNetworkingProcessRelaunchingIfNecessary(Messages::WebCookieManager::DeleteCookiesForHostname(hostname));
     118    processPool()->sendToNetworkingProcessRelaunchingIfNecessary(Messages::WebCookieManager::DeleteCookiesForHostname(sessionID, hostname));
    119119}
    120120
    121 void WebCookieManagerProxy::deleteAllCookies()
     121void WebCookieManagerProxy::deleteAllCookies(WebCore::SessionID sessionID)
    122122{
    123     processPool()->sendToNetworkingProcessRelaunchingIfNecessary(Messages::WebCookieManager::DeleteAllCookies());
     123    processPool()->sendToNetworkingProcessRelaunchingIfNecessary(Messages::WebCookieManager::DeleteAllCookies(sessionID));
    124124}
    125125
    126 void WebCookieManagerProxy::deleteAllCookiesModifiedSince(std::chrono::system_clock::time_point time)
     126void WebCookieManagerProxy::deleteAllCookiesModifiedSince(WebCore::SessionID sessionID, std::chrono::system_clock::time_point time)
    127127{
    128     processPool()->sendToNetworkingProcessRelaunchingIfNecessary(Messages::WebCookieManager::DeleteAllCookiesModifiedSince(time));
     128    processPool()->sendToNetworkingProcessRelaunchingIfNecessary(Messages::WebCookieManager::DeleteAllCookiesModifiedSince(sessionID, time));
    129129}
    130130
    131 void WebCookieManagerProxy::addCookie(const WebCore::Cookie& cookie, const String& hostname)
     131void WebCookieManagerProxy::addCookie(WebCore::SessionID sessionID, const WebCore::Cookie& cookie, const String& hostname)
    132132{
    133     processPool()->sendToNetworkingProcessRelaunchingIfNecessary(Messages::WebCookieManager::AddCookie(cookie, hostname));
     133    processPool()->sendToNetworkingProcessRelaunchingIfNecessary(Messages::WebCookieManager::AddCookie(sessionID, cookie, hostname));
    134134}
    135135
    136 void WebCookieManagerProxy::startObservingCookieChanges()
     136void WebCookieManagerProxy::startObservingCookieChanges(WebCore::SessionID sessionID, std::function<void ()>&& callback)
    137137{
    138     processPool()->sendToNetworkingProcessRelaunchingIfNecessary(Messages::WebCookieManager::StartObservingCookieChanges());
     138    if (callback)
     139        m_cookieObservers.set(sessionID, WTFMove(callback));
     140    processPool()->sendToNetworkingProcessRelaunchingIfNecessary(Messages::WebCookieManager::StartObservingCookieChanges(sessionID));
    139141}
    140142
    141 void WebCookieManagerProxy::stopObservingCookieChanges()
     143void WebCookieManagerProxy::stopObservingCookieChanges(WebCore::SessionID sessionID)
    142144{
    143     processPool()->sendToNetworkingProcessRelaunchingIfNecessary(Messages::WebCookieManager::StopObservingCookieChanges());
     145    m_cookieObservers.remove(sessionID);
     146    processPool()->sendToNetworkingProcessRelaunchingIfNecessary(Messages::WebCookieManager::StopObservingCookieChanges(sessionID));
    144147}
    145148
    146 void WebCookieManagerProxy::cookiesDidChange()
     149void WebCookieManagerProxy::cookiesDidChange(WebCore::SessionID sessionID)
    147150{
    148151    m_client.cookiesDidChange(this);
     152    if (auto callback = m_cookieObservers.get(sessionID))
     153        callback();
    149154}
    150155

  • trunk/Source/WebKit2/UIProcess/WebCookieManagerProxy.h

    r204668 r212283  
    3232#include "WebContextSupplement.h"
    3333#include "WebCookieManagerProxyClient.h"
     34#include <WebCore/SessionID.h>
    3435#include <wtf/PassRefPtr.h>
    3536#include <wtf/RefPtr.h>
    … …  
    6566    void initializeClient(const WKCookieManagerClientBase*);
    6667   
    67     void getHostnamesWithCookies(std::function<void (API::Array*, CallbackBase::Error)>);
    68     void deleteCookiesForHostname(const String& hostname);
    69     void deleteAllCookies();
    70     void deleteAllCookiesModifiedSince(std::chrono::system_clock::time_point);
    71     void addCookie(const WebCore::Cookie&, const String& hostname);
     68    void getHostnamesWithCookies(WebCore::SessionID, std::function<void (API::Array*, CallbackBase::Error)>);
     69    void deleteCookiesForHostname(WebCore::SessionID, const String& hostname);
     70    void deleteAllCookies(WebCore::SessionID);
     71    void deleteAllCookiesModifiedSince(WebCore::SessionID, std::chrono::system_clock::time_point);
     72    void addCookie(WebCore::SessionID, const WebCore::Cookie&, const String& hostname);
    7273
    7374    void setHTTPCookieAcceptPolicy(HTTPCookieAcceptPolicy);
    7475    void getHTTPCookieAcceptPolicy(std::function<void (HTTPCookieAcceptPolicy, CallbackBase::Error)>);
    7576
    76     void startObservingCookieChanges();
    77     void stopObservingCookieChanges();
     77    void startObservingCookieChanges(WebCore::SessionID, std::function<void ()>&& = nullptr);
     78    void stopObservingCookieChanges(WebCore::SessionID);
    7879
    7980#if USE(SOUP)
    … …  
    9192    void didGetHTTPCookieAcceptPolicy(uint32_t policy, uint64_t callbackID);
    9293
    93     void cookiesDidChange();
     94    void cookiesDidChange(WebCore::SessionID);
    9495
    9596    // WebContextSupplement
    … …  
    110111    HashMap<uint64_t, RefPtr<HTTPCookieAcceptPolicyCallback>> m_httpCookieAcceptPolicyCallbacks;
    111112
     113    HashMap<WebCore::SessionID, std::function<void ()>> m_cookieObservers;
     114
    112115    WebCookieManagerProxyClient m_client;
    113116

  • trunk/Source/WebKit2/UIProcess/WebCookieManagerProxy.messages.in

    r160022 r212283  
    2525    DidGetHTTPCookieAcceptPolicy(uint32_t policy, uint64_t callbackID);
    2626   
    27     CookiesDidChange()
     27    CookiesDidChange(WebCore::SessionID sessionID)
    2828}

  • trunk/Source/WebKit2/WebProcess/Cookies/WebCookieManager.cpp

    r199197 r212283  
    4343namespace WebKit {
    4444
    45 static WebCookieManager* sharedCookieManager;
    46 
    4745const char* WebCookieManager::supplementName()
    4846{
    … …  
    5452{
    5553    m_process->addMessageReceiver(Messages::WebCookieManager::messageReceiverName(), *this);
    56 
    57     ASSERT(!sharedCookieManager);
    58     sharedCookieManager = this;
    5954}
    6055
    61 void WebCookieManager::getHostnamesWithCookies(uint64_t callbackID)
     56void WebCookieManager::getHostnamesWithCookies(SessionID sessionID, uint64_t callbackID)
    6257{
    6358    HashSet<String> hostnames;
    64     WebCore::getHostnamesWithCookies(NetworkStorageSession::defaultStorageSession(), hostnames);
     59    if (auto* storageSession = NetworkStorageSession::storageSession(sessionID))
     60        WebCore::getHostnamesWithCookies(*storageSession, hostnames);
    6561
    6662    Vector<String> hostnameList;
    … …  
    7066}
    7167
    72 void WebCookieManager::deleteCookiesForHostname(const String& hostname)
     68void WebCookieManager::deleteCookiesForHostname(SessionID sessionID, const String& hostname)
    7369{
    74     WebCore::deleteCookiesForHostnames(NetworkStorageSession::defaultStorageSession(), { hostname });
     70    if (auto* storageSession = NetworkStorageSession::storageSession(sessionID))
     71        WebCore::deleteCookiesForHostnames(*storageSession, { hostname });
    7572}
    7673
    77 void WebCookieManager::deleteAllCookies()
     74void WebCookieManager::deleteAllCookies(SessionID sessionID)
    7875{
    79     WebCore::deleteAllCookies(NetworkStorageSession::defaultStorageSession());
     76    if (auto* storageSession = NetworkStorageSession::storageSession(sessionID))
     77        WebCore::deleteAllCookies(*storageSession);
    8078}
    8179
    82 void WebCookieManager::deleteAllCookiesModifiedSince(std::chrono::system_clock::time_point time)
     80void WebCookieManager::deleteAllCookiesModifiedSince(SessionID sessionID, std::chrono::system_clock::time_point time)
    8381{
    84     WebCore::deleteAllCookiesModifiedSince(NetworkStorageSession::defaultStorageSession(), time);
     82    if (auto* storageSession = NetworkStorageSession::storageSession(sessionID))
     83        WebCore::deleteAllCookiesModifiedSince(*storageSession, time);
    8584}
    8685
    87 void WebCookieManager::addCookie(const Cookie& cookie, const String& hostname)
     86void WebCookieManager::addCookie(SessionID sessionID, const Cookie& cookie, const String& hostname)
    8887{
    89     WebCore::addCookie(NetworkStorageSession::defaultStorageSession(), URL(URL(), hostname), cookie);
     88    if (auto* storageSession = NetworkStorageSession::storageSession(sessionID))
     89        WebCore::addCookie(*storageSession, URL(URL(), hostname), cookie);
    9090}
    9191
    92 void WebCookieManager::startObservingCookieChanges()
     92void WebCookieManager::startObservingCookieChanges(SessionID sessionID)
    9393{
    94     WebCore::startObservingCookieChanges(cookiesDidChange);
     94    if (auto* storageSession = NetworkStorageSession::storageSession(sessionID)) {
     95        WebCore::startObservingCookieChanges(*storageSession, [this, sessionID] {
     96            ASSERT(RunLoop::isMain());
     97            m_process->send(Messages::WebCookieManagerProxy::CookiesDidChange(sessionID), 0);
     98        });
     99    }
    95100}
    96101
    97 void WebCookieManager::stopObservingCookieChanges()
     102void WebCookieManager::stopObservingCookieChanges(SessionID sessionID)
    98103{
    99     WebCore::stopObservingCookieChanges();
    100 }
    101 
    102 void WebCookieManager::cookiesDidChange()
    103 {
    104     sharedCookieManager->dispatchCookiesDidChange();
    105 }
    106 
    107 void WebCookieManager::dispatchCookiesDidChange()
    108 {
    109     ASSERT(RunLoop::isMain());
    110     m_process->send(Messages::WebCookieManagerProxy::CookiesDidChange(), 0);
     104    if (auto* storageSession = NetworkStorageSession::storageSession(sessionID))
     105        WebCore::stopObservingCookieChanges(*storageSession);
    111106}
    112107

  • trunk/Source/WebKit2/WebProcess/Cookies/WebCookieManager.h

    r204668 r212283  
    3131#include "NetworkProcessSupplement.h"
    3232#include "WebProcessSupplement.h"
     33#include <WebCore/SessionID.h>
    3334#include <stdint.h>
    3435#include <wtf/Forward.h>
    … …  
    6364    void didReceiveMessage(IPC::Connection&, IPC::Decoder&) override;
    6465
    65     void getHostnamesWithCookies(uint64_t callbackID);
    66     void deleteCookiesForHostname(const String&);
    67     void deleteAllCookies();
    68     void deleteAllCookiesModifiedSince(std::chrono::system_clock::time_point);
    69     void addCookie(const WebCore::Cookie&, const String& hostname);
     66    void getHostnamesWithCookies(WebCore::SessionID, uint64_t callbackID);
     67    void deleteCookiesForHostname(WebCore::SessionID, const String&);
     68    void deleteAllCookies(WebCore::SessionID);
     69    void deleteAllCookiesModifiedSince(WebCore::SessionID, std::chrono::system_clock::time_point);
     70    void addCookie(WebCore::SessionID, const WebCore::Cookie&, const String& hostname);
    7071
    7172    void platformSetHTTPCookieAcceptPolicy(HTTPCookieAcceptPolicy);
    … …  
    7374    HTTPCookieAcceptPolicy platformGetHTTPCookieAcceptPolicy();
    7475
    75     void startObservingCookieChanges();
    76     void stopObservingCookieChanges();
    77 
    78     static void cookiesDidChange();
    79     void dispatchCookiesDidChange();
    80 
     76    void startObservingCookieChanges(WebCore::SessionID);
     77    void stopObservingCookieChanges(WebCore::SessionID);
    8178
    8279    ChildProcess* m_process;

  • trunk/Source/WebKit2/WebProcess/Cookies/WebCookieManager.messages.in

    r199197 r212283  
    2525 
    2626 messages -> WebCookieManager {
    27     void GetHostnamesWithCookies(uint64_t callbackID)
    28     void DeleteCookiesForHostname(String hostname)
    29     void DeleteAllCookies()
    30     void DeleteAllCookiesModifiedSince(std::chrono::system_clock::time_point time)
    31     void AddCookie(struct WebCore::Cookie cookie, String hostname)
     27    void GetHostnamesWithCookies(WebCore::SessionID sessionID, uint64_t callbackID)
     28    void DeleteCookiesForHostname(WebCore::SessionID sessionID, String hostname)
     29    void DeleteAllCookies(WebCore::SessionID sessionID)
     30    void DeleteAllCookiesModifiedSince(WebCore::SessionID sessionID, std::chrono::system_clock::time_point time)
     31    void AddCookie(WebCore::SessionID sessionID, struct WebCore::Cookie cookie, String hostname)
    3232
    3333    void SetHTTPCookieAcceptPolicy(uint32_t policy)
    3434    void GetHTTPCookieAcceptPolicy(uint64_t callbackID)
    3535   
    36     void StartObservingCookieChanges()
    37     void StopObservingCookieChanges()
     36    void StartObservingCookieChanges(WebCore::SessionID sessionID)
     37    void StopObservingCookieChanges(WebCore::SessionID sessionID)
    3838
    3939#if USE(SOUP)
Note: See TracChangeset for help on using the changeset viewer.