WebKitCookieManager.cpp [plain text]
#include "config.h"
#include "WebKitCookieManager.h"
#include "APIString.h"
#include "SoupCookiePersistentStorageType.h"
#include "WebCookieManagerProxy.h"
#include "WebKitCookieManagerPrivate.h"
#include "WebKitEnumTypes.h"
#include <wtf/glib/GRefPtr.h>
#include <wtf/text/CString.h>
using namespace WebKit;
enum {
CHANGED,
LAST_SIGNAL
};
struct _WebKitCookieManagerPrivate {
~_WebKitCookieManagerPrivate()
{
webCookieManager->stopObservingCookieChanges();
}
RefPtr<WebCookieManagerProxy> webCookieManager;
};
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 SoupCookiePersistentStorageText;
case WEBKIT_COOKIE_PERSISTENT_STORAGE_SQLITE:
return SoupCookiePersistentStorageSQLite;
default:
ASSERT_NOT_REACHED();
return SoupCookiePersistentStorageText;
}
}
static inline WebKitCookieAcceptPolicy toWebKitCookieAcceptPolicy(HTTPCookieAcceptPolicy httpPolicy)
{
switch (httpPolicy) {
case HTTPCookieAcceptPolicyAlways:
return WEBKIT_COOKIE_POLICY_ACCEPT_ALWAYS;
case HTTPCookieAcceptPolicyNever:
return WEBKIT_COOKIE_POLICY_ACCEPT_NEVER;
case HTTPCookieAcceptPolicyOnlyFromMainDocumentDomain:
return WEBKIT_COOKIE_POLICY_ACCEPT_NO_THIRD_PARTY;
default:
ASSERT_NOT_REACHED();
return WEBKIT_COOKIE_POLICY_ACCEPT_ALWAYS;
}
}
static inline HTTPCookieAcceptPolicy toHTTPCookieAcceptPolicy(WebKitCookieAcceptPolicy kitPolicy)
{
switch (kitPolicy) {
case WEBKIT_COOKIE_POLICY_ACCEPT_ALWAYS:
return HTTPCookieAcceptPolicyAlways;
case WEBKIT_COOKIE_POLICY_ACCEPT_NEVER:
return HTTPCookieAcceptPolicyNever;
case WEBKIT_COOKIE_POLICY_ACCEPT_NO_THIRD_PARTY:
return HTTPCookieAcceptPolicyOnlyFromMainDocumentDomain;
default:
ASSERT_NOT_REACHED();
return HTTPCookieAcceptPolicyAlways;
}
}
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);
}
static void cookiesDidChange(WKCookieManagerRef, const void* clientInfo)
{
g_signal_emit(WEBKIT_COOKIE_MANAGER(clientInfo), signals[CHANGED], 0);
}
WebKitCookieManager* webkitCookieManagerCreate(WebCookieManagerProxy* webCookieManager)
{
WebKitCookieManager* manager = WEBKIT_COOKIE_MANAGER(g_object_new(WEBKIT_TYPE_COOKIE_MANAGER, NULL));
manager->priv->webCookieManager = webCookieManager;
WKCookieManagerClientV0 wkCookieManagerClient = {
{
0, manager, },
cookiesDidChange
};
WKCookieManagerSetClient(toAPI(webCookieManager), &wkCookieManagerClient.base);
manager->priv->webCookieManager->startObservingCookieChanges();
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);
manager->priv->webCookieManager->stopObservingCookieChanges();
manager->priv->webCookieManager->setCookiePersistentStorage(String::fromUTF8(filename), toSoupCookiePersistentStorageType(storage));
manager->priv->webCookieManager->startObservingCookieChanges();
}
void webkit_cookie_manager_set_accept_policy(WebKitCookieManager* manager, WebKitCookieAcceptPolicy policy)
{
g_return_if_fail(WEBKIT_IS_COOKIE_MANAGER(manager));
manager->priv->webCookieManager->setHTTPCookieAcceptPolicy(toHTTPCookieAcceptPolicy(policy));
}
static void webkitCookieManagerGetAcceptPolicyCallback(WKHTTPCookieAcceptPolicy policy, WKErrorRef, void* context)
{
GRefPtr<GTask> task = adoptGRef(G_TASK(context));
g_task_return_int(task.get(), toWebKitCookieAcceptPolicy(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));
GTask* task = g_task_new(manager, cancellable, callback, userData);
manager->priv->webCookieManager->getHTTPCookieAcceptPolicy(toGenericCallbackFunction<WKHTTPCookieAcceptPolicy, HTTPCookieAcceptPolicy>(task, webkitCookieManagerGetAcceptPolicyCallback));
}
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);
}
static void webkitCookieManagerGetDomainsWithCookiesCallback(WKArrayRef wkDomains, WKErrorRef, void* context)
{
GRefPtr<GTask> task = adoptGRef(G_TASK(context));
if (g_task_return_error_if_cancelled(task.get()))
return;
API::Array* domains = toImpl(wkDomains);
GPtrArray* returnValue = g_ptr_array_sized_new(domains->size());
for (size_t i = 0; i < domains->size(); ++i) {
API::String* domainString = static_cast<API::String*>(domains->at(i));
String domain = domainString->string();
if (domain.isEmpty())
continue;
g_ptr_array_add(returnValue, g_strdup(domain.utf8().data()));
}
g_ptr_array_add(returnValue, 0);
g_task_return_pointer(task.get(), g_ptr_array_free(returnValue, FALSE), reinterpret_cast<GDestroyNotify>(g_strfreev));
}
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);
manager->priv->webCookieManager->getHostnamesWithCookies(toGenericCallbackFunction(task, webkitCookieManagerGetDomainsWithCookiesCallback));
}
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), 0);
g_return_val_if_fail(g_task_is_valid(result, manager), 0);
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);
manager->priv->webCookieManager->deleteCookiesForHostname(String::fromUTF8(domain));
}
void webkit_cookie_manager_delete_all_cookies(WebKitCookieManager* manager)
{
g_return_if_fail(WEBKIT_IS_COOKIE_MANAGER(manager));
manager->priv->webCookieManager->deleteAllCookies();
}