1 files changed, 118 insertions, 69 deletions

diff --git a/Source/WebKit2/UIProcess/API/gtk/WebKitCookieManager.cpp b/Source/WebKit2/UIProcess/API/gtk/WebKitCookieManager.cpp
index 2c1ef4568..75a66ec61 100644
--- a/Source/WebKit2/UIProcess/API/gtk/WebKitCookieManager.cpp
+++ b/Source/WebKit2/UIProcess/API/gtk/WebKitCookieManager.cpp
@@ -20,12 +20,14 @@
 #include "config.h"
 #include "WebKitCookieManager.h"
 
-#include "APIString.h"
 #include "SoupCookiePersistentStorageType.h"
 #include "WebCookieManagerProxy.h"
 #include "WebKitCookieManagerPrivate.h"
 #include "WebKitEnumTypes.h"
-#include <wtf/gobject/GRefPtr.h>
+#include "WebKitWebsiteDataManagerPrivate.h"
+#include "WebKitWebsiteDataPrivate.h"
+#include "WebsiteDataRecord.h"
+#include <wtf/glib/GRefPtr.h>
 #include <wtf/text/CString.h>
 
 using namespace WebKit;
@@ -35,15 +37,11 @@ using namespace WebKit;
  * @Short_description: Defines how to handle cookies in a #WebKitWebContext
  * @Title: WebKitCookieManager
  *
- * The #WebKitCookieManager defines how to handle cookies in a
- * #WebKitWebContext. Get it from the context with
- * webkit_web_context_get_cookie_manager(), and use it to set where to
- * store cookies, with webkit_cookie_manager_set_persistent_storage(),
- * to get the list of domains with cookies, with
- * webkit_cookie_manager_get_domains_with_cookies(), or to set the
- * acceptance policy, with webkit_cookie_manager_get_accept_policy()
- * (among other actions).
- *
+ * The WebKitCookieManager defines how to set up and handle cookies.
+ * You can get it from a #WebKitWebsiteDataManager with
+ * webkit_website_data_manager_get_cookie_manager(), and use it to set where to
+ * store cookies with webkit_cookie_manager_set_persistent_storage(),
+ * or to set the acceptance policy, with webkit_cookie_manager_get_accept_policy().
  */
 
 enum {
@@ -55,22 +53,60 @@ enum {
 struct _WebKitCookieManagerPrivate {
     ~_WebKitCookieManagerPrivate()
     {
-        webCookieManager->stopObservingCookieChanges();
+        auto sessionID = webkitWebsiteDataManagerGetDataStore(dataManager).websiteDataStore().sessionID();
+        for (auto* processPool : webkitWebsiteDataManagerGetProcessPools(dataManager))
+            processPool->supplement<WebCookieManagerProxy>()->setCookieObserverCallback(sessionID, nullptr);
     }
 
-    RefPtr<WebCookieManagerProxy> webCookieManager;
+    WebKitWebsiteDataManager* dataManager;
 };
 
 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);
+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;
+    }
+}
 
