Attachment 373045 Details for Bug 199256 – Patch

[patch] Patch

bug-199256-20190627125003.patch (text/plain), 51.31 KB, created by Alex Christensen on 2019-06-27 12:50:05 PDT

(hide)

Description:

Filename:

MIME Type:

Creator: Alex Christensen

Created: 2019-06-27 12:50:05 PDT

Size: 51.31 KB

patch

obsolete

>Subversion Revision: 246896
>diff --git a/Source/WebKit/ChangeLog b/Source/WebKit/ChangeLog
>index dcb3e109101ae7c82471a0356db0837bcc825f13..63767152619ebf12ecd024e7111ff35089fea614 100644
>--- a/Source/WebKit/ChangeLog
>+++ b/Source/WebKit/ChangeLog
>@@ -1,3 +1,65 @@
>+2019-06-27  Alex Christensen  <achristensen@webkit.org>
>+
>+        Clean up WebCookieManager
>+        https://bugs.webkit.org/show_bug.cgi?id=199256
>+
>+        Reviewed by NOBODY (OOPS!).
>+
>+        Use sendWithAsyncReply instead of the older GenericCallback which tried to do the same thing but had less elegant syntax.
>+        Remove unused WebCookieManager::getHostnamesWithCookies which has been superceded by WKWebsiteDataStore's fetchDataRecordsOfTypes:completionHandler:
>+
>+        * NetworkProcess/Cookies/WebCookieManager.cpp:
>+        (WebKit::WebCookieManager::deleteCookie):
>+        (WebKit::WebCookieManager::deleteAllCookiesModifiedSince):
>+        (WebKit::WebCookieManager::getAllCookies):
>+        (WebKit::WebCookieManager::getCookies):
>+        (WebKit::WebCookieManager::setCookie):
>+        (WebKit::WebCookieManager::setCookies):
>+        (WebKit::WebCookieManager::setHTTPCookieAcceptPolicy):
>+        (WebKit::WebCookieManager::getHTTPCookieAcceptPolicy):
>+        (WebKit::WebCookieManager::getHostnamesWithCookies): Deleted.
>+        * NetworkProcess/Cookies/WebCookieManager.h:
>+        * NetworkProcess/Cookies/WebCookieManager.messages.in:
>+        * Shared/HTTPCookieAcceptPolicy.h:
>+        * UIProcess/API/APIHTTPCookieStore.cpp:
>+        (API::HTTPCookieStore::cookies):
>+        (API::HTTPCookieStore::setCookies):
>+        (API::HTTPCookieStore::deleteCookie):
>+        * UIProcess/API/C/WKCookieManager.cpp:
>+        (WKCookieManagerDeleteAllCookiesModifiedAfterDate):
>+        (WKCookieManagerSetHTTPCookieAcceptPolicy):
>+        (WKCookieManagerGetHTTPCookieAcceptPolicy):
>+        (WKCookieManagerGetHostnamesWithCookies): Deleted.
>+        * UIProcess/API/C/WKCookieManager.h:
>+        * UIProcess/API/Cocoa/WKProcessPool.mm:
>+        (-[WKProcessPool _setCookieAcceptPolicy:]):
>+        * UIProcess/Automation/WebAutomationSession.cpp:
>+        (WebKit::WebAutomationSession::addSingleCookie):
>+        * UIProcess/AuxiliaryProcessProxy.h:
>+        (WebKit::AuxiliaryProcessProxy::sendWithAsyncReply):
>+        * UIProcess/WebCookieManagerProxy.cpp:
>+        (WebKit::WebCookieManagerProxy::processPoolDestroyed):
>+        (WebKit::WebCookieManagerProxy::processDidClose):
>+        (WebKit::WebCookieManagerProxy::deleteCookie):
>+        (WebKit::WebCookieManagerProxy::deleteAllCookiesModifiedSince):
>+        (WebKit::WebCookieManagerProxy::setCookies):
>+        (WebKit::WebCookieManagerProxy::getAllCookies):
>+        (WebKit::WebCookieManagerProxy::getCookies):
>+        (WebKit::WebCookieManagerProxy::setCookieObserverCallback):
>+        (WebKit::WebCookieManagerProxy::setHTTPCookieAcceptPolicy):
>+        (WebKit::WebCookieManagerProxy::getHTTPCookieAcceptPolicy):
>+        (WebKit::WebCookieManagerProxy::getHostnamesWithCookies): Deleted.
>+        (WebKit::WebCookieManagerProxy::didGetHostnamesWithCookies): Deleted.
>+        (WebKit::WebCookieManagerProxy::didSetCookies): Deleted.
>+        (WebKit::WebCookieManagerProxy::didGetCookies): Deleted.
>+        (WebKit::WebCookieManagerProxy::didDeleteCookies): Deleted.
>+        (WebKit::WebCookieManagerProxy::didGetHTTPCookieAcceptPolicy): Deleted.
>+        (WebKit::WebCookieManagerProxy::didSetHTTPCookieAcceptPolicy): Deleted.
>+        * UIProcess/WebCookieManagerProxy.h:
>+        * UIProcess/WebCookieManagerProxy.messages.in:
>+        * UIProcess/WebProcessPool.h:
>+        (WebKit::WebProcessPool::sendToNetworkingProcessWithAsyncReply):
>+
> 2019-06-27  Carlos Garcia Campos  <cgarcia@igalia.com>
> 
>         WebSockets: avoid data copies when queuing tasks in WebSocketChannel
>diff --git a/Source/WebKit/NetworkProcess/Cookies/WebCookieManager.cpp b/Source/WebKit/NetworkProcess/Cookies/WebCookieManager.cpp
>index cb8a1a1a972ebe6fe3b15d3fd106661dac928256..d269d9ad67443bf811981e227fbebddebe2ec1f4 100644
>--- a/Source/WebKit/NetworkProcess/Cookies/WebCookieManager.cpp
>+++ b/Source/WebKit/NetworkProcess/Cookies/WebCookieManager.cpp
>@@ -54,15 +54,6 @@ WebCookieManager::WebCookieManager(NetworkProcess& process)
> 
> WebCookieManager::~WebCookieManager() = default;
> 
>-void WebCookieManager::getHostnamesWithCookies(PAL::SessionID sessionID, CallbackID callbackID)
>-{
>-    HashSet<String> hostnames;
>-    if (auto* storageSession = m_process.storageSession(sessionID))
>-        storageSession->getHostnamesWithCookies(hostnames);
>-
>-    m_process.send(Messages::WebCookieManagerProxy::DidGetHostnamesWithCookies(copyToVector(hostnames), callbackID), 0);
>-}
>-
> void WebCookieManager::deleteCookiesForHostnames(PAL::SessionID sessionID, const Vector<String>& hostnames)
> {
>     if (auto* storageSession = m_process.storageSession(sessionID))
>@@ -75,56 +66,56 @@ void WebCookieManager::deleteAllCookies(PAL::SessionID sessionID)
>         storageSession->deleteAllCookies();
> }
> 
>-void WebCookieManager::deleteCookie(PAL::SessionID sessionID, const Cookie& cookie, CallbackID callbackID)
>+void WebCookieManager::deleteCookie(PAL::SessionID sessionID, const Cookie& cookie, CompletionHandler<void()>&& completionHandler)
> {
>     if (auto* storageSession = m_process.storageSession(sessionID))
>         storageSession->deleteCookie(cookie);
> 
>-    m_process.send(Messages::WebCookieManagerProxy::DidDeleteCookies(callbackID), 0);
>+    completionHandler();
> }
> 
>-void WebCookieManager::deleteAllCookiesModifiedSince(PAL::SessionID sessionID, WallTime time, CallbackID callbackID)
>+void WebCookieManager::deleteAllCookiesModifiedSince(PAL::SessionID sessionID, WallTime time, CompletionHandler<void()>&& completionHandler)
> {
>     if (auto* storageSession = m_process.storageSession(sessionID))
>         storageSession->deleteAllCookiesModifiedSince(time);
> 
>-    m_process.send(Messages::WebCookieManagerProxy::DidDeleteCookies(callbackID), 0);
>+    completionHandler();
> }
> 
>-void WebCookieManager::getAllCookies(PAL::SessionID sessionID, CallbackID callbackID)
>+void WebCookieManager::getAllCookies(PAL::SessionID sessionID, CompletionHandler<void(Vector<Cookie>&&)>&& completionHandler)
> {
>     Vector<Cookie> cookies;
>     if (auto* storageSession = m_process.storageSession(sessionID))
>         cookies = storageSession->getAllCookies();
> 
>-    m_process.send(Messages::WebCookieManagerProxy::DidGetCookies(cookies, callbackID), 0);
>+    completionHandler(WTFMove(cookies));
> }
> 
>-void WebCookieManager::getCookies(PAL::SessionID sessionID, const URL& url, CallbackID callbackID)
>+void WebCookieManager::getCookies(PAL::SessionID sessionID, const URL& url, CompletionHandler<void(Vector<Cookie>&&)>&& completionHandler)
> {
>     Vector<Cookie> cookies;
>     if (auto* storageSession = m_process.storageSession(sessionID))
>         cookies = storageSession->getCookies(url);
> 
>-    m_process.send(Messages::WebCookieManagerProxy::DidGetCookies(cookies, callbackID), 0);
>+    completionHandler(WTFMove(cookies));
> }
> 
>-void WebCookieManager::setCookie(PAL::SessionID sessionID, const Vector<Cookie>& cookies, CallbackID callbackID)
>+void WebCookieManager::setCookie(PAL::SessionID sessionID, const Vector<Cookie>& cookies, CompletionHandler<void()>&& completionHandler)
> {
>     if (auto* storageSession = m_process.storageSession(sessionID)) {
>         for (auto& cookie : cookies)
>             storageSession->setCookie(cookie);
>     }
> 
>-    m_process.send(Messages::WebCookieManagerProxy::DidSetCookies(callbackID), 0);
>+    completionHandler();
> }
> 
>-void WebCookieManager::setCookies(PAL::SessionID sessionID, const Vector<Cookie>& cookies, const URL& url, const URL& mainDocumentURL, CallbackID callbackID)
>+void WebCookieManager::setCookies(PAL::SessionID sessionID, const Vector<Cookie>& cookies, const URL& url, const URL& mainDocumentURL, CompletionHandler<void()>&& completionHandler)
> {
>     if (auto* storageSession = m_process.storageSession(sessionID))
>         storageSession->setCookies(cookies, url, mainDocumentURL);
> 
>-    m_process.send(Messages::WebCookieManagerProxy::DidSetCookies(callbackID), 0);
>+    completionHandler();
> }
> 
> void WebCookieManager::notifyCookiesDidChange(PAL::SessionID sessionID)
>@@ -148,17 +139,16 @@ void WebCookieManager::stopObservingCookieChanges(PAL::SessionID sessionID)
>         WebCore::stopObservingCookieChanges(*storageSession);
> }
> 
>-void WebCookieManager::setHTTPCookieAcceptPolicy(HTTPCookieAcceptPolicy policy, OptionalCallbackID callbackID)
>+void WebCookieManager::setHTTPCookieAcceptPolicy(HTTPCookieAcceptPolicy policy,  CompletionHandler<void()>&& completionHandler)
> {
>     platformSetHTTPCookieAcceptPolicy(policy);
> 
>-    if (callbackID)
>-        m_process.send(Messages::WebCookieManagerProxy::DidSetHTTPCookieAcceptPolicy(callbackID.callbackID()), 0);
>+    completionHandler();
> }
> 
>-void WebCookieManager::getHTTPCookieAcceptPolicy(CallbackID callbackID)
>+void WebCookieManager::getHTTPCookieAcceptPolicy(CompletionHandler<void(HTTPCookieAcceptPolicy)>&& completionHandler)
> {
>-    m_process.send(Messages::WebCookieManagerProxy::DidGetHTTPCookieAcceptPolicy(platformGetHTTPCookieAcceptPolicy(), callbackID), 0);
>+    completionHandler(platformGetHTTPCookieAcceptPolicy());
> }
> 
> } // namespace WebKit
>diff --git a/Source/WebKit/NetworkProcess/Cookies/WebCookieManager.h b/Source/WebKit/NetworkProcess/Cookies/WebCookieManager.h
>index 605aef3e6ee950f39483fcd8cc4d8e658e02cf0c..28a8b0a5d9b0518a9c3169bb9d1ed139d459622c 100644
>--- a/Source/WebKit/NetworkProcess/Cookies/WebCookieManager.h
>+++ b/Source/WebKit/NetworkProcess/Cookies/WebCookieManager.h
>@@ -25,15 +25,14 @@
> 
> #pragma once
> 
>-#include "CallbackID.h"
> #include "HTTPCookieAcceptPolicy.h"
> #include "MessageReceiver.h"
> #include "NetworkProcessSupplement.h"
>-#include "OptionalCallbackID.h"
> #include <pal/SessionID.h>
> #include <stdint.h>
> #include <wtf/Forward.h>
> #include <wtf/Noncopyable.h>
>+#include <wtf/WallTime.h>
> 
> #if USE(SOUP)
> #include "SoupCookiePersistentStorageType.h"
>@@ -55,7 +54,7 @@ public:
> 
>     static const char* supplementName();
> 
>-    void setHTTPCookieAcceptPolicy(HTTPCookieAcceptPolicy, OptionalCallbackID);
>+    void setHTTPCookieAcceptPolicy(HTTPCookieAcceptPolicy, CompletionHandler<void()>&&);
> 
> #if USE(SOUP)
>     void setCookiePersistentStorage(PAL::SessionID, const String& storagePath, SoupCookiePersistentStorageType);
>@@ -67,20 +66,18 @@ private:
>     // IPC::MessageReceiver
>     void didReceiveMessage(IPC::Connection&, IPC::Decoder&) override;
> 
>-    void getHostnamesWithCookies(PAL::SessionID, CallbackID);
>-
>-    void deleteCookie(PAL::SessionID, const WebCore::Cookie&, CallbackID);
>+    void deleteCookie(PAL::SessionID, const WebCore::Cookie&, CompletionHandler<void()>&&);
>     void deleteCookiesForHostnames(PAL::SessionID, const Vector<String>&);
>     void deleteAllCookies(PAL::SessionID);
>-    void deleteAllCookiesModifiedSince(PAL::SessionID, WallTime, CallbackID);
>+    void deleteAllCookiesModifiedSince(PAL::SessionID, WallTime, CompletionHandler<void()>&&);
> 
>-    void setCookie(PAL::SessionID, const Vector<WebCore::Cookie>&, CallbackID);
>-    void setCookies(PAL::SessionID, const Vector<WebCore::Cookie>&, const URL&, const URL& mainDocumentURL, CallbackID);
>-    void getAllCookies(PAL::SessionID, CallbackID);
>-    void getCookies(PAL::SessionID, const URL&, CallbackID);
>+    void setCookie(PAL::SessionID, const Vector<WebCore::Cookie>&, CompletionHandler<void()>&&);
>+    void setCookies(PAL::SessionID, const Vector<WebCore::Cookie>&, const URL&, const URL& mainDocumentURL, CompletionHandler<void()>&&);
>+    void getAllCookies(PAL::SessionID, CompletionHandler<void(Vector<WebCore::Cookie>&&)>&&);
>+    void getCookies(PAL::SessionID, const URL&, CompletionHandler<void(Vector<WebCore::Cookie>&&)>&&);
> 
>     void platformSetHTTPCookieAcceptPolicy(HTTPCookieAcceptPolicy);
>-    void getHTTPCookieAcceptPolicy(CallbackID);
>+    void getHTTPCookieAcceptPolicy(CompletionHandler<void(HTTPCookieAcceptPolicy)>&&);
>     HTTPCookieAcceptPolicy platformGetHTTPCookieAcceptPolicy();
> 
>     void startObservingCookieChanges(PAL::SessionID);
>diff --git a/Source/WebKit/NetworkProcess/Cookies/WebCookieManager.messages.in b/Source/WebKit/NetworkProcess/Cookies/WebCookieManager.messages.in
>index 518d11cffe22d6d76257ad8e266bd4bd235d68d3..9d824480a669709a4cbfbd90347dd5454ed81b44 100644
>--- a/Source/WebKit/NetworkProcess/Cookies/WebCookieManager.messages.in
>+++ b/Source/WebKit/NetworkProcess/Cookies/WebCookieManager.messages.in
>@@ -1,5 +1,5 @@
> /*
>- * Copyright (C) 2011, 2016 Apple Inc. All rights reserved.
>+ * Copyright (C) 2011, 2016, 2019 Apple Inc. All rights reserved.
>  *
>  * Redistribution and use in source and binary forms, with or without
>  * modification, are permitted provided that the following conditions
>@@ -24,19 +24,18 @@
>  */
>  
>  messages -> WebCookieManager {
>-    void GetHostnamesWithCookies(PAL::SessionID sessionID, WebKit::CallbackID callbackID)
>     void DeleteCookiesForHostnames(PAL::SessionID sessionID, Vector<String> hostnames)
>     void DeleteAllCookies(PAL::SessionID sessionID)
> 
>-    void SetCookie(PAL::SessionID sessionID, Vector<WebCore::Cookie> cookie, WebKit::CallbackID callbackID)
>-    void SetCookies(PAL::SessionID sessionID, Vector<WebCore::Cookie> cookies, URL url, URL mainDocumentURL, WebKit::CallbackID callbackID)
>-    void GetAllCookies(PAL::SessionID sessionID, WebKit::CallbackID callbackID)
>-    void GetCookies(PAL::SessionID sessionID, URL url, WebKit::CallbackID callbackID)
>-    void DeleteCookie(PAL::SessionID sessionID, struct WebCore::Cookie cookie, WebKit::CallbackID callbackID)
>-    void DeleteAllCookiesModifiedSince(PAL::SessionID sessionID, WallTime time, WebKit::CallbackID callbackID)
>+    void SetCookie(PAL::SessionID sessionID, Vector<WebCore::Cookie> cookie) -> () Async
>+    void SetCookies(PAL::SessionID sessionID, Vector<WebCore::Cookie> cookies, URL url, URL mainDocumentURL) -> () Async
>+    void GetAllCookies(PAL::SessionID sessionID) -> (Vector<WebCore::Cookie> cookies) Async
>+    void GetCookies(PAL::SessionID sessionID, URL url) -> (Vector<WebCore::Cookie> cookies) Async
>+    void DeleteCookie(PAL::SessionID sessionID, struct WebCore::Cookie cookie) -> () Async
>+    void DeleteAllCookiesModifiedSince(PAL::SessionID sessionID, WallTime time) -> () Async
> 
>-    void SetHTTPCookieAcceptPolicy(enum:uint8_t WebKit::HTTPCookieAcceptPolicy policy, WebKit::OptionalCallbackID callbackID)
>-    void GetHTTPCookieAcceptPolicy(WebKit::CallbackID callbackID)
>+    void SetHTTPCookieAcceptPolicy(enum:uint8_t WebKit::HTTPCookieAcceptPolicy policy) -> () Async
>+    void GetHTTPCookieAcceptPolicy() -> (enum:uint8_t WebKit::HTTPCookieAcceptPolicy policy) Async
>     
>     void StartObservingCookieChanges(PAL::SessionID sessionID)
>     void StopObservingCookieChanges(PAL::SessionID sessionID)
>diff --git a/Source/WebKit/NetworkProcess/soup/NetworkProcessSoup.cpp b/Source/WebKit/NetworkProcess/soup/NetworkProcessSoup.cpp
>index dca7c41f43040a622d711ae8ad62530a1cd78dc9..e03a74b7d795a9c14e46a0aaf556d6e2ca18016b 100644
>--- a/Source/WebKit/NetworkProcess/soup/NetworkProcessSoup.cpp
>+++ b/Source/WebKit/NetworkProcess/soup/NetworkProcessSoup.cpp
>@@ -123,7 +123,7 @@ void NetworkProcess::platformInitializeNetworkProcess(const NetworkProcessCreati
> 
>     m_cache = NetworkCache::Cache::open(*this, m_diskCacheDirectory, cacheOptions);
> 
>-    supplement<WebCookieManager>()->setHTTPCookieAcceptPolicy(parameters.cookieAcceptPolicy, OptionalCallbackID());
>+    supplement<WebCookieManager>()->setHTTPCookieAcceptPolicy(parameters.cookieAcceptPolicy, [] () { });
> 
>     if (!parameters.languages.isEmpty())
>         userPreferredLanguagesChanged(parameters.languages);
>diff --git a/Source/WebKit/Shared/HTTPCookieAcceptPolicy.h b/Source/WebKit/Shared/HTTPCookieAcceptPolicy.h
>index 457c2344c9c8986ff6e2323305a28433d86ea0eb..8c2e0e34670e21c58ea9aa69b71ff83300726d03 100644
>--- a/Source/WebKit/Shared/HTTPCookieAcceptPolicy.h
>+++ b/Source/WebKit/Shared/HTTPCookieAcceptPolicy.h
>@@ -25,6 +25,8 @@
> 
> #pragma once
> 
>+#include <wtf/EnumTraits.h>
>+
> namespace WebKit {
> 
> enum class HTTPCookieAcceptPolicy : uint8_t {
>diff --git a/Source/WebKit/UIProcess/API/APIHTTPCookieStore.cpp b/Source/WebKit/UIProcess/API/APIHTTPCookieStore.cpp
>index 981a985bbde5f1cb65f96cbb2139fbcf19d7dce5..c3b6f6d92e91f4aa59095e20f20b2e58e47e73f0 100644
>--- a/Source/WebKit/UIProcess/API/APIHTTPCookieStore.cpp
>+++ b/Source/WebKit/UIProcess/API/APIHTTPCookieStore.cpp
>@@ -69,7 +69,7 @@ void HTTPCookieStore::cookies(CompletionHandler<void(const Vector<WebCore::Cooki
>     }
> 
>     auto* cookieManager = pool->supplement<WebKit::WebCookieManagerProxy>();
>-    cookieManager->getAllCookies(m_owningDataStore->sessionID(), [pool = WTFMove(pool), completionHandler = WTFMove(completionHandler)] (const Vector<WebCore::Cookie>& cookies, CallbackBase::Error error) mutable {
>+    cookieManager->getAllCookies(m_owningDataStore->sessionID(), [pool = WTFMove(pool), completionHandler = WTFMove(completionHandler)] (const Vector<WebCore::Cookie>& cookies) mutable {
>         completionHandler(cookies);
>     });
> }
>@@ -91,7 +91,7 @@ void HTTPCookieStore::setCookies(const Vector<WebCore::Cookie>& cookies, Complet
>     }
> 
>     auto* cookieManager = pool->supplement<WebKit::WebCookieManagerProxy>();
>-    cookieManager->setCookies(m_owningDataStore->sessionID(), cookies, [pool = WTFMove(pool), completionHandler = WTFMove(completionHandler)] (CallbackBase::Error error) mutable {
>+    cookieManager->setCookies(m_owningDataStore->sessionID(), cookies, [pool = WTFMove(pool), completionHandler = WTFMove(completionHandler)] () mutable {
>         completionHandler();
>     });
> }
>@@ -112,7 +112,7 @@ void HTTPCookieStore::deleteCookie(const WebCore::Cookie& cookie, CompletionHand
>     }
> 
>     auto* cookieManager = pool->supplement<WebKit::WebCookieManagerProxy>();
>-    cookieManager->deleteCookie(m_owningDataStore->sessionID(), cookie, [pool = WTFMove(pool), completionHandler = WTFMove(completionHandler)](CallbackBase::Error error) mutable {
>+    cookieManager->deleteCookie(m_owningDataStore->sessionID(), cookie, [pool = WTFMove(pool), completionHandler = WTFMove(completionHandler)] () mutable {
>         completionHandler();
>     });
> }
>diff --git a/Source/WebKit/UIProcess/API/C/WKCookieManager.cpp b/Source/WebKit/UIProcess/API/C/WKCookieManager.cpp
>index 0636ea6c2c77e3fd4d0b4dc6f12d08deb8695048..a302e5023f23f9c2855fa9a6e6242a2016609a86 100644
>--- a/Source/WebKit/UIProcess/API/C/WKCookieManager.cpp
>+++ b/Source/WebKit/UIProcess/API/C/WKCookieManager.cpp
>@@ -42,11 +42,6 @@ void WKCookieManagerSetClient(WKCookieManagerRef cookieManagerRef, const WKCooki
>     toImpl(cookieManagerRef)->initializeClient(wkClient);
> }
> 
>-void WKCookieManagerGetHostnamesWithCookies(WKCookieManagerRef cookieManagerRef, void* context, WKCookieManagerGetCookieHostnamesFunction callback)
>-{
>-    toImpl(cookieManagerRef)->getHostnamesWithCookies(PAL::SessionID::defaultSessionID(), toGenericCallbackFunction(context, callback));
>-}
>-
> void WKCookieManagerDeleteCookiesForHostname(WKCookieManagerRef cookieManagerRef, WKStringRef hostname)
> {
>     toImpl(cookieManagerRef)->deleteCookiesForHostnames(PAL::SessionID::defaultSessionID(), { toImpl(hostname)->string() });
>@@ -59,20 +54,23 @@ void WKCookieManagerDeleteAllCookies(WKCookieManagerRef cookieManagerRef)
> 
> void WKCookieManagerDeleteAllCookiesModifiedAfterDate(WKCookieManagerRef cookieManagerRef, double date)
> {
>-    toImpl(cookieManagerRef)->deleteAllCookiesModifiedSince(PAL::SessionID::defaultSessionID(), WallTime::fromRawSeconds(date), [](CallbackBase::Error){});
>+    toImpl(cookieManagerRef)->deleteAllCookiesModifiedSince(PAL::SessionID::defaultSessionID(), WallTime::fromRawSeconds(date), [] () { });
> }
> 
> void WKCookieManagerSetHTTPCookieAcceptPolicy(WKCookieManagerRef cookieManager, WKHTTPCookieAcceptPolicy policy, void* context, WKCookieManagerSetHTTPCookieAcceptPolicyFunction callback)
> {
>-    toImpl(cookieManager)->setHTTPCookieAcceptPolicy(PAL::SessionID::defaultSessionID(), toHTTPCookieAcceptPolicy(policy), [context, callback](CallbackBase::Error error) {
>+    toImpl(cookieManager)->setHTTPCookieAcceptPolicy(PAL::SessionID::defaultSessionID(), toHTTPCookieAcceptPolicy(policy), [context, callback] {
>         if (callback)
>-            callback(error != CallbackBase::Error::None ? toAPI(API::Error::create().ptr()) : nullptr, context);
>+            callback(context);
>     });
> }
> 
> void WKCookieManagerGetHTTPCookieAcceptPolicy(WKCookieManagerRef cookieManager, void* context, WKCookieManagerGetHTTPCookieAcceptPolicyFunction callback)
> {
>-    toImpl(cookieManager)->getHTTPCookieAcceptPolicy(PAL::SessionID::defaultSessionID(), toGenericCallbackFunction<WKHTTPCookieAcceptPolicy, HTTPCookieAcceptPolicy>(context, callback));
>+    toImpl(cookieManager)->getHTTPCookieAcceptPolicy(PAL::SessionID::defaultSessionID(), [context, callback] (HTTPCookieAcceptPolicy policy) {
>+        if (callback)
>+            callback(toAPI(policy), context);
>+    });
> }
> 
> void WKCookieManagerSetStorageAccessAPIEnabled(WKCookieManagerRef cookieManager, bool enabled)
>diff --git a/Source/WebKit/UIProcess/API/C/WKCookieManager.h b/Source/WebKit/UIProcess/API/C/WKCookieManager.h
>index 73354d2cba4edf97b9a57920cd45bc774252baa5..51516b65e4edfc5edff9c2984830ff960a727c2e 100644
>--- a/Source/WebKit/UIProcess/API/C/WKCookieManager.h
>+++ b/Source/WebKit/UIProcess/API/C/WKCookieManager.h
>@@ -59,18 +59,15 @@ WK_EXPORT WKTypeID WKCookieManagerGetTypeID();
> 
> WK_EXPORT void WKCookieManagerSetClient(WKCookieManagerRef cookieManager, const WKCookieManagerClientBase* client);
> 
>-typedef void (*WKCookieManagerGetCookieHostnamesFunction)(WKArrayRef, WKErrorRef, void*);
>-WK_EXPORT void WKCookieManagerGetHostnamesWithCookies(WKCookieManagerRef cookieManager, void* context, WKCookieManagerGetCookieHostnamesFunction function);
>-
> WK_EXPORT void WKCookieManagerDeleteCookiesForHostname(WKCookieManagerRef cookieManager, WKStringRef hostname);
> WK_EXPORT void WKCookieManagerDeleteAllCookies(WKCookieManagerRef cookieManager);
> 
> // The time here is relative to the Unix epoch.
> WK_EXPORT void WKCookieManagerDeleteAllCookiesModifiedAfterDate(WKCookieManagerRef cookieManager, double);
> 
>-typedef void (*WKCookieManagerSetHTTPCookieAcceptPolicyFunction)(WKErrorRef, void*);
>+typedef void (*WKCookieManagerSetHTTPCookieAcceptPolicyFunction)(void*);
> WK_EXPORT void WKCookieManagerSetHTTPCookieAcceptPolicy(WKCookieManagerRef cookieManager, WKHTTPCookieAcceptPolicy policy, void* context, WKCookieManagerSetHTTPCookieAcceptPolicyFunction callback);
>-typedef void (*WKCookieManagerGetHTTPCookieAcceptPolicyFunction)(WKHTTPCookieAcceptPolicy, WKErrorRef, void*);
>+typedef void (*WKCookieManagerGetHTTPCookieAcceptPolicyFunction)(WKHTTPCookieAcceptPolicy, void*);
> WK_EXPORT void WKCookieManagerGetHTTPCookieAcceptPolicy(WKCookieManagerRef cookieManager, void* context, WKCookieManagerGetHTTPCookieAcceptPolicyFunction callback);
> 
> WK_EXPORT void WKCookieManagerSetStorageAccessAPIEnabled(WKCookieManagerRef cookieManager, bool enabled);
>diff --git a/Source/WebKit/UIProcess/API/Cocoa/WKProcessPool.mm b/Source/WebKit/UIProcess/API/Cocoa/WKProcessPool.mm
>index c06e1afb33ffa318b7e29dfdc4f067957a838bf2..8566fc2a44fff194ce53f682128297fe65b94f9e 100644
>--- a/Source/WebKit/UIProcess/API/Cocoa/WKProcessPool.mm
>+++ b/Source/WebKit/UIProcess/API/Cocoa/WKProcessPool.mm
>@@ -222,7 +222,7 @@ static WebKit::HTTPCookieAcceptPolicy toHTTPCookieAcceptPolicy(NSHTTPCookieAccep
> 
> - (void)_setCookieAcceptPolicy:(NSHTTPCookieAcceptPolicy)policy
> {
>-    _processPool->supplement<WebKit::WebCookieManagerProxy>()->setHTTPCookieAcceptPolicy(PAL::SessionID::defaultSessionID(), toHTTPCookieAcceptPolicy(policy), [](WebKit::CallbackBase::Error){});
>+    _processPool->supplement<WebKit::WebCookieManagerProxy>()->setHTTPCookieAcceptPolicy(PAL::SessionID::defaultSessionID(), toHTTPCookieAcceptPolicy(policy), [] () { });
> }
> 
> - (id)_objectForBundleParameter:(NSString *)parameter
>diff --git a/Source/WebKit/UIProcess/API/glib/WebKitCookieManager.cpp b/Source/WebKit/UIProcess/API/glib/WebKitCookieManager.cpp
>index 8327ae93084f9d1e7260cfdcf15b5bcf1c1799a0..cbe4f5d3becb845da8df64201059516c2390cb80 100644
>--- a/Source/WebKit/UIProcess/API/glib/WebKitCookieManager.cpp
>+++ b/Source/WebKit/UIProcess/API/glib/WebKitCookieManager.cpp
>@@ -190,7 +190,7 @@ void webkit_cookie_manager_set_accept_policy(WebKitCookieManager* manager, WebKi
>     g_return_if_fail(WEBKIT_IS_COOKIE_MANAGER(manager));
> 
>     for (auto* processPool : webkitWebsiteDataManagerGetProcessPools(manager->priv->dataManager))
>-        processPool->supplement<WebCookieManagerProxy>()->setHTTPCookieAcceptPolicy(manager->priv->sessionID(), toHTTPCookieAcceptPolicy(policy), [](CallbackBase::Error) { });
>+        processPool->supplement<WebCookieManagerProxy>()->setHTTPCookieAcceptPolicy(manager->priv->sessionID(), toHTTPCookieAcceptPolicy(policy), []() { });
> }
> 
> /**
>@@ -218,7 +218,7 @@ void webkit_cookie_manager_get_accept_policy(WebKitCookieManager* manager, GCanc
>         return;
>     }
> 
>-    processPools[0]->supplement<WebCookieManagerProxy>()->getHTTPCookieAcceptPolicy(manager->priv->sessionID(), [task = WTFMove(task)](HTTPCookieAcceptPolicy policy, CallbackBase::Error) {
>+    processPools[0]->supplement<WebCookieManagerProxy>()->getHTTPCookieAcceptPolicy(manager->priv->sessionID(), [task = WTFMove(task)](HTTPCookieAcceptPolicy policy) {
>         g_task_return_int(task.get(), toWebKitCookieAcceptPolicy(policy));
>     });
> }
>@@ -267,14 +267,7 @@ void webkit_cookie_manager_add_cookie(WebKitCookieManager* manager, SoupCookie*
>     // Cookies are read/written from/to the same SQLite database on disk regardless
>     // of the process we access them from, so just use the first process pool.
>     const auto& processPools = webkitWebsiteDataManagerGetProcessPools(manager->priv->dataManager);
>-    processPools[0]->supplement<WebCookieManagerProxy>()->setCookies(manager->priv->sessionID(), { WebCore::Cookie(cookie) }, [task = WTFMove(task)](CallbackBase::Error error) {
>-        if (error != CallbackBase::Error::None) {
>-            // This can only happen in cases where the web process is not available,
>-            // consider the operation "cancelled" from the point of view of the client.
>-            g_task_return_new_error(task.get(), G_IO_ERROR, G_IO_ERROR_CANCELLED, _("Operation was cancelled"));
>-            return;
>-        }
>-
>+    processPools[0]->supplement<WebCookieManagerProxy>()->setCookies(manager->priv->sessionID(), { WebCore::Cookie(cookie) }, [task = WTFMove(task)]() {
>         g_task_return_boolean(task.get(), TRUE);
>     });
> }
>@@ -325,14 +318,7 @@ void webkit_cookie_manager_get_cookies(WebKitCookieManager* manager, const gchar
>     // Cookies are read/written from/to the same SQLite database on disk regardless
>     // of the process we access them from, so just use the first process pool.
>     const auto& processPools = webkitWebsiteDataManagerGetProcessPools(manager->priv->dataManager);
>-    processPools[0]->supplement<WebCookieManagerProxy>()->getCookies(manager->priv->sessionID(), URL(URL(), String::fromUTF8(uri)), [task = WTFMove(task)](const Vector<WebCore::Cookie>& cookies, CallbackBase::Error error) {
>-        if (error != CallbackBase::Error::None) {
>-            // This can only happen in cases where the web process is not available,
>-            // consider the operation "cancelled" from the point of view of the client.
>-            g_task_return_new_error(task.get(), G_IO_ERROR, G_IO_ERROR_CANCELLED, _("Operation was cancelled"));
>-            return;
>-        }
>-
>+    processPools[0]->supplement<WebCookieManagerProxy>()->getCookies(manager->priv->sessionID(), URL(URL(), String::fromUTF8(uri)), [task = WTFMove(task)](Vector<WebCore::Cookie>&& cookies) {
>         GList* cookiesList = nullptr;
>         for (auto& cookie : cookies)
>             cookiesList = g_list_prepend(cookiesList, cookie.toSoupCookie());
>@@ -390,14 +376,7 @@ void webkit_cookie_manager_delete_cookie(WebKitCookieManager* manager, SoupCooki
>     // Cookies are read/written from/to the same SQLite database on disk regardless
>     // of the process we access them from, so just use the first process pool.
>     const auto& processPools = webkitWebsiteDataManagerGetProcessPools(manager->priv->dataManager);
>-    processPools[0]->supplement<WebCookieManagerProxy>()->deleteCookie(manager->priv->sessionID(), WebCore::Cookie(cookie), [task = WTFMove(task)](CallbackBase::Error error) {
>-        if (error != CallbackBase::Error::None) {
>-            // This can only happen in cases where the web process is not available,
>-            // consider the operation "cancelled" from the point of view of the client.
>-            g_task_return_new_error(task.get(), G_IO_ERROR, G_IO_ERROR_CANCELLED, _("Operation was cancelled"));
>-            return;
>-        }
>-
>+    processPools[0]->supplement<WebCookieManagerProxy>()->deleteCookie(manager->priv->sessionID(), WebCore::Cookie(cookie), [task = WTFMove(task)]() {
>         g_task_return_boolean(task.get(), TRUE);
>     });
> }
>diff --git a/Source/WebKit/UIProcess/Automation/WebAutomationSession.cpp b/Source/WebKit/UIProcess/Automation/WebAutomationSession.cpp
>index 06226ea2ddb24a0a1930f93f7c18e4d8d9951fc6..5a6b85aa3f1e80d95066dee9c40c3a3889fe08d7 100644
>--- a/Source/WebKit/UIProcess/Automation/WebAutomationSession.cpp
>+++ b/Source/WebKit/UIProcess/Automation/WebAutomationSession.cpp
>@@ -1352,11 +1352,8 @@ void WebAutomationSession::addSingleCookie(const String& browsingContextHandle,
>         ASYNC_FAIL_WITH_PREDEFINED_ERROR_AND_DETAILS(MissingParameter, "The parameter 'httpOnly' was not found.");
> 
>     WebCookieManagerProxy* cookieManager = m_processPool->supplement<WebCookieManagerProxy>();
>-    cookieManager->setCookies(page->websiteDataStore().sessionID(), { cookie }, [callback = callback.copyRef()](CallbackBase::Error error) {
>-        if (error == CallbackBase::Error::None)
>-            callback->sendSuccess();
>-        else
>-            callback->sendFailure(STRING_FOR_PREDEFINED_ERROR_NAME(InternalError));
>+    cookieManager->setCookies(page->websiteDataStore().sessionID(), { cookie }, [callback = callback.copyRef()]() {
>+        callback->sendSuccess();
>     });
> }
> 
>diff --git a/Source/WebKit/UIProcess/AuxiliaryProcessProxy.h b/Source/WebKit/UIProcess/AuxiliaryProcessProxy.h
>index 6b09badb8d0cebabf2c69f6009b1bd1d23c09e58..68e0223476041f891ab66671de9c4d2ceb1a9d23 100644
>--- a/Source/WebKit/UIProcess/AuxiliaryProcessProxy.h
>+++ b/Source/WebKit/UIProcess/AuxiliaryProcessProxy.h
>@@ -50,7 +50,7 @@ public:
> 
>     template<typename T> bool send(T&& message, uint64_t destinationID, OptionSet<IPC::SendOption> sendOptions = { });
>     template<typename T> bool sendSync(T&& message, typename T::Reply&&, uint64_t destinationID, Seconds timeout = 1_s, OptionSet<IPC::SendSyncOption> sendSyncOptions = { });
>-    template<typename T, typename... Args> void sendWithAsyncReply(T&&, CompletionHandler<void(Args...)>&&);
>+    template<typename T, typename C> void sendWithAsyncReply(T&&, C&&);
>     
>     template<typename T, typename U>
>     bool send(T&& message, ObjectIdentifier<U> destinationID, OptionSet<IPC::SendOption> sendOptions = { })
>@@ -156,8 +156,8 @@ bool AuxiliaryProcessProxy::sendSync(U&& message, typename U::Reply&& reply, uin
>     return connection()->sendSync(std::forward<U>(message), WTFMove(reply), destinationID, timeout, sendSyncOptions);
> }
> 
>-template<typename T, typename... Args>
>-void AuxiliaryProcessProxy::sendWithAsyncReply(T&& message, CompletionHandler<void(Args...)>&& completionHandler)
>+template<typename T, typename C>
>+void AuxiliaryProcessProxy::sendWithAsyncReply(T&& message, C&& completionHandler)
> {
>     if (!m_connection) {
>         T::cancelReply(WTFMove(completionHandler));
>diff --git a/Source/WebKit/UIProcess/WebCookieManagerProxy.cpp b/Source/WebKit/UIProcess/WebCookieManagerProxy.cpp
>index 7432880e9e3360af5adfaaa26de7a7d450c8be65..01d092984a2175c943ecc5b7c3ae2b27bf4d7e1f 100644
>--- a/Source/WebKit/UIProcess/WebCookieManagerProxy.cpp
>+++ b/Source/WebKit/UIProcess/WebCookieManagerProxy.cpp
>@@ -69,8 +69,6 @@ void WebCookieManagerProxy::initializeClient(const WKCookieManagerClientBase* cl
> 
> void WebCookieManagerProxy::processPoolDestroyed()
> {
>-    m_callbacks.invalidate(CallbackBase::Error::OwnerWasInvalidated);
>-
>     Vector<Observer*> observers;
>     for (auto& observerSet : m_cookieObservers.values()) {
>         for (auto* observer : observerSet)
>@@ -85,12 +83,10 @@ void WebCookieManagerProxy::processPoolDestroyed()
> 
> void WebCookieManagerProxy::processDidClose(WebProcessProxy*)
> {
>-    m_callbacks.invalidate(CallbackBase::Error::ProcessExited);
> }
> 
> void WebCookieManagerProxy::processDidClose(NetworkProcessProxy*)
> {
>-    m_callbacks.invalidate(CallbackBase::Error::ProcessExited);
> }
> 
> void WebCookieManagerProxy::refWebContextSupplement()
>@@ -103,23 +99,6 @@ void WebCookieManagerProxy::derefWebContextSupplement()
>     API::Object::deref();
> }
> 
>-void WebCookieManagerProxy::getHostnamesWithCookies(PAL::SessionID sessionID, Function<void (API::Array*, CallbackBase::Error)>&& callbackFunction)
>-{
>-    auto callbackID = m_callbacks.put(WTFMove(callbackFunction), processPool()->ensureNetworkProcess().throttler().backgroundActivityToken());
>-    processPool()->sendToNetworkingProcess(Messages::WebCookieManager::GetHostnamesWithCookies(sessionID, callbackID));
>-}
>-
>-void WebCookieManagerProxy::didGetHostnamesWithCookies(const Vector<String>& hostnames, WebKit::CallbackID callbackID)
>-{
>-    auto callback = m_callbacks.take<ArrayCallback>(callbackID);
>-    if (!callback) {
>-        // FIXME: Log error or assert.
>-        return;
>-    }
>-
>-    callback->performCallbackWithReturnValue(API::Array::createStringArray(hostnames).ptr());
>-}
>-
> void WebCookieManagerProxy::deleteCookiesForHostnames(PAL::SessionID sessionID, const Vector<String>& hostnames)
> {
>     processPool()->sendToNetworkingProcessRelaunchingIfNecessary(Messages::WebCookieManager::DeleteCookiesForHostnames(sessionID, hostnames));
>@@ -130,55 +109,52 @@ void WebCookieManagerProxy::deleteAllCookies(PAL::SessionID sessionID)
>     processPool()->sendToNetworkingProcessRelaunchingIfNecessary(Messages::WebCookieManager::DeleteAllCookies(sessionID));
> }
> 
>-void WebCookieManagerProxy::deleteCookie(PAL::SessionID sessionID, const Cookie& cookie, Function<void (CallbackBase::Error)>&& callbackFunction)
>-{
>-    auto callbackID = m_callbacks.put(WTFMove(callbackFunction), processPool()->ensureNetworkProcess().throttler().backgroundActivityToken());
>-    processPool()->sendToNetworkingProcess(Messages::WebCookieManager::DeleteCookie(sessionID, cookie, callbackID));
>-}
>-
>-void WebCookieManagerProxy::deleteAllCookiesModifiedSince(PAL::SessionID sessionID, WallTime time, Function<void (CallbackBase::Error)>&& callbackFunction)
>+void WebCookieManagerProxy::deleteCookie(PAL::SessionID sessionID, const Cookie& cookie, CompletionHandler<void()>&& completionHandler)
> {
>-    auto callbackID = m_callbacks.put(WTFMove(callbackFunction), processPool()->ensureNetworkProcess().throttler().backgroundActivityToken());
>-    processPool()->sendToNetworkingProcess(Messages::WebCookieManager::DeleteAllCookiesModifiedSince(sessionID, time, callbackID));
>+    auto token = processPool()->ensureNetworkProcess().throttler().backgroundActivityToken();
>+    processPool()->sendToNetworkingProcessWithAsyncReply(Messages::WebCookieManager::DeleteCookie(sessionID, cookie), [completionHandler = WTFMove(completionHandler), token = WTFMove(token)] () mutable {
>+        completionHandler();
>+    });
> }
> 
>-void WebCookieManagerProxy::setCookies(PAL::SessionID sessionID, const Vector<Cookie>& cookies, Function<void(CallbackBase::Error)>&& callbackFunction)
>+void WebCookieManagerProxy::deleteAllCookiesModifiedSince(PAL::SessionID sessionID, WallTime time, CompletionHandler<void()>&& completionHandler)
> {
>-    auto callbackID = m_callbacks.put(WTFMove(callbackFunction), processPool()->ensureNetworkProcess().throttler().backgroundActivityToken());
>-    processPool()->sendToNetworkingProcess(Messages::WebCookieManager::SetCookie(sessionID, cookies, callbackID));
>+    auto token = processPool()->ensureNetworkProcess().throttler().backgroundActivityToken();
>+    processPool()->sendToNetworkingProcessWithAsyncReply(Messages::WebCookieManager::DeleteAllCookiesModifiedSince(sessionID, time), [completionHandler = WTFMove(completionHandler), token = WTFMove(token)] () mutable {
>+        completionHandler();
>+    });
> }
> 
>-void WebCookieManagerProxy::setCookies(PAL::SessionID sessionID, const Vector<Cookie>& cookies, const URL& url, const URL& mainDocumentURL, Function<void (CallbackBase::Error)>&& callbackFunction)
>+void WebCookieManagerProxy::setCookies(PAL::SessionID sessionID, const Vector<Cookie>& cookies, CompletionHandler<void()>&& completionHandler)
> {
>-    auto callbackID = m_callbacks.put(WTFMove(callbackFunction), processPool()->ensureNetworkProcess().throttler().backgroundActivityToken());
>-    processPool()->sendToNetworkingProcess(Messages::WebCookieManager::SetCookies(sessionID, cookies, url, mainDocumentURL, callbackID));
>+    auto token = processPool()->ensureNetworkProcess().throttler().backgroundActivityToken();
>+    processPool()->sendToNetworkingProcessWithAsyncReply(Messages::WebCookieManager::SetCookie(sessionID, cookies), [completionHandler = WTFMove(completionHandler), token = WTFMove(token)] () mutable {
>+        completionHandler();
>+    });
> }
> 
>-void WebCookieManagerProxy::getAllCookies(PAL::SessionID sessionID, Function<void (const Vector<Cookie>&, CallbackBase::Error)>&& callbackFunction)
>+void WebCookieManagerProxy::setCookies(PAL::SessionID sessionID, const Vector<Cookie>& cookies, const URL& url, const URL& mainDocumentURL, CompletionHandler<void()>&& completionHandler)
> {
>-    auto callbackID = m_callbacks.put(WTFMove(callbackFunction), processPool()->ensureNetworkProcess().throttler().backgroundActivityToken());
>-    processPool()->sendToNetworkingProcess(Messages::WebCookieManager::GetAllCookies(sessionID, callbackID));
>+    auto token = processPool()->ensureNetworkProcess().throttler().backgroundActivityToken();
>+    processPool()->sendToNetworkingProcessWithAsyncReply(Messages::WebCookieManager::SetCookies(sessionID, cookies, url, mainDocumentURL), [completionHandler = WTFMove(completionHandler), token = WTFMove(token)] () mutable {
>+        completionHandler();
>+    });
> }
> 
>-void WebCookieManagerProxy::getCookies(PAL::SessionID sessionID, const URL& url, Function<void (const Vector<Cookie>&, CallbackBase::Error)>&& callbackFunction)
>+void WebCookieManagerProxy::getAllCookies(PAL::SessionID sessionID, CompletionHandler<void(Vector<Cookie>&&)>&& completionHandler)
> {
>-    auto callbackID = m_callbacks.put(WTFMove(callbackFunction), processPool()->ensureNetworkProcess().throttler().backgroundActivityToken());
>-    processPool()->sendToNetworkingProcess(Messages::WebCookieManager::GetCookies(sessionID, url, callbackID));
>+    auto token = processPool()->ensureNetworkProcess().throttler().backgroundActivityToken();
>+    processPool()->sendToNetworkingProcessWithAsyncReply(Messages::WebCookieManager::GetAllCookies(sessionID), [completionHandler = WTFMove(completionHandler), token = WTFMove(token)] (Vector<Cookie>&& cookies) mutable {
>+        completionHandler(WTFMove(cookies));
>+    });
> }
> 
>-void WebCookieManagerProxy::didSetCookies(WebKit::CallbackID callbackID)
>+void WebCookieManagerProxy::getCookies(PAL::SessionID sessionID, const URL& url, CompletionHandler<void(Vector<Cookie>&&)>&& completionHandler)
> {
>-    m_callbacks.take<VoidCallback>(callbackID)->performCallback();
>-}
>-
>-void WebCookieManagerProxy::didGetCookies(const Vector<Cookie>& cookies, WebKit::CallbackID callbackID)
>-{
>-    m_callbacks.take<GetCookiesCallback>(callbackID)->performCallbackWithReturnValue(cookies);
>-}
>-
>-void WebCookieManagerProxy::didDeleteCookies(WebKit::CallbackID callbackID)
>-{
>-    m_callbacks.take<VoidCallback>(callbackID)->performCallback();
>+    auto token = processPool()->ensureNetworkProcess().throttler().backgroundActivityToken();
>+    processPool()->sendToNetworkingProcessWithAsyncReply(Messages::WebCookieManager::GetCookies(sessionID, url), [completionHandler = WTFMove(completionHandler), token = WTFMove(token)] (Vector<Cookie>&& cookies) mutable {
>+        completionHandler(WTFMove(cookies));
>+    });
> }
> 
> void WebCookieManagerProxy::startObservingCookieChanges(PAL::SessionID sessionID)
>@@ -192,7 +168,7 @@ void WebCookieManagerProxy::stopObservingCookieChanges(PAL::SessionID sessionID)
> }
> 
> 
>-void WebCookieManagerProxy::setCookieObserverCallback(PAL::SessionID sessionID, WTF::Function<void ()>&& callback)
>+void WebCookieManagerProxy::setCookieObserverCallback(PAL::SessionID sessionID, Function<void()>&& callback)
> {
>     if (callback)
>         m_legacyCookieObservers.set(sessionID, WTFMove(callback));
>@@ -238,7 +214,7 @@ void WebCookieManagerProxy::cookiesDidChange(PAL::SessionID sessionID)
>         observer->cookiesDidChange();
> }
> 
>-void WebCookieManagerProxy::setHTTPCookieAcceptPolicy(PAL::SessionID, HTTPCookieAcceptPolicy policy, Function<void (CallbackBase::Error)>&& callbackFunction)
>+void WebCookieManagerProxy::setHTTPCookieAcceptPolicy(PAL::SessionID, HTTPCookieAcceptPolicy policy, CompletionHandler<void()>&& completionHandler)
> {
> #if PLATFORM(COCOA)
>     if (!processPool()->isUsingTestingNetworkSession())
>@@ -247,25 +223,15 @@ void WebCookieManagerProxy::setHTTPCookieAcceptPolicy(PAL::SessionID, HTTPCookie
> #if USE(SOUP)
>     processPool()->setInitialHTTPCookieAcceptPolicy(policy);
> #endif
>-
>-    auto callbackID = m_callbacks.put(WTFMove(callbackFunction), processPool()->ensureNetworkProcess().throttler().backgroundActivityToken());
>-    processPool()->sendToNetworkingProcess(Messages::WebCookieManager::SetHTTPCookieAcceptPolicy(policy, OptionalCallbackID(callbackID)));
>-}
>-
>-void WebCookieManagerProxy::getHTTPCookieAcceptPolicy(PAL::SessionID, Function<void (HTTPCookieAcceptPolicy, CallbackBase::Error)>&& callbackFunction)
>-{
>-    auto callbackID = m_callbacks.put(WTFMove(callbackFunction), processPool()->ensureNetworkProcess().throttler().backgroundActivityToken());
>-    processPool()->sendToNetworkingProcess(Messages::WebCookieManager::GetHTTPCookieAcceptPolicy(callbackID));
>-}
>-
>-void WebCookieManagerProxy::didGetHTTPCookieAcceptPolicy(HTTPCookieAcceptPolicy policy, WebKit::CallbackID callbackID)
>-{
>-    m_callbacks.take<HTTPCookieAcceptPolicyCallback>(callbackID)->performCallbackWithReturnValue(policy);
>+    processPool()->sendToNetworkingProcessWithAsyncReply(Messages::WebCookieManager::SetHTTPCookieAcceptPolicy(policy), WTFMove(completionHandler));
> }
> 
>-void WebCookieManagerProxy::didSetHTTPCookieAcceptPolicy(WebKit::CallbackID callbackID)
>+void WebCookieManagerProxy::getHTTPCookieAcceptPolicy(PAL::SessionID, CompletionHandler<void(HTTPCookieAcceptPolicy)>&& completionHandler)
> {
>-    m_callbacks.take<VoidCallback>(callbackID)->performCallback();
>+    auto token = processPool()->ensureNetworkProcess().throttler().backgroundActivityToken();
>+    processPool()->sendToNetworkingProcessWithAsyncReply(Messages::WebCookieManager::GetHTTPCookieAcceptPolicy(), [completionHandler = WTFMove(completionHandler), token = WTFMove(token)] (HTTPCookieAcceptPolicy policy) mutable {
>+        completionHandler(policy);
>+    });
> }
> 
> void WebCookieManagerProxy::setStorageAccessAPIEnabled(bool enabled)
>diff --git a/Source/WebKit/UIProcess/WebCookieManagerProxy.h b/Source/WebKit/UIProcess/WebCookieManagerProxy.h
>index 673ad6403fb2b7d4dd94e0110bc549525b06a4bc..d9673dc11784f5d7ac1068777b36d09c91b3e4e6 100644
>--- a/Source/WebKit/UIProcess/WebCookieManagerProxy.h
>+++ b/Source/WebKit/UIProcess/WebCookieManagerProxy.h
>@@ -34,6 +34,7 @@
> #include <wtf/Forward.h>
> #include <wtf/HashMap.h>
> #include <wtf/RefPtr.h>
>+#include <wtf/WallTime.h>
> 
> #if USE(SOUP)
> #include "SoupCookiePersistentStorageType.h"
>@@ -65,20 +66,19 @@ public:
> 
>     void initializeClient(const WKCookieManagerClientBase*);
>     
>-    void getHostnamesWithCookies(PAL::SessionID, Function<void (API::Array*, CallbackBase::Error)>&&);
>-    void deleteCookie(PAL::SessionID, const WebCore::Cookie&, Function<void (CallbackBase::Error)>&&);
>+    void deleteCookie(PAL::SessionID, const WebCore::Cookie&, CompletionHandler<void()>&&);
>     void deleteCookiesForHostnames(PAL::SessionID, const Vector<String>&);
>     void deleteAllCookies(PAL::SessionID);
>-    void deleteAllCookiesModifiedSince(PAL::SessionID, WallTime, Function<void (CallbackBase::Error)>&&);
>+    void deleteAllCookiesModifiedSince(PAL::SessionID, WallTime, CompletionHandler<void()>&&);
> 
>-    void setCookies(PAL::SessionID, const Vector<WebCore::Cookie>&, Function<void(CallbackBase::Error)>&&);
>-    void setCookies(PAL::SessionID, const Vector<WebCore::Cookie>&, const URL&, const URL& mainDocumentURL, Function<void(CallbackBase::Error)>&&);
>+    void setCookies(PAL::SessionID, const Vector<WebCore::Cookie>&, CompletionHandler<void()>&&);
>+    void setCookies(PAL::SessionID, const Vector<WebCore::Cookie>&, const URL&, const URL& mainDocumentURL, CompletionHandler<void()>&&);
> 
>-    void getAllCookies(PAL::SessionID, Function<void (const Vector<WebCore::Cookie>&, CallbackBase::Error)>&& completionHandler);
>-    void getCookies(PAL::SessionID, const URL&, Function<void(const Vector<WebCore::Cookie>&, CallbackBase::Error)>&& completionHandler);
>+    void getAllCookies(PAL::SessionID, CompletionHandler<void(Vector<WebCore::Cookie>&&)>&&);
>+    void getCookies(PAL::SessionID, const URL&, CompletionHandler<void(Vector<WebCore::Cookie>&&)>&&);
> 
>-    void setHTTPCookieAcceptPolicy(PAL::SessionID, HTTPCookieAcceptPolicy, Function<void (CallbackBase::Error)>&&);
>-    void getHTTPCookieAcceptPolicy(PAL::SessionID, Function<void (HTTPCookieAcceptPolicy, CallbackBase::Error)>&&);
>+    void setHTTPCookieAcceptPolicy(PAL::SessionID, HTTPCookieAcceptPolicy, CompletionHandler<void()>&&);
>+    void getHTTPCookieAcceptPolicy(PAL::SessionID, CompletionHandler<void(HTTPCookieAcceptPolicy)>&&);
> 
>     void setStorageAccessAPIEnabled(bool);
> 
>@@ -108,14 +108,6 @@ public:
> private:
>     WebCookieManagerProxy(WebProcessPool*);
> 
>-    void didGetHostnamesWithCookies(const Vector<String>&, WebKit::CallbackID);
>-    void didGetHTTPCookieAcceptPolicy(HTTPCookieAcceptPolicy, WebKit::CallbackID);
>-
>-    void didSetHTTPCookieAcceptPolicy(WebKit::CallbackID);
>-    void didSetCookies(WebKit::CallbackID);
>-    void didGetCookies(const Vector<WebCore::Cookie>&, WebKit::CallbackID);
>-    void didDeleteCookies(WebKit::CallbackID);
>-
>     void cookiesDidChange(PAL::SessionID);
> 
>     // WebContextSupplement
>@@ -132,8 +124,6 @@ private:
>     void persistHTTPCookieAcceptPolicy(HTTPCookieAcceptPolicy);
> #endif
> 
>-    CallbackMap m_callbacks;
>-
>     HashMap<PAL::SessionID, WTF::Function<void ()>> m_legacyCookieObservers;
>     HashMap<PAL::SessionID, HashSet<Observer*>> m_cookieObservers;
> 
>diff --git a/Source/WebKit/UIProcess/WebCookieManagerProxy.messages.in b/Source/WebKit/UIProcess/WebCookieManagerProxy.messages.in
>index bb6723c34c5bf3d180ad88404357bb1bb7f24be7..a06b77b473ec602bd7c8c1495cd0a2286e8ca53b 100644
>--- a/Source/WebKit/UIProcess/WebCookieManagerProxy.messages.in
>+++ b/Source/WebKit/UIProcess/WebCookieManagerProxy.messages.in
>@@ -21,13 +21,5 @@
> # OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
> 
> messages -> WebCookieManagerProxy {
>-    DidGetHostnamesWithCookies(Vector<String> hostnames, WebKit::CallbackID callbackID);
>-    DidGetHTTPCookieAcceptPolicy(enum:uint8_t WebKit::HTTPCookieAcceptPolicy policy, WebKit::CallbackID callbackID);
>-
>-    DidSetHTTPCookieAcceptPolicy(WebKit::CallbackID callbackID);
>-    DidDeleteCookies(WebKit::CallbackID callbackID);
>-    DidSetCookies(WebKit::CallbackID callbackID);
>-    DidGetCookies(Vector<WebCore::Cookie> cookies, WebKit::CallbackID callbackID);
>-
>     CookiesDidChange(PAL::SessionID sessionID)
> }
>diff --git a/Source/WebKit/UIProcess/WebProcessPool.h b/Source/WebKit/UIProcess/WebProcessPool.h
>index 57068520efae1bec0fcec43b331d7cb5dcc9ecca..f4a0e18f9052d51c4776c45c43123d1d9a43fdff 100644
>--- a/Source/WebKit/UIProcess/WebProcessPool.h
>+++ b/Source/WebKit/UIProcess/WebProcessPool.h
>@@ -192,6 +192,7 @@ public:
> 
>     // Sends the message to WebProcess or NetworkProcess as approporiate for current process model.
>     template<typename T> void sendToNetworkingProcess(T&& message);
>+    template<typename T, typename C> void sendToNetworkingProcessWithAsyncReply(T&&, C&&);
>     template<typename T, typename U> void sendSyncToNetworkingProcess(T&& message, U&& reply);
>     template<typename T> void sendToNetworkingProcessRelaunchingIfNecessary(T&& message);
> 
>@@ -827,6 +828,13 @@ void WebProcessPool::sendToNetworkingProcess(T&& message)
>         m_networkProcess->send(std::forward<T>(message), 0);
> }
> 
>+template<typename T, typename C>
>+void WebProcessPool::sendToNetworkingProcessWithAsyncReply(T&& message, C&& completionHandler)
>+{
>+    ensureNetworkProcess();
>+    m_networkProcess->sendWithAsyncReply(std::forward<T>(message), std::forward<C>(completionHandler));
>+}
>+
> template<typename T>
> void WebProcessPool::sendToNetworkingProcessRelaunchingIfNecessary(T&& message)
> {
>diff --git a/Tools/ChangeLog b/Tools/ChangeLog
>index e14b12394b510c1278ff483b17d556a5fbff8a48..477fc5363039b3fac00f87c7b7ab6f3b49c07c98 100644
>--- a/Tools/ChangeLog
>+++ b/Tools/ChangeLog
>@@ -1,3 +1,16 @@
>+2019-06-27  Alex Christensen  <achristensen@webkit.org>
>+
>+        Clean up WebCookieManager
>+        https://bugs.webkit.org/show_bug.cgi?id=199256
>+
>+        Reviewed by NOBODY (OOPS!).
>+
>+        * TestWebKitAPI/Tests/WebKit/CookieManager.cpp:
>+        (TestWebKitAPI::didGetTestHTTPCookieAcceptPolicy):
>+        (TestWebKitAPI::didGetUserHTTPCookieAcceptPolicy):
>+        * WebKitTestRunner/TestController.cpp:
>+        (WTR::TestController::didReceiveSynchronousMessageFromInjectedBundle):
>+
> 2019-06-27  Beth Dakin  <bdakin@apple.com>
> 
>         Upstream use of MACCATALYST
>diff --git a/Tools/TestWebKitAPI/Tests/WebKit/CookieManager.cpp b/Tools/TestWebKitAPI/Tests/WebKit/CookieManager.cpp
>index 840c6c5a06218cd983d618bc7c52d39e8f4f4a6c..e60859b428d1e2bcf623d8580c0a50bebbe87d3d 100644
>--- a/Tools/TestWebKitAPI/Tests/WebKit/CookieManager.cpp
>+++ b/Tools/TestWebKitAPI/Tests/WebKit/CookieManager.cpp
>@@ -40,7 +40,7 @@ static WKHTTPCookieAcceptPolicy userPolicy;
> static WKHTTPCookieAcceptPolicy testPolicy;
> static WKRetainPtr<WKContextRef> wkContext;
> 
>-static void didGetTestHTTPCookieAcceptPolicy(WKHTTPCookieAcceptPolicy policy, WKErrorRef, void* context)
>+static void didGetTestHTTPCookieAcceptPolicy(WKHTTPCookieAcceptPolicy policy, void* context)
> {
>     EXPECT_EQ(reinterpret_cast<void*>(0x1234578), context);
>     EXPECT_EQ(testPolicy, policy);
>@@ -51,7 +51,7 @@ static void didGetTestHTTPCookieAcceptPolicy(WKHTTPCookieAcceptPolicy policy, WK
>     testDone = true;
> }
> 
>-static void didGetUserHTTPCookieAcceptPolicy(WKHTTPCookieAcceptPolicy policy, WKErrorRef, void* context)
>+static void didGetUserHTTPCookieAcceptPolicy(WKHTTPCookieAcceptPolicy policy, void* context)
> {
>     EXPECT_EQ(reinterpret_cast<void*>(0x1234578), context);
> 
>diff --git a/Tools/WebKitTestRunner/TestController.cpp b/Tools/WebKitTestRunner/TestController.cpp
>index bfac192334c362e1774a7bedf7727c63c166280b..3a9f46e52f46c32bf5ef79ee4226151a8674d49e 100644
>--- a/Tools/WebKitTestRunner/TestController.cpp
>+++ b/Tools/WebKitTestRunner/TestController.cpp
>@@ -2083,7 +2083,7 @@ void TestController::didReceiveSynchronousMessageFromInjectedBundle(WKStringRef
> 
>     auto setHTTPCookieAcceptPolicy = [&] (WKHTTPCookieAcceptPolicy policy, CompletionHandler<void(WKTypeRef)>&& completionHandler) {
>         auto context = new CompletionHandler<void(WKTypeRef)>(WTFMove(completionHandler));
>-        WKCookieManagerSetHTTPCookieAcceptPolicy(WKContextGetCookieManager(this->context()), policy, context, [] (WKErrorRef error, void* context) {
>+        WKCookieManagerSetHTTPCookieAcceptPolicy(WKContextGetCookieManager(this->context()), policy, context, [] (void* context) {
>             auto completionHandlerPointer = static_cast<CompletionHandler<void(WKTypeRef)>*>(context);
>             (*completionHandlerPointer)(nullptr);
>             delete completionHandlerPointer;

Flags:

mcatanzaro: review+

Actions: View | Formatted Diff | Diff

Attachments on bug 199256: 372995 | 373000 | 373034 | 373038 | 373045