webkitgtk-2.16.5HEADwebkitgtk-2.16.5master

5 files changed, 90 insertions, 67 deletions

diff --git a/Source/WebKit2/WebProcess/Cookies/WebCookieManager.cpp b/Source/WebKit2/WebProcess/Cookies/WebCookieManager.cpp
index 3998d21d3..4bf6773dc 100644
--- a/Source/WebKit2/WebProcess/Cookies/WebCookieManager.cpp
+++ b/Source/WebKit2/WebProcess/Cookies/WebCookieManager.cpp
@@ -33,6 +33,7 @@
 #include <WebCore/CookieStorage.h>
 #include <WebCore/NetworkStorageSession.h>
 #include <WebCore/PlatformCookieJar.h>
+#include <WebCore/URL.h>
 #include <wtf/MainThread.h>
 #include <wtf/text/StringHash.h>
 #include <wtf/text/WTFString.h>
@@ -41,8 +42,6 @@ using namespace WebCore;
 
 namespace WebKit {
 
-static WebCookieManager* sharedCookieManager;
-
 const char* WebCookieManager::supplementName()
 {
     return "WebCookieManager";
@@ -52,15 +51,13 @@ WebCookieManager::WebCookieManager(ChildProcess* process)
     : m_process(process)
 {
     m_process->addMessageReceiver(Messages::WebCookieManager::messageReceiverName(), *this);
-
-    ASSERT(!sharedCookieManager);
-    sharedCookieManager = this;
 }
 
-void WebCookieManager::getHostnamesWithCookies(uint64_t callbackID)
+void WebCookieManager::getHostnamesWithCookies(SessionID sessionID, uint64_t callbackID)
 {
     HashSet<String> hostnames;
-    WebCore::getHostnamesWithCookies(NetworkStorageSession::defaultStorageSession(), hostnames);
+    if (auto* storageSession = NetworkStorageSession::storageSession(sessionID))
+        WebCore::getHostnamesWithCookies(*storageSession, hostnames);
 
     Vector<String> hostnameList;
     copyToVector(hostnames, hostnameList);
@@ -68,35 +65,49 @@ void WebCookieManager::getHostnamesWithCookies(uint64_t callbackID)
     m_process->send(Messages::WebCookieManagerProxy::DidGetHostnamesWithCookies(hostnameList, callbackID), 0);
 }
 
-void WebCookieManager::deleteCookiesForHostname(const String& hostname)
+void WebCookieManager::deleteCookiesForHostname(SessionID sessionID, const String& hostname)
+{
+    if (auto* storageSession = NetworkStorageSession::storageSession(sessionID))
+        WebCore::deleteCookiesForHostnames(*storageSession, { hostname });
+}
+
+void WebCookieManager::deleteAllCookies(SessionID sessionID)
 {
-    WebCore::deleteCookiesForHostname(NetworkStorageSession::defaultStorageSession(), hostname);
+    if (auto* storageSession = NetworkStorageSession::storageSession(sessionID))
+        WebCore::deleteAllCookies(*storageSession);
 }
 
-void WebCookieManager::deleteAllCookies()
+void WebCookieManager::deleteAllCookiesModifiedSince(SessionID sessionID, std::chrono::system_clock::time_point time)
 {
-    WebCore::deleteAllCookies(NetworkStorageSession::defaultStorageSession());
+    if (auto* storageSession = NetworkStorageSession::storageSession(sessionID))
+        WebCore::deleteAllCookiesModifiedSince(*storageSession, time);
 }
 
-void WebCookieManager::startObservingCookieChanges()
+void WebCookieManager::addCookie(SessionID sessionID, const Cookie& cookie, const String& hostname)
 {
-    WebCore::startObservingCookieChanges(cookiesDidChange);
+    if (auto* storageSession = NetworkStorageSession::storageSession(sessionID))
+        WebCore::addCookie(*storageSession, URL(URL(), hostname), cookie);
 }
 
-void WebCookieManager::stopObservingCookieChanges()
+void WebCookieManager::notifyCookiesDidChange(SessionID sessionID)
 {
-    WebCore::stopObservingCookieChanges();
+    ASSERT(RunLoop::isMain());
+    m_process->send(Messages::WebCookieManagerProxy::CookiesDidChange(sessionID), 0);
 }
 
-void WebCookieManager::cookiesDidChange()
+void WebCookieManager::startObservingCookieChanges(SessionID sessionID)
 {
-    sharedCookieManager->dispatchCookiesDidChange();
+    if (auto* storageSession = NetworkStorageSession::storageSession(sessionID)) {
+        WebCore::startObservingCookieChanges(*storageSession, [this, sessionID] {
+            notifyCookiesDidChange(sessionID);
+        });
+    }
 }
 
-void WebCookieManager::dispatchCookiesDidChange()
+void WebCookieManager::stopObservingCookieChanges(SessionID sessionID)
 {
-    ASSERT(isMainThread());
-    m_process->send(Messages::WebCookieManagerProxy::CookiesDidChange(), 0);
+    if (auto* storageSession = NetworkStorageSession::storageSession(sessionID))
+        WebCore::stopObservingCookieChanges(*storageSession);
 }
 
 void WebCookieManager::setHTTPCookieAcceptPolicy(HTTPCookieAcceptPolicy policy)
diff --git a/Source/WebKit2/WebProcess/Cookies/WebCookieManager.h b/Source/WebKit2/WebProcess/Cookies/WebCookieManager.h
index ec092651c..7ed658f4f 100644
--- a/Source/WebKit2/WebProcess/Cookies/WebCookieManager.h
+++ b/Source/WebKit2/WebProcess/Cookies/WebCookieManager.h
@@ -1,5 +1,5 @@
 /*
- * Copyright (C) 2011, 2013 Apple Inc. All rights reserved.
+ * Copyright (C) 2011, 2013, 2016 Apple Inc. All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions
@@ -30,6 +30,7 @@
 #include "MessageReceiver.h"
 #include "NetworkProcessSupplement.h"
 #include "WebProcessSupplement.h"
+#include <WebCore/SessionID.h>
 #include <stdint.h>
 #include <wtf/Forward.h>
 #include <wtf/Noncopyable.h>
@@ -38,6 +39,10 @@
 #include "SoupCookiePersistentStorageType.h"
 #endif
 
+namespace WebCore {
+struct Cookie;
+}
+
 namespace WebKit {
 
 class ChildProcess;
@@ -54,24 +59,24 @@ public:
     void setCookiePersistentStorage(const String& storagePath, uint32_t storageType);
 #endif
 
+    void notifyCookiesDidChange(WebCore::SessionID);
+
 private:
     // IPC::MessageReceiver
-    virtual void didReceiveMessage(IPC::Connection*, IPC::MessageDecoder&) override;
+    void didReceiveMessage(IPC::Connection&, IPC::Decoder&) override;
 
-    void getHostnamesWithCookies(uint64_t callbackID);
-    void deleteCookiesForHostname(const String&);
-    void deleteAllCookies();
+    void getHostnamesWithCookies(WebCore::SessionID, uint64_t callbackID);
+    void deleteCookiesForHostname(WebCore::SessionID, const String&);
+    void deleteAllCookies(WebCore::SessionID);
+    void deleteAllCookiesModifiedSince(WebCore::SessionID, std::chrono::system_clock::time_point);
+    void addCookie(WebCore::SessionID, const WebCore::Cookie&, const String& hostname);
 
     void platformSetHTTPCookieAcceptPolicy(HTTPCookieAcceptPolicy);
     void getHTTPCookieAcceptPolicy(uint64_t callbackID);
     HTTPCookieAcceptPolicy platformGetHTTPCookieAcceptPolicy();
 
-    void startObservingCookieChanges();
-    void stopObservingCookieChanges();
-
-    static void cookiesDidChange();
-    void dispatchCookiesDidChange();
-
+    void startObservingCookieChanges(WebCore::SessionID);
+    void stopObservingCookieChanges(WebCore::SessionID);
 
     ChildProcess* m_process;
 };
diff --git a/Source/WebKit2/WebProcess/Cookies/WebCookieManager.messages.in b/Source/WebKit2/WebProcess/Cookies/WebCookieManager.messages.in
index 65b3e5c9e..5d5153664 100644
--- a/Source/WebKit2/WebProcess/Cookies/WebCookieManager.messages.in
+++ b/Source/WebKit2/WebProcess/Cookies/WebCookieManager.messages.in
@@ -1,5 +1,5 @@
 /*
- * Copyright (C) 2011 Apple Inc. All rights reserved.
+ * Copyright (C) 2011, 2016 Apple Inc. All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions
@@ -24,15 +24,17 @@
  */
  
  messages -> WebCookieManager {
-    void GetHostnamesWithCookies(uint64_t callbackID)
-    void DeleteCookiesForHostname(String hostname)
-    void DeleteAllCookies()
+    void GetHostnamesWithCookies(WebCore::SessionID sessionID, uint64_t callbackID)
+    void DeleteCookiesForHostname(WebCore::SessionID sessionID, String hostname)
+    void DeleteAllCookies(WebCore::SessionID sessionID)
+    void DeleteAllCookiesModifiedSince(WebCore::SessionID sessionID, std::chrono::system_clock::time_point time)
+    void AddCookie(WebCore::SessionID sessionID, struct WebCore::Cookie cookie, String hostname)
 
     void SetHTTPCookieAcceptPolicy(uint32_t policy)
     void GetHTTPCookieAcceptPolicy(uint64_t callbackID)
     
-    void StartObservingCookieChanges()
-    void StopObservingCookieChanges()
+    void StartObservingCookieChanges(WebCore::SessionID sessionID)
+    void StopObservingCookieChanges(WebCore::SessionID sessionID)
 
 #if USE(SOUP)
     SetCookiePersistentStorage(String storagePath, uint32_t storageType)
diff --git a/Source/WebKit2/WebProcess/Cookies/soup/WebCookieManagerSoup.cpp b/Source/WebKit2/WebProcess/Cookies/soup/WebCookieManagerSoup.cpp
index 3e7b46a09..7d00d29eb 100644
--- a/Source/WebKit2/WebProcess/Cookies/soup/WebCookieManagerSoup.cpp
+++ b/Source/WebKit2/WebProcess/Cookies/soup/WebCookieManagerSoup.cpp
@@ -27,12 +27,11 @@
 #include "WebCookieManager.h"
 
 #include "ChildProcess.h"
-#include "WebFrameNetworkingContext.h"
 #include "WebKitSoupCookieJarSqlite.h"
-#include <WebCore/CookieJarSoup.h>
+#include <WebCore/NetworkStorageSession.h>
 #include <WebCore/SoupNetworkSession.h>
 #include <libsoup/soup.h>
-#include <wtf/gobject/GRefPtr.h>
+#include <wtf/glib/GRefPtr.h>
 #include <wtf/text/CString.h>
 
 using namespace WebCore;
@@ -41,31 +40,37 @@ namespace WebKit {
 
 void WebCookieManager::platformSetHTTPCookieAcceptPolicy(HTTPCookieAcceptPolicy policy)
 {
-    WebFrameNetworkingContext::setCookieAcceptPolicyForAllContexts(policy);
+    SoupCookieJarAcceptPolicy soupPolicy = SOUP_COOKIE_JAR_ACCEPT_NO_THIRD_PARTY;
+    switch (policy) {
+    case HTTPCookieAcceptPolicyAlways:
+        soupPolicy = SOUP_COOKIE_JAR_ACCEPT_ALWAYS;
+        break;
+    case HTTPCookieAcceptPolicyNever:
+        soupPolicy = SOUP_COOKIE_JAR_ACCEPT_NEVER;
+        break;
+    case HTTPCookieAcceptPolicyOnlyFromMainDocumentDomain:
+        soupPolicy = SOUP_COOKIE_JAR_ACCEPT_NO_THIRD_PARTY;
+        break;
+    }
+
+    NetworkStorageSession::forEach([soupPolicy] (const NetworkStorageSession& session) {
+        soup_cookie_jar_set_accept_policy(session.cookieStorage(), soupPolicy);
+    });
 }
 
 HTTPCookieAcceptPolicy WebCookieManager::platformGetHTTPCookieAcceptPolicy()
 {
-    SoupCookieJar* cookieJar = WebCore::soupCookieJar();
-    SoupCookieJarAcceptPolicy soupPolicy;
-
-    HTTPCookieAcceptPolicy policy;
-
-    soupPolicy = soup_cookie_jar_get_accept_policy(cookieJar);
-    switch (soupPolicy) {
+    switch (soup_cookie_jar_get_accept_policy(NetworkStorageSession::defaultStorageSession().cookieStorage())) {
     case SOUP_COOKIE_JAR_ACCEPT_ALWAYS:
-        policy = HTTPCookieAcceptPolicyAlways;
-        break;
+        return HTTPCookieAcceptPolicyAlways;
     case SOUP_COOKIE_JAR_ACCEPT_NEVER:
-        policy = HTTPCookieAcceptPolicyNever;
-        break;
+        return HTTPCookieAcceptPolicyNever;
     case SOUP_COOKIE_JAR_ACCEPT_NO_THIRD_PARTY:
-        policy = HTTPCookieAcceptPolicyOnlyFromMainDocumentDomain;
-        break;
-    default:
-        policy = HTTPCookieAcceptPolicyAlways;
+        return HTTPCookieAcceptPolicyOnlyFromMainDocumentDomain;
     }
-    return policy;
+
+    ASSERT_NOT_REACHED();
+    return HTTPCookieAcceptPolicyOnlyFromMainDocumentDomain;
 }
 
 void WebCookieManager::setCookiePersistentStorage(const String& storagePath, uint32_t storageType)
@@ -82,9 +87,9 @@ void WebCookieManager::setCookiePersistentStorage(const String& storagePath, uin
         ASSERT_NOT_REACHED();
     }
 
-    soup_cookie_jar_set_accept_policy(jar.get(), soup_cookie_jar_get_accept_policy(WebCore::soupCookieJar()));
-    SoupNetworkSession::defaultSession().setCookieJar(jar.get());
-    WebCore::setSoupCookieJar(jar.get());
+    auto& storageSession = NetworkStorageSession::defaultStorageSession();
+    soup_cookie_jar_set_accept_policy(jar.get(), soup_cookie_jar_get_accept_policy(storageSession.cookieStorage()));
+    storageSession.setCookieStorage(jar.get());
 }
 
 } // namespace WebKit
diff --git a/Source/WebKit2/WebProcess/Cookies/soup/WebKitSoupCookieJarSqlite.cpp b/Source/WebKit2/WebProcess/Cookies/soup/WebKitSoupCookieJarSqlite.cpp
index b60584c22..369fabfaf 100644
--- a/Source/WebKit2/WebProcess/Cookies/soup/WebKitSoupCookieJarSqlite.cpp
+++ b/Source/WebKit2/WebProcess/Cookies/soup/WebKitSoupCookieJarSqlite.cpp
@@ -93,7 +93,7 @@ static void webkitSoupCookieJarSqliteLoad(WebKitSoupCookieJarSqlite* sqliteJar)
     WebKitSoupCookieJarSqlitePrivate* priv = sqliteJar->priv;
     priv->isLoading = true;
     SQLiteStatement query(priv->database, "SELECT id, name, value, host, path, expiry, lastAccessed, isSecure, isHttpOnly FROM moz_cookies;");
-    if (query.prepare() != SQLResultOk) {
+    if (query.prepare() != SQLITE_OK) {
         g_warning("Failed to prepare all cookies query");
         priv->isLoading = false;
         return;
@@ -102,7 +102,7 @@ static void webkitSoupCookieJarSqliteLoad(WebKitSoupCookieJarSqlite* sqliteJar)
     SoupCookieJar* jar = SOUP_COOKIE_JAR(sqliteJar);
     time_t now = floorf(currentTime());
     int result;
-    while ((result = query.step()) == SQLResultRow) {
+    while ((result = query.step()) == SQLITE_ROW) {
         int expireTime = query.getColumnInt(ColumnExpiry);
         if (now >= expireTime)
             continue;
@@ -118,7 +118,7 @@ static void webkitSoupCookieJarSqliteLoad(WebKitSoupCookieJarSqlite* sqliteJar)
         soup_cookie_jar_add_cookie(jar, cookie);
     }
 
-    if (result != SQLResultDone)
+    if (result != SQLITE_DONE)
         g_warning("Error reading cookies from database");
     priv->isLoading = false;
 }
@@ -127,7 +127,7 @@ static bool webkitSoupCookieJarSqliteInsertCookie(WebKitSoupCookieJarSqlite* sql
 {
     WebKitSoupCookieJarSqlitePrivate* priv = sqliteJar->priv;
     SQLiteStatement query(priv->database, "INSERT INTO moz_cookies VALUES(NULL, ?, ?, ?, ?, ?, NULL, ?, ?);");
-    if (query.prepare() != SQLResultOk) {
+    if (query.prepare() != SQLITE_OK) {
         g_warning("Failed to prepare insert cookies query");
         return false;
     }
@@ -139,7 +139,7 @@ static bool webkitSoupCookieJarSqliteInsertCookie(WebKitSoupCookieJarSqlite* sql
     query.bindInt(5, static_cast<int64_t>(soup_date_to_time_t(cookie->expires)));
     query.bindInt(6, cookie->secure);
     query.bindInt(7, cookie->http_only);
-    if (query.step() != SQLResultDone) {
+    if (query.step() != SQLITE_DONE) {
         g_warning("Error adding cookie (name=%s, domain=%s) to database", cookie->name, cookie->name);
         return false;
     }
@@ -151,14 +151,14 @@ static bool webkitSoupCookieJarSqliteDeleteCookie(WebKitSoupCookieJarSqlite* sql
 {
     WebKitSoupCookieJarSqlitePrivate* priv = sqliteJar->priv;
     SQLiteStatement query(priv->database, "DELETE FROM moz_cookies WHERE name = (?) AND host = (?);");
-    if (query.prepare() != SQLResultOk) {
+    if (query.prepare() != SQLITE_OK) {
         g_warning("Failed to prepare delete cookies query");
         return false;
     }
 
     query.bindText(1, String::fromUTF8(cookie->name));
     query.bindText(2, String::fromUTF8(cookie->domain));
-    if (query.step() != SQLResultDone) {
+    if (query.step() != SQLITE_DONE) {
         g_warning("Error deleting cookie (name=%s, domain=%s) from database", cookie->name, cookie->name);
         return false;
     }