-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 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)
 {
@@ -91,26 +127,16 @@ static void webkit_cookie_manager_class_init(WebKitCookieManagerClass* findClass
                      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* webkitCookieManagerCreate(WebKitWebsiteDataManager* dataManager)
 {
-    WebKitCookieManager* manager = WEBKIT_COOKIE_MANAGER(g_object_new(WEBKIT_TYPE_COOKIE_MANAGER, NULL));
-    manager->priv->webCookieManager = webCookieManager;
-
-    WKCookieManagerClientV0 wkCookieManagerClient = {
-        {
-            0, // version
-            manager, // clientInfo
-        },
-        cookiesDidChange
-    };
-    WKCookieManagerSetClient(toAPI(webCookieManager), &wkCookieManagerClient.base);
-    manager->priv->webCookieManager->startObservingCookieChanges();
-
+    WebKitCookieManager* manager = WEBKIT_COOKIE_MANAGER(g_object_new(WEBKIT_TYPE_COOKIE_MANAGER, nullptr));
+    manager->priv->dataManager = dataManager;
+    auto sessionID = webkitWebsiteDataManagerGetDataStore(manager->priv->dataManager).websiteDataStore().sessionID();
+    for (auto* processPool : webkitWebsiteDataManagerGetProcessPools(manager->priv->dataManager)) {
+        processPool->supplement<WebCookieManagerProxy>()->setCookieObserverCallback(sessionID, [manager] {
+            g_signal_emit(manager, signals[CHANGED], 0);
+        });
+    }
     return manager;
 }
 
@@ -125,17 +151,19 @@ WebKitCookieManager* webkitCookieManagerCreate(WebCookieManagerProxy* webCookieM
  * Cookies are initially read from @filename to create an initial set of cookies.
  * Then, non-session cookies will be written to @filename when the WebKitCookieManager::changed
  * signal is emitted.
- * By default, @cookie_manager doesn't store the cookies persistenly, so you need to call this
+ * By default, @cookie_manager doesn't store the cookies persistently, so you need to call this
  * method to keep cookies saved across sessions.
+ *
+ * This method should never be called on a #WebKitCookieManager associated to an ephemeral #WebKitWebsiteDataManager.
  */
 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));
 
-    manager->priv->webCookieManager->stopObservingCookieChanges();
-    manager->priv->webCookieManager->setCookiePersistentStorage(String::fromUTF8(filename), storage);
-    manager->priv->webCookieManager->startObservingCookieChanges();
+    for (auto* processPool : webkitWebsiteDataManagerGetProcessPools(manager->priv->dataManager))
+        processPool->supplement<WebCookieManagerProxy>()->setCookiePersistentStorage(String::fromUTF8(filename), toSoupCookiePersistentStorageType(storage));
 }
 
 /**
@@ -149,13 +177,14 @@ void webkit_cookie_manager_set_accept_policy(WebKitCookieManager* manager, WebKi
 {
     g_return_if_fail(WEBKIT_IS_COOKIE_MANAGER(manager));
 
-    manager->priv->webCookieManager->setHTTPCookieAcceptPolicy(policy);
+    for (auto* processPool : webkitWebsiteDataManagerGetProcessPools(manager->priv->dataManager))
+        processPool->supplement<WebCookieManagerProxy>()->setHTTPCookieAcceptPolicy(toHTTPCookieAcceptPolicy(policy));
 }
 
 static void webkitCookieManagerGetAcceptPolicyCallback(WKHTTPCookieAcceptPolicy policy, WKErrorRef, void* context)
 {
     GRefPtr<GTask> task = adoptGRef(G_TASK(context));
-    g_task_return_int(task.get(), policy);
+    g_task_return_int(task.get(), toWebKitCookieAcceptPolicy(toHTTPCookieAcceptPolicy(policy)));
 }
 
 /**
@@ -174,8 +203,17 @@ void webkit_cookie_manager_get_accept_policy(WebKitCookieManager* manager, GCanc
 {
     g_return_if_fail(WEBKIT_IS_COOKIE_MANAGER(manager));
 
-    GTask* task = g_task_new(manager, cancellable, callback, userData);
-    manager->priv->webCookieManager->getHTTPCookieAcceptPolicy(HTTPCookieAcceptPolicyCallback::create(task, webkitCookieManagerGetAcceptPolicyCallback));
+    GRefPtr<GTask> task = adoptGRef(g_task_new(manager, cancellable, callback, userData));
+
+    // The policy is the same in all process pools having the same session ID, so just ask any.
+    const auto& processPools = webkitWebsiteDataManagerGetProcessPools(manager->priv->dataManager);
+    if (processPools.isEmpty()) {
+        g_task_return_int(task.get(), WEBKIT_COOKIE_POLICY_ACCEPT_NO_THIRD_PARTY);
+        return;
+    }
+
+    processPools[0]->supplement<WebCookieManagerProxy>()->getHTTPCookieAcceptPolicy(
+        toGenericCallbackFunction<WKHTTPCookieAcceptPolicy, HTTPCookieAcceptPolicy>(task.leakRef(), webkitCookieManagerGetAcceptPolicyCallback));
 }
 
 /**
@@ -197,25 +235,6 @@ WebKitCookieAcceptPolicy webkit_cookie_manager_get_accept_policy_finish(WebKitCo
     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));
-}
-
 /**
  * webkit_cookie_manager_get_domains_with_cookies:
  * @cookie_manager: a #WebKitCookieManager
@@ -227,13 +246,32 @@ static void webkitCookieManagerGetDomainsWithCookiesCallback(WKArrayRef wkDomain
  *
  * When the operation is finished, @callback will be called. You can then call
  * webkit_cookie_manager_get_domains_with_cookies_finish() to get the result of the operation.
+ *
+ * Deprecated: 2.16: Use webkit_website_data_manager_fetch() instead.
  */
 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(ArrayCallback::create(task, webkitCookieManagerGetDomainsWithCookiesCallback));
+    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);
 }
 
 /**
@@ -248,11 +286,13 @@ void webkit_cookie_manager_get_domains_with_cookies(WebKitCookieManager* manager
  *
  * Returns: (transfer full) (array zero-terminated=1): A %NULL terminated array of domain names
  *    or %NULL in case of error.
+ *
+ * Deprecated: 2.16: Use webkit_website_data_manager_fetch_finish() instead.
  */
 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);
+    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));
 }
@@ -263,13 +303,20 @@ gchar** webkit_cookie_manager_get_domains_with_cookies_finish(WebKitCookieManage
  * @domain: a domain name
  *
  * Remove all cookies of @cookie_manager for the given @domain.
+ *
+ * Deprecated: 2.16: Use webkit_website_data_manager_remove() instead.
  */
 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));
+    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);
 }
 
 /**
@@ -277,10 +324,12 @@ void webkit_cookie_manager_delete_cookies_for_domain(WebKitCookieManager* manage
  * @cookie_manager: a #WebKitCookieManager
  *
  * Delete all cookies of @cookie_manager
+ *
+ * Deprecated: 2.16: Use webkit_website_data_manager_clear() instead.
  */
 void webkit_cookie_manager_delete_all_cookies(WebKitCookieManager* manager)
 {
     g_return_if_fail(WEBKIT_IS_COOKIE_MANAGER(manager));
 
-    manager->priv->webCookieManager->deleteAllCookies();
+    webkit_website_data_manager_clear(manager->priv->dataManager, WEBKIT_WEBSITE_DATA_COOKIES, 0, nullptr, nullptr, nullptr);
 }