WebKitCookieManager.cpp [plain text]
#include "config.h"
#include "WebKitCookieManager.h"
#include "SoupCookiePersistentStorageType.h"
#include "WebCookieManagerProxy.h"
#include "WebKitCookieManagerPrivate.h"
#include "WebKitEnumTypes.h"
#include <wtf/gobject/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)
COMPILE_ASSERT_MATCHING_ENUM(WEBKIT_COOKIE_PERSISTENT_STORAGE_TEXT, SoupCookiePersistentStorageText);
COMPILE_ASSERT_MATCHING_ENUM(WEBKIT_COOKIE_PERSISTENT_STORAGE_SQLITE, SoupCookiePersistentStorageSQLite);
COMPILE_ASSERT_MATCHING_ENUM(WEBKIT_COOKIE_POLICY_ACCEPT_ALWAYS, HTTPCookieAcceptPolicyAlways);
COMPILE_ASSERT_MATCHING_ENUM(WEBKIT_COOKIE_POLICY_ACCEPT_NEVER, HTTPCookieAcceptPolicyNever);
COMPILE_ASSERT_MATCHING_ENUM(WEBKIT_COOKIE_POLICY_ACCEPT_NO_THIRD_PARTY, HTTPCookieAcceptPolicyOnlyFromMainDocumentDomain);
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;
WKCookieManagerClient wkCookieManagerClient = {
kWKCookieManagerClientCurrentVersion,
manager, cookiesDidChange
};
WKCookieManagerSetClient(toAPI(webCookieManager), &wkCookieManagerClient);
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), 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(policy);
}
struct GetAcceptPolicyAsyncData {
WKHTTPCookieAcceptPolicy policy;
GRefPtr<GCancellable> cancellable;
};
WEBKIT_DEFINE_ASYNC_DATA_STRUCT(GetAcceptPolicyAsyncData)
static void webkitCookieManagerGetAcceptPolicyCallback(WKHTTPCookieAcceptPolicy policy, WKErrorRef, void* context)
{
GRefPtr<GSimpleAsyncResult> result = adoptGRef(G_SIMPLE_ASYNC_RESULT(context));
GetAcceptPolicyAsyncData* data = static_cast<GetAcceptPolicyAsyncData*>(g_simple_async_result_get_op_res_gpointer(result.get()));
GError* error = 0;
if (g_cancellable_set_error_if_cancelled(data->cancellable.get(), &error))
g_simple_async_result_take_error(result.get(), error);
else
data->policy = policy;
g_simple_async_result_complete(result.get());
}
void webkit_cookie_manager_get_accept_policy(WebKitCookieManager* manager, GCancellable* cancellable, GAsyncReadyCallback callback, gpointer userData)
{
g_return_if_fail(WEBKIT_IS_COOKIE_MANAGER(manager));
GSimpleAsyncResult* result = g_simple_async_result_new(G_OBJECT(manager), callback, userData,
reinterpret_cast<gpointer>(webkit_cookie_manager_get_accept_policy));
GetAcceptPolicyAsyncData* data = createGetAcceptPolicyAsyncData();
data->cancellable = cancellable;
g_simple_async_result_set_op_res_gpointer(result, data, reinterpret_cast<GDestroyNotify>(destroyGetAcceptPolicyAsyncData));
manager->priv->webCookieManager->getHTTPCookieAcceptPolicy(HTTPCookieAcceptPolicyCallback::create(result, 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_IS_ASYNC_RESULT(result), WEBKIT_COOKIE_POLICY_ACCEPT_NO_THIRD_PARTY);
GSimpleAsyncResult* simpleResult = G_SIMPLE_ASYNC_RESULT(result);
g_warn_if_fail(g_simple_async_result_get_source_tag(simpleResult) == webkit_cookie_manager_get_accept_policy);
if (g_simple_async_result_propagate_error(simpleResult, error))
return WEBKIT_COOKIE_POLICY_ACCEPT_NO_THIRD_PARTY;
GetAcceptPolicyAsyncData* data = static_cast<GetAcceptPolicyAsyncData*>(g_simple_async_result_get_op_res_gpointer(simpleResult));
return static_cast<WebKitCookieAcceptPolicy>(data->policy);
}
struct GetDomainsWithCookiesAsyncData {
GRefPtr<GPtrArray> domains;
GRefPtr<GCancellable> cancellable;
};
WEBKIT_DEFINE_ASYNC_DATA_STRUCT(GetDomainsWithCookiesAsyncData)
static void webkitCookieManagerGetDomainsWithCookiesCallback(WKArrayRef wkDomains, WKErrorRef, void* context)
{
GRefPtr<GSimpleAsyncResult> result = adoptGRef(G_SIMPLE_ASYNC_RESULT(context));
GetDomainsWithCookiesAsyncData* data = static_cast<GetDomainsWithCookiesAsyncData*>(g_simple_async_result_get_op_res_gpointer(result.get()));
GError* error = 0;
if (g_cancellable_set_error_if_cancelled(data->cancellable.get(), &error))
g_simple_async_result_take_error(result.get(), error);
else {
ImmutableArray* domains = toImpl(wkDomains);
data->domains = adoptGRef(g_ptr_array_new_with_free_func(g_free));
for (size_t i = 0; i < domains->size(); ++i) {
WebString* domainString = static_cast<WebString*>(domains->at(i));
String domain = domainString->string();
if (domain.isEmpty())
continue;
g_ptr_array_add(data->domains.get(), g_strdup(domain.utf8().data()));
}
g_ptr_array_add(data->domains.get(), 0);
}
g_simple_async_result_complete(result.get());
}
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));
GSimpleAsyncResult* result = g_simple_async_result_new(G_OBJECT(manager), callback, userData,
reinterpret_cast<gpointer>(webkit_cookie_manager_get_domains_with_cookies));
GetDomainsWithCookiesAsyncData* data = createGetDomainsWithCookiesAsyncData();
data->cancellable = cancellable;
g_simple_async_result_set_op_res_gpointer(result, data, reinterpret_cast<GDestroyNotify>(destroyGetDomainsWithCookiesAsyncData));
manager->priv->webCookieManager->getHostnamesWithCookies(ArrayCallback::create(result, 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_IS_ASYNC_RESULT(result), 0);
GSimpleAsyncResult* simpleResult = G_SIMPLE_ASYNC_RESULT(result);
g_warn_if_fail(g_simple_async_result_get_source_tag(simpleResult) == webkit_cookie_manager_get_domains_with_cookies);
if (g_simple_async_result_propagate_error(simpleResult, error))
return 0;
GetDomainsWithCookiesAsyncData* data = static_cast<GetDomainsWithCookiesAsyncData*>(g_simple_async_result_get_op_res_gpointer(simpleResult));
return reinterpret_cast<char**>(g_ptr_array_free(data->domains.leakRef(), FALSE));
}
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();
}