WebKitCookieManager.cpp [plain text]
#include "config.h"
#include "WebKitCookieManager.h"
#include "NetworkProcessProxy.h"
#include "SoupCookiePersistentStorageType.h"
#include "WebCookieManagerProxy.h"
#include "WebKitCookieManagerPrivate.h"
#include "WebKitEnumTypes.h"
#include "WebKitWebsiteDataManagerPrivate.h"
#include "WebKitWebsiteDataPrivate.h"
#include "WebsiteDataRecord.h"
#include <WebCore/HTTPCookieAcceptPolicy.h>
#include <glib/gi18n-lib.h>
#include <pal/SessionID.h>
#include <wtf/glib/GRefPtr.h>
#include <wtf/glib/WTFGType.h>
#include <wtf/text/CString.h>
using namespace WebKit;
enum {
CHANGED,
LAST_SIGNAL
};
struct _WebKitCookieManagerPrivate {
WebCookieManagerProxy& cookieManager() const
{
ASSERT(dataManager);
return webkitWebsiteDataManagerGetDataStore(dataManager).networkProcess().cookieManager();
}
PAL::SessionID sessionID() const
{
ASSERT(dataManager);
return webkitWebsiteDataManagerGetDataStore(dataManager).sessionID();
}
~_WebKitCookieManagerPrivate()
{
cookieManager().setCookieObserverCallback(sessionID(), nullptr);
}
WebKitWebsiteDataManager* dataManager;
};
static guint signals[LAST_SIGNAL] = { 0, };
WEBKIT_DEFINE_TYPE(WebKitCookieManager, webkit_cookie_manager, G_TYPE_OBJECT)
static inline SoupCookiePersistentStorageType toSoupCookiePersistentStorageType(WebKitCookiePersistentStorage kitStorage)
{
switch (kitStorage) {
case WEBKIT_COOKIE_PERSISTENT_STORAGE_TEXT:
return SoupCookiePersistentStorageType::Text;
case WEBKIT_COOKIE_PERSISTENT_STORAGE_SQLITE:
return SoupCookiePersistentStorageType::SQLite;
default:
ASSERT_NOT_REACHED();
return SoupCookiePersistentStorageType::Text;
}
}
static inline WebKitCookieAcceptPolicy toWebKitCookieAcceptPolicy(WebCore::HTTPCookieAcceptPolicy httpPolicy)
{
switch (httpPolicy) {
case WebCore::HTTPCookieAcceptPolicy::AlwaysAccept:
return WEBKIT_COOKIE_POLICY_ACCEPT_ALWAYS;
case WebCore::HTTPCookieAcceptPolicy::Never:
return WEBKIT_COOKIE_POLICY_ACCEPT_NEVER;
case WebCore::HTTPCookieAcceptPolicy::ExclusivelyFromMainDocumentDomain:
return WEBKIT_COOKIE_POLICY_ACCEPT_NO_THIRD_PARTY;
case WebCore::HTTPCookieAcceptPolicy::OnlyFromMainDocumentDomain:
break;
}
RELEASE_ASSERT_NOT_REACHED();
}
static inline WebCore::HTTPCookieAcceptPolicy toHTTPCookieAcceptPolicy(WebKitCookieAcceptPolicy kitPolicy)
{
switch (kitPolicy) {
case WEBKIT_COOKIE_POLICY_ACCEPT_ALWAYS:
return WebCore::HTTPCookieAcceptPolicy::AlwaysAccept;
case WEBKIT_COOKIE_POLICY_ACCEPT_NEVER:
return WebCore::HTTPCookieAcceptPolicy::Never;
case WEBKIT_COOKIE_POLICY_ACCEPT_NO_THIRD_PARTY:
return WebCore::HTTPCookieAcceptPolicy::ExclusivelyFromMainDocumentDomain;
}
RELEASE_ASSERT_NOT_REACHED();
}
static void webkit_cookie_manager_class_init(WebKitCookieManagerClass* findClass)
{
GObjectClass* gObjectClass = G_OBJECT_CLASS(findClass);
signals[CHANGED] =
g_signal_new("changed",
G_TYPE_FROM_CLASS(gObjectClass),
G_SIGNAL_RUN_LAST,
0, 0, 0,
g_cclosure_marshal_VOID__VOID,
G_TYPE_NONE, 0);
}
WebKitCookieManager* webkitCookieManagerCreate(WebKitWebsiteDataManager* dataManager)
{
WebKitCookieManager* manager = WEBKIT_COOKIE_MANAGER(g_object_new(WEBKIT_TYPE_COOKIE_MANAGER, nullptr));
manager->priv->dataManager = dataManager;
manager->priv->cookieManager().setCookieObserverCallback(manager->priv->sessionID(), [manager] {
g_signal_emit(manager, signals[CHANGED], 0);
});
return manager;
}
void webkit_cookie_manager_set_persistent_storage(WebKitCookieManager* manager, const char* filename, WebKitCookiePersistentStorage storage)
{
g_return_if_fail(WEBKIT_IS_COOKIE_MANAGER(manager));
g_return_if_fail(filename);
g_return_if_fail(!webkit_website_data_manager_is_ephemeral(manager->priv->dataManager));
auto sessionID = manager->priv->sessionID();
if (sessionID.isEphemeral())
return;
manager->priv->cookieManager().setCookiePersistentStorage(sessionID, String::fromUTF8(filename), toSoupCookiePersistentStorageType(storage));
}
void webkit_cookie_manager_set_accept_policy(WebKitCookieManager* manager, WebKitCookieAcceptPolicy policy)
{
g_return_if_fail(WEBKIT_IS_COOKIE_MANAGER(manager));
manager->priv->cookieManager().setHTTPCookieAcceptPolicy(manager->priv->sessionID(), toHTTPCookieAcceptPolicy(policy), []() { });
}
void webkit_cookie_manager_get_accept_policy(WebKitCookieManager* manager, GCancellable* cancellable, GAsyncReadyCallback callback, gpointer userData)
{
g_return_if_fail(WEBKIT_IS_COOKIE_MANAGER(manager));
GRefPtr<GTask> task = adoptGRef(g_task_new(manager, cancellable, callback, userData));
manager->priv->cookieManager().getHTTPCookieAcceptPolicy(manager->priv->sessionID(), [task = WTFMove(task)](WebCore::HTTPCookieAcceptPolicy policy) {
g_task_return_int(task.get(), toWebKitCookieAcceptPolicy(policy));
});
}
WebKitCookieAcceptPolicy webkit_cookie_manager_get_accept_policy_finish(WebKitCookieManager* manager, GAsyncResult* result, GError** error)
{
g_return_val_if_fail(WEBKIT_IS_COOKIE_MANAGER(manager), WEBKIT_COOKIE_POLICY_ACCEPT_NO_THIRD_PARTY);
g_return_val_if_fail(g_task_is_valid(result, manager), WEBKIT_COOKIE_POLICY_ACCEPT_NO_THIRD_PARTY);
gssize returnValue = g_task_propagate_int(G_TASK(result), error);
return returnValue == -1 ? WEBKIT_COOKIE_POLICY_ACCEPT_NO_THIRD_PARTY : static_cast<WebKitCookieAcceptPolicy>(returnValue);
}
void webkit_cookie_manager_add_cookie(WebKitCookieManager* manager, SoupCookie* cookie, GCancellable* cancellable, GAsyncReadyCallback callback, gpointer userData)
{
g_return_if_fail(WEBKIT_IS_COOKIE_MANAGER(manager));
g_return_if_fail(cookie);
GRefPtr<GTask> task = adoptGRef(g_task_new(manager, cancellable, callback, userData));
manager->priv->cookieManager().setCookies(manager->priv->sessionID(), { WebCore::Cookie(cookie) }, [task = WTFMove(task)]() {
g_task_return_boolean(task.get(), TRUE);
});
}
gboolean webkit_cookie_manager_add_cookie_finish(WebKitCookieManager* manager, GAsyncResult* result, GError** error)
{
g_return_val_if_fail(WEBKIT_IS_COOKIE_MANAGER(manager), FALSE);
g_return_val_if_fail(g_task_is_valid(result, manager), FALSE);
return g_task_propagate_boolean(G_TASK(result), error);
}
void webkit_cookie_manager_get_cookies(WebKitCookieManager* manager, const gchar* uri, GCancellable* cancellable, GAsyncReadyCallback callback, gpointer userData)
{
g_return_if_fail(WEBKIT_IS_COOKIE_MANAGER(manager));
g_return_if_fail(uri);
GRefPtr<GTask> task = adoptGRef(g_task_new(manager, cancellable, callback, userData));
manager->priv->cookieManager().getCookies(manager->priv->sessionID(), URL(URL(), String::fromUTF8(uri)), [task = WTFMove(task)](const Vector<WebCore::Cookie>& cookies) {
GList* cookiesList = nullptr;
for (auto& cookie : cookies)
cookiesList = g_list_prepend(cookiesList, cookie.toSoupCookie());
g_task_return_pointer(task.get(), g_list_reverse(cookiesList), [](gpointer data) {
g_list_free_full(static_cast<GList*>(data), reinterpret_cast<GDestroyNotify>(soup_cookie_free));
});
});
}
GList* webkit_cookie_manager_get_cookies_finish(WebKitCookieManager* manager, GAsyncResult* result, GError** error)
{
g_return_val_if_fail(WEBKIT_IS_COOKIE_MANAGER(manager), nullptr);
g_return_val_if_fail(g_task_is_valid(result, manager), nullptr);
return reinterpret_cast<GList*>(g_task_propagate_pointer(G_TASK(result), error));
}
void webkit_cookie_manager_delete_cookie(WebKitCookieManager* manager, SoupCookie* cookie, GCancellable* cancellable, GAsyncReadyCallback callback, gpointer userData)
{
g_return_if_fail(WEBKIT_IS_COOKIE_MANAGER(manager));
g_return_if_fail(cookie);
GRefPtr<GTask> task = adoptGRef(g_task_new(manager, cancellable, callback, userData));
manager->priv->cookieManager().deleteCookie(manager->priv->sessionID(), WebCore::Cookie(cookie), [task = WTFMove(task)]() {
g_task_return_boolean(task.get(), TRUE);
});
}
gboolean webkit_cookie_manager_delete_cookie_finish(WebKitCookieManager* manager, GAsyncResult* result, GError** error)
{
g_return_val_if_fail(WEBKIT_IS_COOKIE_MANAGER(manager), FALSE);
g_return_val_if_fail(g_task_is_valid(result, manager), FALSE);
return g_task_propagate_boolean(G_TASK(result), error);
}
#if PLATFORM(GTK)
void webkit_cookie_manager_get_domains_with_cookies(WebKitCookieManager* manager, GCancellable* cancellable, GAsyncReadyCallback callback, gpointer userData)
{
g_return_if_fail(WEBKIT_IS_COOKIE_MANAGER(manager));
GTask* task = g_task_new(manager, cancellable, callback, userData);
webkit_website_data_manager_fetch(manager->priv->dataManager, WEBKIT_WEBSITE_DATA_COOKIES, cancellable, [](GObject* object, GAsyncResult* result, gpointer userData) {
GRefPtr<GTask> task = adoptGRef(G_TASK(userData));
GError* error = nullptr;
GUniquePtr<GList> dataList(webkit_website_data_manager_fetch_finish(WEBKIT_WEBSITE_DATA_MANAGER(object), result, &error));
if (error) {
g_task_return_error(task.get(), error);
return;
}
GPtrArray* domains = g_ptr_array_sized_new(g_list_length(dataList.get()));
for (GList* item = dataList.get(); item; item = g_list_next(item)) {
auto* data = static_cast<WebKitWebsiteData*>(item->data);
g_ptr_array_add(domains, g_strdup(webkit_website_data_get_name(data)));
webkit_website_data_unref(data);
}
g_ptr_array_add(domains, nullptr);
g_task_return_pointer(task.get(), g_ptr_array_free(domains, FALSE), reinterpret_cast<GDestroyNotify>(g_strfreev));
}, task);
}
gchar** webkit_cookie_manager_get_domains_with_cookies_finish(WebKitCookieManager* manager, GAsyncResult* result, GError** error)
{
g_return_val_if_fail(WEBKIT_IS_COOKIE_MANAGER(manager), nullptr);
g_return_val_if_fail(g_task_is_valid(result, manager), nullptr);
return reinterpret_cast<char**>(g_task_propagate_pointer(G_TASK(result), error));
}
void webkit_cookie_manager_delete_cookies_for_domain(WebKitCookieManager* manager, const gchar* domain)
{
g_return_if_fail(WEBKIT_IS_COOKIE_MANAGER(manager));
g_return_if_fail(domain);
WebsiteDataRecord record;
record.addCookieHostName(String::fromUTF8(domain));
auto* data = webkitWebsiteDataCreate(WTFMove(record));
GList dataList = { data, nullptr, nullptr };
webkit_website_data_manager_remove(manager->priv->dataManager, WEBKIT_WEBSITE_DATA_COOKIES, &dataList, nullptr, nullptr, nullptr);
webkit_website_data_unref(data);
}
void webkit_cookie_manager_delete_all_cookies(WebKitCookieManager* manager)
{
g_return_if_fail(WEBKIT_IS_COOKIE_MANAGER(manager));
webkit_website_data_manager_clear(manager->priv->dataManager, WEBKIT_WEBSITE_DATA_COOKIES, 0, nullptr, nullptr, nullptr);
}
#endif