01e1a3eda83df0bd8bbdbdf7f6a64e0266329cd7
[WebKit-https.git] / Source / WebKit / UIProcess / API / glib / WebKitCookieManager.cpp
1 /*
2  * Copyright (C) 2012 Igalia S.L.
3  * Copyright (C) 2017 Endless Mobile, Inc.
4  *
5  * This library is free software; you can redistribute it and/or
6  * modify it under the terms of the GNU Lesser General Public
7  * License as published by the Free Software Foundation; either
8  * version 2,1 of the License, or (at your option) any later version.
9  *
10  * This library is distributed in the hope that it will be useful,
11  * but WITHOUT ANY WARRANTY; without even the implied warranty of
12  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
13  * Library General Public License for more details.
14  *
15  * You should have received a copy of the GNU Library General Public License
16  * along with this library; see the file COPYING.LIB.  If not, write to
17  * the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
18  * Boston, MA 02110-1301, USA.
19  */
20
21 #include "config.h"
22 #include "WebKitCookieManager.h"
23
24 #include "SoupCookiePersistentStorageType.h"
25 #include "WebCookieManagerProxy.h"
26 #include "WebKitCookieManagerPrivate.h"
27 #include "WebKitEnumTypes.h"
28 #include "WebKitWebsiteDataManagerPrivate.h"
29 #include "WebKitWebsiteDataPrivate.h"
30 #include "WebsiteDataRecord.h"
31 #include <glib/gi18n-lib.h>
32 #include <pal/SessionID.h>
33 #include <wtf/glib/GRefPtr.h>
34 #include <wtf/glib/WTFGType.h>
35 #include <wtf/text/CString.h>
36
37 using namespace WebKit;
38
39 /**
40  * SECTION: WebKitCookieManager
41  * @Short_description: Defines how to handle cookies in a #WebKitWebContext
42  * @Title: WebKitCookieManager
43  *
44  * The WebKitCookieManager defines how to set up and handle cookies.
45  * You can get it from a #WebKitWebsiteDataManager with
46  * webkit_website_data_manager_get_cookie_manager(), and use it to set where to
47  * store cookies with webkit_cookie_manager_set_persistent_storage(),
48  * or to set the acceptance policy, with webkit_cookie_manager_get_accept_policy().
49  */
50
51 enum {
52     CHANGED,
53
54     LAST_SIGNAL
55 };
56
57 struct _WebKitCookieManagerPrivate {
58     ~_WebKitCookieManagerPrivate()
59     {
60         auto sessionID = webkitWebsiteDataManagerGetDataStore(dataManager).websiteDataStore().sessionID();
61         for (auto* processPool : webkitWebsiteDataManagerGetProcessPools(dataManager))
62             processPool->supplement<WebCookieManagerProxy>()->setCookieObserverCallback(sessionID, nullptr);
63     }
64
65     WebKitWebsiteDataManager* dataManager;
66 };
67
68 static guint signals[LAST_SIGNAL] = { 0, };
69
70 WEBKIT_DEFINE_TYPE(WebKitCookieManager, webkit_cookie_manager, G_TYPE_OBJECT)
71
72 static inline SoupCookiePersistentStorageType toSoupCookiePersistentStorageType(WebKitCookiePersistentStorage kitStorage)
73 {
74     switch (kitStorage) {
75     case WEBKIT_COOKIE_PERSISTENT_STORAGE_TEXT:
76         return SoupCookiePersistentStorageText;
77     case WEBKIT_COOKIE_PERSISTENT_STORAGE_SQLITE:
78         return SoupCookiePersistentStorageSQLite;
79     default:
80         ASSERT_NOT_REACHED();
81         return SoupCookiePersistentStorageText;
82     }
83 }
84
85 static inline WebKitCookieAcceptPolicy toWebKitCookieAcceptPolicy(HTTPCookieAcceptPolicy httpPolicy)
86 {
87     switch (httpPolicy) {
88     case HTTPCookieAcceptPolicyAlways:
89         return WEBKIT_COOKIE_POLICY_ACCEPT_ALWAYS;
90     case HTTPCookieAcceptPolicyNever:
91         return WEBKIT_COOKIE_POLICY_ACCEPT_NEVER;
92     case HTTPCookieAcceptPolicyOnlyFromMainDocumentDomain:
93         return WEBKIT_COOKIE_POLICY_ACCEPT_NO_THIRD_PARTY;
94     default:
95         ASSERT_NOT_REACHED();
96         return WEBKIT_COOKIE_POLICY_ACCEPT_ALWAYS;
97     }
98 }
99
100 static inline HTTPCookieAcceptPolicy toHTTPCookieAcceptPolicy(WebKitCookieAcceptPolicy kitPolicy)
101 {
102     switch (kitPolicy) {
103     case WEBKIT_COOKIE_POLICY_ACCEPT_ALWAYS:
104         return HTTPCookieAcceptPolicyAlways;
105     case WEBKIT_COOKIE_POLICY_ACCEPT_NEVER:
106         return HTTPCookieAcceptPolicyNever;
107     case WEBKIT_COOKIE_POLICY_ACCEPT_NO_THIRD_PARTY:
108         return HTTPCookieAcceptPolicyOnlyFromMainDocumentDomain;
109     default:
110         ASSERT_NOT_REACHED();
111         return HTTPCookieAcceptPolicyAlways;
112     }
113 }
114
115 static void webkit_cookie_manager_class_init(WebKitCookieManagerClass* findClass)
116 {
117     GObjectClass* gObjectClass = G_OBJECT_CLASS(findClass);
118
119     /**
120      * WebKitCookieManager::changed:
121      * @cookie_manager: the #WebKitCookieManager
122      *
123      * This signal is emitted when cookies are added, removed or modified.
124      */
125     signals[CHANGED] =
126         g_signal_new("changed",
127                      G_TYPE_FROM_CLASS(gObjectClass),
128                      G_SIGNAL_RUN_LAST,
129                      0, 0, 0,
130                      g_cclosure_marshal_VOID__VOID,
131                      G_TYPE_NONE, 0);
132 }
133
134 WebKitCookieManager* webkitCookieManagerCreate(WebKitWebsiteDataManager* dataManager)
135 {
136     WebKitCookieManager* manager = WEBKIT_COOKIE_MANAGER(g_object_new(WEBKIT_TYPE_COOKIE_MANAGER, nullptr));
137     manager->priv->dataManager = dataManager;
138     auto sessionID = webkitWebsiteDataManagerGetDataStore(manager->priv->dataManager).websiteDataStore().sessionID();
139     for (auto* processPool : webkitWebsiteDataManagerGetProcessPools(manager->priv->dataManager)) {
140         processPool->supplement<WebCookieManagerProxy>()->setCookieObserverCallback(sessionID, [manager] {
141             g_signal_emit(manager, signals[CHANGED], 0);
142         });
143     }
144     return manager;
145 }
146
147 /**
148  * webkit_cookie_manager_set_persistent_storage:
149  * @cookie_manager: a #WebKitCookieManager
150  * @filename: the filename to read to/write from
151  * @storage: a #WebKitCookiePersistentStorage
152  *
153  * Set the @filename where non-session cookies are stored persistently using
154  * @storage as the format to read/write the cookies.
155  * Cookies are initially read from @filename to create an initial set of cookies.
156  * Then, non-session cookies will be written to @filename when the WebKitCookieManager::changed
157  * signal is emitted.
158  * By default, @cookie_manager doesn't store the cookies persistently, so you need to call this
159  * method to keep cookies saved across sessions.
160  *
161  * This method should never be called on a #WebKitCookieManager associated to an ephemeral #WebKitWebsiteDataManager.
162  */
163 void webkit_cookie_manager_set_persistent_storage(WebKitCookieManager* manager, const char* filename, WebKitCookiePersistentStorage storage)
164 {
165     g_return_if_fail(WEBKIT_IS_COOKIE_MANAGER(manager));
166     g_return_if_fail(filename);
167     g_return_if_fail(!webkit_website_data_manager_is_ephemeral(manager->priv->dataManager));
168
169     auto sessionID = webkitWebsiteDataManagerGetDataStore(manager->priv->dataManager).websiteDataStore().sessionID();
170     if (sessionID.isEphemeral())
171         return;
172
173     for (auto* processPool : webkitWebsiteDataManagerGetProcessPools(manager->priv->dataManager))
174         processPool->supplement<WebCookieManagerProxy>()->setCookiePersistentStorage(sessionID, String::fromUTF8(filename), toSoupCookiePersistentStorageType(storage));
175 }
176
177 /**
178  * webkit_cookie_manager_set_accept_policy:
179  * @cookie_manager: a #WebKitCookieManager
180  * @policy: a #WebKitCookieAcceptPolicy
181  *
182  * Set the cookie acceptance policy of @cookie_manager as @policy.
183  */
184 void webkit_cookie_manager_set_accept_policy(WebKitCookieManager* manager, WebKitCookieAcceptPolicy policy)
185 {
186     g_return_if_fail(WEBKIT_IS_COOKIE_MANAGER(manager));
187
188     for (auto* processPool : webkitWebsiteDataManagerGetProcessPools(manager->priv->dataManager))
189         processPool->supplement<WebCookieManagerProxy>()->setHTTPCookieAcceptPolicy(PAL::SessionID::defaultSessionID(), toHTTPCookieAcceptPolicy(policy), [](CallbackBase::Error){});
190 }
191
192 /**
193  * webkit_cookie_manager_get_accept_policy:
194  * @cookie_manager: a #WebKitCookieManager
195  * @cancellable: (allow-none): a #GCancellable or %NULL to ignore
196  * @callback: (scope async): a #GAsyncReadyCallback to call when the request is satisfied
197  * @user_data: (closure): the data to pass to callback function
198  *
199  * Asynchronously get the cookie acceptance policy of @cookie_manager.
200  *
201  * When the operation is finished, @callback will be called. You can then call
202  * webkit_cookie_manager_get_accept_policy_finish() to get the result of the operation.
203  */
204 void webkit_cookie_manager_get_accept_policy(WebKitCookieManager* manager, GCancellable* cancellable, GAsyncReadyCallback callback, gpointer userData)
205 {
206     g_return_if_fail(WEBKIT_IS_COOKIE_MANAGER(manager));
207
208     GRefPtr<GTask> task = adoptGRef(g_task_new(manager, cancellable, callback, userData));
209
210     // The policy is the same in all process pools having the same session ID, so just ask any.
211     const auto& processPools = webkitWebsiteDataManagerGetProcessPools(manager->priv->dataManager);
212     if (processPools.isEmpty()) {
213         g_task_return_int(task.get(), WEBKIT_COOKIE_POLICY_ACCEPT_NO_THIRD_PARTY);
214         return;
215     }
216
217     processPools[0]->supplement<WebCookieManagerProxy>()->getHTTPCookieAcceptPolicy(PAL::SessionID::defaultSessionID(), [task = WTFMove(task)](HTTPCookieAcceptPolicy policy, CallbackBase::Error) {
218         g_task_return_int(task.get(), toWebKitCookieAcceptPolicy(policy));
219     });
220 }
221
222 /**
223  * webkit_cookie_manager_get_accept_policy_finish:
224  * @cookie_manager: a #WebKitCookieManager
225  * @result: a #GAsyncResult
226  * @error: return location for error or %NULL to ignore
227  *
228  * Finish an asynchronous operation started with webkit_cookie_manager_get_accept_policy().
229  *
230  * Returns: the cookie acceptance policy of @cookie_manager as a #WebKitCookieAcceptPolicy.
231  */
232 WebKitCookieAcceptPolicy webkit_cookie_manager_get_accept_policy_finish(WebKitCookieManager* manager, GAsyncResult* result, GError** error)
233 {
234     g_return_val_if_fail(WEBKIT_IS_COOKIE_MANAGER(manager), WEBKIT_COOKIE_POLICY_ACCEPT_NO_THIRD_PARTY);
235     g_return_val_if_fail(g_task_is_valid(result, manager), WEBKIT_COOKIE_POLICY_ACCEPT_NO_THIRD_PARTY);
236
237     gssize returnValue = g_task_propagate_int(G_TASK(result), error);
238     return returnValue == -1 ? WEBKIT_COOKIE_POLICY_ACCEPT_NO_THIRD_PARTY : static_cast<WebKitCookieAcceptPolicy>(returnValue);
239 }
240
241 /**
242  * webkit_cookie_manager_add_cookie:
243  * @cookie_manager: a #WebKitCookieManager
244  * @cookie: the #SoupCookie to be added
245  * @cancellable: (allow-none): a #GCancellable or %NULL to ignore
246  * @callback: (scope async): a #GAsyncReadyCallback to call when the request is satisfied
247  * @user_data: (closure): the data to pass to callback function
248  *
249  * Asynchronously add a #SoupCookie to the underlying storage.
250  *
251  * When the operation is finished, @callback will be called. You can then call
252  * webkit_cookie_manager_add_cookie_finish() to get the result of the operation.
253  *
254  * Since: 2.20
255  */
256 void webkit_cookie_manager_add_cookie(WebKitCookieManager* manager, SoupCookie* cookie, GCancellable* cancellable, GAsyncReadyCallback callback, gpointer userData)
257 {
258     g_return_if_fail(WEBKIT_IS_COOKIE_MANAGER(manager));
259     g_return_if_fail(cookie);
260
261     GRefPtr<GTask> task = adoptGRef(g_task_new(manager, cancellable, callback, userData));
262
263     auto sessionID = webkitWebsiteDataManagerGetDataStore(manager->priv->dataManager).websiteDataStore().sessionID();
264     const auto& processPools = webkitWebsiteDataManagerGetProcessPools(manager->priv->dataManager);
265
266     // Cookies are read/written from/to the same SQLite database on disk regardless
267     // of the process we access them from, so just use the first process pool.
268     processPools[0]->supplement<WebCookieManagerProxy>()->setCookie(sessionID, WebCore::Cookie(cookie), [task = WTFMove(task)](CallbackBase::Error error) {
269         if (error != CallbackBase::Error::None) {
270             // This can only happen in cases where the web process is not available,
271             // consider the operation "cancelled" from the point of view of the client.
272             g_task_return_new_error(task.get(), G_IO_ERROR, G_IO_ERROR_CANCELLED, _("Operation was cancelled"));
273             return;
274         }
275
276         g_task_return_boolean(task.get(), TRUE);
277     });
278 }
279
280 /**
281  * webkit_cookie_manager_add_cookie_finish:
282  * @cookie_manager: a #WebKitCookieManager
283  * @result: a #GAsyncResult
284  * @error: return location for error or %NULL to ignore
285  *
286  * Finish an asynchronous operation started with webkit_cookie_manager_add_cookie().
287  *
288  * Returns: %TRUE if the cookie was added or %FALSE in case of error.
289  *
290  * Since: 2.20
291  */
292 gboolean webkit_cookie_manager_add_cookie_finish(WebKitCookieManager* manager, GAsyncResult* result, GError** error)
293 {
294     g_return_val_if_fail(WEBKIT_IS_COOKIE_MANAGER(manager), FALSE);
295     g_return_val_if_fail(g_task_is_valid(result, manager), FALSE);
296
297     return g_task_propagate_boolean(G_TASK(result), error);
298 }
299
300 /**
301  * webkit_cookie_manager_get_cookies:
302  * @cookie_manager: a #WebKitCookieManager
303  * @uri: the URI associated to the cookies to be retrieved
304  * @cancellable: (allow-none): a #GCancellable or %NULL to ignore
305  * @callback: (scope async): a #GAsyncReadyCallback to call when the request is satisfied
306  * @user_data: (closure): the data to pass to callback function
307  *
308  * Asynchronously get a list of #SoupCookie from @cookie_manager associated with @uri, which
309  * must be either an HTTP or an HTTPS URL.
310  *
311  * When the operation is finished, @callback will be called. You can then call
312  * webkit_cookie_manager_get_cookies_finish() to get the result of the operation.
313  *
314  * Since: 2.20
315  */
316 void webkit_cookie_manager_get_cookies(WebKitCookieManager* manager, const gchar* uri, GCancellable* cancellable, GAsyncReadyCallback callback, gpointer userData)
317 {
318     g_return_if_fail(WEBKIT_IS_COOKIE_MANAGER(manager));
319     g_return_if_fail(uri);
320
321     GRefPtr<GTask> task = adoptGRef(g_task_new(manager, cancellable, callback, userData));
322
323     auto sessionID = webkitWebsiteDataManagerGetDataStore(manager->priv->dataManager).websiteDataStore().sessionID();
324     const auto& processPools = webkitWebsiteDataManagerGetProcessPools(manager->priv->dataManager);
325
326     // Cookies are read/written from/to the same SQLite database on disk regardless
327     // of the process we access them from, so just use the first process pool.
328     processPools[0]->supplement<WebCookieManagerProxy>()->getCookies(sessionID, URL(URL(), String::fromUTF8(uri)), [task = WTFMove(task)](const Vector<WebCore::Cookie>& cookies, CallbackBase::Error error) {
329         if (error != CallbackBase::Error::None) {
330             // This can only happen in cases where the web process is not available,
331             // consider the operation "cancelled" from the point of view of the client.
332             g_task_return_new_error(task.get(), G_IO_ERROR, G_IO_ERROR_CANCELLED, _("Operation was cancelled"));
333             return;
334         }
335
336         GList* cookiesList = nullptr;
337         for (auto& cookie : cookies)
338             cookiesList = g_list_prepend(cookiesList, cookie.toSoupCookie());
339
340         g_task_return_pointer(task.get(), g_list_reverse(cookiesList), [](gpointer data) {
341             g_list_free_full(static_cast<GList*>(data), reinterpret_cast<GDestroyNotify>(soup_cookie_free));
342         });
343     });
344 }
345
346 /**
347  * webkit_cookie_manager_get_cookies_finish:
348  * @cookie_manager: a #WebKitCookieManager
349  * @result: a #GAsyncResult
350  * @error: return location for error or %NULL to ignore
351  *
352  * Finish an asynchronous operation started with webkit_cookie_manager_get_cookies().
353  * The return value is a #GSList of #SoupCookie instances which should be released
354  * with g_list_free_full() and soup_cookie_free().
355  *
356  * Returns: (element-type SoupCookie) (transfer full): A #GList of #SoupCookie instances.
357  *
358  * Since: 2.20
359  */
360 GList* webkit_cookie_manager_get_cookies_finish(WebKitCookieManager* manager, GAsyncResult* result, GError** error)
361 {
362     g_return_val_if_fail(WEBKIT_IS_COOKIE_MANAGER(manager), nullptr);
363     g_return_val_if_fail(g_task_is_valid(result, manager), nullptr);
364
365     return reinterpret_cast<GList*>(g_task_propagate_pointer(G_TASK(result), error));
366 }
367
368 /**
369  * webkit_cookie_manager_delete_cookie:
370  * @cookie_manager: a #WebKitCookieManager
371  * @cookie: the #SoupCookie to be deleted
372  * @cancellable: (allow-none): a #GCancellable or %NULL to ignore
373  * @callback: (scope async): a #GAsyncReadyCallback to call when the request is satisfied
374  * @user_data: (closure): the data to pass to callback function
375  *
376  * Asynchronously delete a #SoupCookie from the current session.
377  *
378  * When the operation is finished, @callback will be called. You can then call
379  * webkit_cookie_manager_delete_cookie_finish() to get the result of the operation.
380  *
381  * Since: 2.20
382  */
383 void webkit_cookie_manager_delete_cookie(WebKitCookieManager* manager, SoupCookie* cookie, GCancellable* cancellable, GAsyncReadyCallback callback, gpointer userData)
384 {
385     g_return_if_fail(WEBKIT_IS_COOKIE_MANAGER(manager));
386     g_return_if_fail(cookie);
387
388     GRefPtr<GTask> task = adoptGRef(g_task_new(manager, cancellable, callback, userData));
389
390     auto sessionID = webkitWebsiteDataManagerGetDataStore(manager->priv->dataManager).websiteDataStore().sessionID();
391     const auto& processPools = webkitWebsiteDataManagerGetProcessPools(manager->priv->dataManager);
392
393     // Cookies are read/written from/to the same SQLite database on disk regardless
394     // of the process we access them from, so just use the first process pool.
395     processPools[0]->supplement<WebCookieManagerProxy>()->deleteCookie(sessionID, WebCore::Cookie(cookie), [task = WTFMove(task)](CallbackBase::Error error) {
396         if (error != CallbackBase::Error::None) {
397             // This can only happen in cases where the web process is not available,
398             // consider the operation "cancelled" from the point of view of the client.
399             g_task_return_new_error(task.get(), G_IO_ERROR, G_IO_ERROR_CANCELLED, _("Operation was cancelled"));
400             return;
401         }
402
403         g_task_return_boolean(task.get(), TRUE);
404     });
405 }
406
407 /**
408  * webkit_cookie_manager_delete_cookie_finish:
409  * @cookie_manager: a #WebKitCookieManager
410  * @result: a #GAsyncResult
411  * @error: return location for error or %NULL to ignore
412  *
413  * Finish an asynchronous operation started with webkit_cookie_manager_delete_cookie().
414  *
415  * Returns: %TRUE if the cookie was deleted or %FALSE in case of error.
416  *
417  * Since: 2.20
418  */
419 gboolean webkit_cookie_manager_delete_cookie_finish(WebKitCookieManager* manager, GAsyncResult* result, GError** error)
420 {
421     g_return_val_if_fail(WEBKIT_IS_COOKIE_MANAGER(manager), FALSE);
422     g_return_val_if_fail(g_task_is_valid(result, manager), FALSE);
423
424     return g_task_propagate_boolean(G_TASK(result), error);
425 }
426
427 #if PLATFORM(GTK)
428 /**
429  * webkit_cookie_manager_get_domains_with_cookies:
430  * @cookie_manager: a #WebKitCookieManager
431  * @cancellable: (allow-none): a #GCancellable or %NULL to ignore
432  * @callback: (scope async): a #GAsyncReadyCallback to call when the request is satisfied
433  * @user_data: (closure): the data to pass to callback function
434  *
435  * Asynchronously get the list of domains for which @cookie_manager contains cookies.
436  *
437  * When the operation is finished, @callback will be called. You can then call
438  * webkit_cookie_manager_get_domains_with_cookies_finish() to get the result of the operation.
439  *
440  * Deprecated: 2.16: Use webkit_website_data_manager_fetch() instead.
441  */
442 void webkit_cookie_manager_get_domains_with_cookies(WebKitCookieManager* manager, GCancellable* cancellable, GAsyncReadyCallback callback, gpointer userData)
443 {
444     g_return_if_fail(WEBKIT_IS_COOKIE_MANAGER(manager));
445
446     GTask* task = g_task_new(manager, cancellable, callback, userData);
447     webkit_website_data_manager_fetch(manager->priv->dataManager, WEBKIT_WEBSITE_DATA_COOKIES, cancellable, [](GObject* object, GAsyncResult* result, gpointer userData) {
448         GRefPtr<GTask> task = adoptGRef(G_TASK(userData));
449         GError* error = nullptr;
450         GUniquePtr<GList> dataList(webkit_website_data_manager_fetch_finish(WEBKIT_WEBSITE_DATA_MANAGER(object), result, &error));
451         if (error) {
452             g_task_return_error(task.get(), error);
453             return;
454         }
455
456         GPtrArray* domains = g_ptr_array_sized_new(g_list_length(dataList.get()));
457         for (GList* item = dataList.get(); item; item = g_list_next(item)) {
458             auto* data = static_cast<WebKitWebsiteData*>(item->data);
459             g_ptr_array_add(domains, g_strdup(webkit_website_data_get_name(data)));
460             webkit_website_data_unref(data);
461         }
462         g_ptr_array_add(domains, nullptr);
463         g_task_return_pointer(task.get(), g_ptr_array_free(domains, FALSE), reinterpret_cast<GDestroyNotify>(g_strfreev));
464     }, task);
465 }
466
467 /**
468  * webkit_cookie_manager_get_domains_with_cookies_finish:
469  * @cookie_manager: a #WebKitCookieManager
470  * @result: a #GAsyncResult
471  * @error: return location for error or %NULL to ignore
472  *
473  * Finish an asynchronous operation started with webkit_cookie_manager_get_domains_with_cookies().
474  * The return value is a %NULL terminated list of strings which should
475  * be released with g_strfreev().
476  *
477  * Returns: (transfer full) (array zero-terminated=1): A %NULL terminated array of domain names
478  *    or %NULL in case of error.
479  *
480  * Deprecated: 2.16: Use webkit_website_data_manager_fetch_finish() instead.
481  */
482 gchar** webkit_cookie_manager_get_domains_with_cookies_finish(WebKitCookieManager* manager, GAsyncResult* result, GError** error)
483 {
484     g_return_val_if_fail(WEBKIT_IS_COOKIE_MANAGER(manager), nullptr);
485     g_return_val_if_fail(g_task_is_valid(result, manager), nullptr);
486
487     return reinterpret_cast<char**>(g_task_propagate_pointer(G_TASK(result), error));
488 }
489
490 /**
491  * webkit_cookie_manager_delete_cookies_for_domain:
492  * @cookie_manager: a #WebKitCookieManager
493  * @domain: a domain name
494  *
495  * Remove all cookies of @cookie_manager for the given @domain.
496  *
497  * Deprecated: 2.16: Use webkit_website_data_manager_remove() instead.
498  */
499 void webkit_cookie_manager_delete_cookies_for_domain(WebKitCookieManager* manager, const gchar* domain)
500 {
501     g_return_if_fail(WEBKIT_IS_COOKIE_MANAGER(manager));
502     g_return_if_fail(domain);
503
504     WebsiteDataRecord record;
505     record.addCookieHostName(String::fromUTF8(domain));
506     auto* data = webkitWebsiteDataCreate(WTFMove(record));
507     GList dataList = { data, nullptr, nullptr };
508     webkit_website_data_manager_remove(manager->priv->dataManager, WEBKIT_WEBSITE_DATA_COOKIES, &dataList, nullptr, nullptr, nullptr);
509     webkit_website_data_unref(data);
510 }
511
512 /**
513  * webkit_cookie_manager_delete_all_cookies:
514  * @cookie_manager: a #WebKitCookieManager
515  *
516  * Delete all cookies of @cookie_manager
517  *
518  * Deprecated: 2.16: Use webkit_website_data_manager_clear() instead.
519  */
520 void webkit_cookie_manager_delete_all_cookies(WebKitCookieManager* manager)
521 {
522     g_return_if_fail(WEBKIT_IS_COOKIE_MANAGER(manager));
523
524     webkit_website_data_manager_clear(manager->priv->dataManager, WEBKIT_WEBSITE_DATA_COOKIES, 0, nullptr, nullptr, nullptr);
525 }
526 #endif