WebKitWebsiteDataManager.cpp [plain text]
#include "config.h"
#include "WebKitWebsiteDataManager.h"
#include "APIWebsiteDataStore.h"
#include "WebKitCookieManagerPrivate.h"
#include "WebKitPrivate.h"
#include "WebKitWebsiteDataManagerPrivate.h"
#include "WebKitWebsiteDataPrivate.h"
#include "WebsiteDataFetchOption.h"
#include <WebCore/FileSystem.h>
#include <glib/gi18n-lib.h>
#include <wtf/glib/GUniquePtr.h>
#include <wtf/glib/WTFGType.h>
using namespace WebKit;
using namespace WebKit;
enum {
PROP_0,
PROP_BASE_DATA_DIRECTORY,
PROP_BASE_CACHE_DIRECTORY,
PROP_LOCAL_STORAGE_DIRECTORY,
PROP_DISK_CACHE_DIRECTORY,
PROP_APPLICATION_CACHE_DIRECTORY,
PROP_INDEXEDDB_DIRECTORY,
PROP_WEBSQL_DIRECTORY,
PROP_IS_EPHEMERAL
};
struct _WebKitWebsiteDataManagerPrivate {
~_WebKitWebsiteDataManagerPrivate()
{
ASSERT(processPools.isEmpty());
}
RefPtr<API::WebsiteDataStore> websiteDataStore;
GUniquePtr<char> baseDataDirectory;
GUniquePtr<char> baseCacheDirectory;
GUniquePtr<char> localStorageDirectory;
GUniquePtr<char> diskCacheDirectory;
GUniquePtr<char> applicationCacheDirectory;
GUniquePtr<char> indexedDBDirectory;
GUniquePtr<char> webSQLDirectory;
GRefPtr<WebKitCookieManager> cookieManager;
Vector<WebProcessPool*> processPools;
};
WEBKIT_DEFINE_TYPE(WebKitWebsiteDataManager, webkit_website_data_manager, G_TYPE_OBJECT)
static void webkitWebsiteDataManagerGetProperty(GObject* object, guint propID, GValue* value, GParamSpec* paramSpec)
{
WebKitWebsiteDataManager* manager = WEBKIT_WEBSITE_DATA_MANAGER(object);
switch (propID) {
case PROP_BASE_DATA_DIRECTORY:
g_value_set_string(value, webkit_website_data_manager_get_base_data_directory(manager));
break;
case PROP_BASE_CACHE_DIRECTORY:
g_value_set_string(value, webkit_website_data_manager_get_base_cache_directory(manager));
break;
case PROP_LOCAL_STORAGE_DIRECTORY:
g_value_set_string(value, webkit_website_data_manager_get_local_storage_directory(manager));
break;
case PROP_DISK_CACHE_DIRECTORY:
g_value_set_string(value, webkit_website_data_manager_get_disk_cache_directory(manager));
break;
case PROP_APPLICATION_CACHE_DIRECTORY:
g_value_set_string(value, webkit_website_data_manager_get_offline_application_cache_directory(manager));
break;
case PROP_INDEXEDDB_DIRECTORY:
g_value_set_string(value, webkit_website_data_manager_get_indexeddb_directory(manager));
break;
case PROP_WEBSQL_DIRECTORY:
g_value_set_string(value, webkit_website_data_manager_get_websql_directory(manager));
break;
case PROP_IS_EPHEMERAL:
g_value_set_boolean(value, webkit_website_data_manager_is_ephemeral(manager));
break;
default:
G_OBJECT_WARN_INVALID_PROPERTY_ID(object, propID, paramSpec);
}
}
static void webkitWebsiteDataManagerSetProperty(GObject* object, guint propID, const GValue* value, GParamSpec* paramSpec)
{
WebKitWebsiteDataManager* manager = WEBKIT_WEBSITE_DATA_MANAGER(object);
switch (propID) {
case PROP_BASE_DATA_DIRECTORY:
manager->priv->baseDataDirectory.reset(g_value_dup_string(value));
break;
case PROP_BASE_CACHE_DIRECTORY:
manager->priv->baseCacheDirectory.reset(g_value_dup_string(value));
break;
case PROP_LOCAL_STORAGE_DIRECTORY:
manager->priv->localStorageDirectory.reset(g_value_dup_string(value));
break;
case PROP_DISK_CACHE_DIRECTORY:
manager->priv->diskCacheDirectory.reset(g_value_dup_string(value));
break;
case PROP_APPLICATION_CACHE_DIRECTORY:
manager->priv->applicationCacheDirectory.reset(g_value_dup_string(value));
break;
case PROP_INDEXEDDB_DIRECTORY:
manager->priv->indexedDBDirectory.reset(g_value_dup_string(value));
break;
case PROP_WEBSQL_DIRECTORY:
manager->priv->webSQLDirectory.reset(g_value_dup_string(value));
break;
case PROP_IS_EPHEMERAL:
if (g_value_get_boolean(value))
manager->priv->websiteDataStore = API::WebsiteDataStore::createNonPersistentDataStore();
break;
default:
G_OBJECT_WARN_INVALID_PROPERTY_ID(object, propID, paramSpec);
}
}
static void webkitWebsiteDataManagerConstructed(GObject* object)
{
G_OBJECT_CLASS(webkit_website_data_manager_parent_class)->constructed(object);
WebKitWebsiteDataManagerPrivate* priv = WEBKIT_WEBSITE_DATA_MANAGER(object)->priv;
if (priv->baseDataDirectory) {
if (!priv->localStorageDirectory)
priv->localStorageDirectory.reset(g_build_filename(priv->baseDataDirectory.get(), "localstorage", nullptr));
if (!priv->indexedDBDirectory)
priv->indexedDBDirectory.reset(g_build_filename(priv->baseDataDirectory.get(), "databases", "indexeddb", nullptr));
if (!priv->webSQLDirectory)
priv->webSQLDirectory.reset(g_build_filename(priv->baseDataDirectory.get(), "databases", nullptr));
}
if (priv->baseCacheDirectory) {
if (!priv->diskCacheDirectory)
priv->diskCacheDirectory.reset(g_strdup(priv->baseCacheDirectory.get()));
if (!priv->applicationCacheDirectory)
priv->applicationCacheDirectory.reset(g_build_filename(priv->baseCacheDirectory.get(), "applications", nullptr));
}
}
static void webkit_website_data_manager_class_init(WebKitWebsiteDataManagerClass* findClass)
{
GObjectClass* gObjectClass = G_OBJECT_CLASS(findClass);
gObjectClass->get_property = webkitWebsiteDataManagerGetProperty;
gObjectClass->set_property = webkitWebsiteDataManagerSetProperty;
gObjectClass->constructed = webkitWebsiteDataManagerConstructed;
g_object_class_install_property(
gObjectClass,
PROP_BASE_DATA_DIRECTORY,
g_param_spec_string(
"base-data-directory",
_("Base Data Directory"),
_("The base directory for Website data"),
nullptr,
static_cast<GParamFlags>(WEBKIT_PARAM_READWRITE | G_PARAM_CONSTRUCT_ONLY)));
g_object_class_install_property(
gObjectClass,
PROP_BASE_CACHE_DIRECTORY,
g_param_spec_string(
"base-cache-directory",
_("Base Cache Directory"),
_("The base directory for Website cache"),
nullptr,
static_cast<GParamFlags>(WEBKIT_PARAM_READWRITE | G_PARAM_CONSTRUCT_ONLY)));
g_object_class_install_property(
gObjectClass,
PROP_LOCAL_STORAGE_DIRECTORY,
g_param_spec_string(
"local-storage-directory",
_("Local Storage Directory"),
_("The directory where local storage data will be stored"),
nullptr,
static_cast<GParamFlags>(WEBKIT_PARAM_READWRITE | G_PARAM_CONSTRUCT_ONLY)));
g_object_class_install_property(
gObjectClass,
PROP_DISK_CACHE_DIRECTORY,
g_param_spec_string(
"disk-cache-directory",
_("Disk Cache Directory"),
_("The directory where HTTP disk cache will be stored"),
nullptr,
static_cast<GParamFlags>(WEBKIT_PARAM_READWRITE | G_PARAM_CONSTRUCT_ONLY)));
g_object_class_install_property(
gObjectClass,
PROP_APPLICATION_CACHE_DIRECTORY,
g_param_spec_string(
"offline-application-cache-directory",
_("Offline Web Application Cache Directory"),
_("The directory where offline web application cache will be stored"),
nullptr,
static_cast<GParamFlags>(WEBKIT_PARAM_READWRITE | G_PARAM_CONSTRUCT_ONLY)));
g_object_class_install_property(
gObjectClass,
PROP_INDEXEDDB_DIRECTORY,
g_param_spec_string(
"indexeddb-directory",
_("IndexedDB Directory"),
_("The directory where IndexedDB databases will be stored"),
nullptr,
static_cast<GParamFlags>(WEBKIT_PARAM_READWRITE | G_PARAM_CONSTRUCT_ONLY)));
g_object_class_install_property(
gObjectClass,
PROP_WEBSQL_DIRECTORY,
g_param_spec_string(
"websql-directory",
_("WebSQL Directory"),
_("The directory where WebSQL databases will be stored"),
nullptr,
static_cast<GParamFlags>(WEBKIT_PARAM_READWRITE | G_PARAM_CONSTRUCT_ONLY)));
g_object_class_install_property(
gObjectClass,
PROP_IS_EPHEMERAL,
g_param_spec_boolean(
"is-ephemeral",
"Is Ephemeral",
_("Whether the WebKitWebsiteDataManager is ephemeral"),
FALSE,
static_cast<GParamFlags>(WEBKIT_PARAM_READWRITE | G_PARAM_CONSTRUCT_ONLY)));
}
WebKitWebsiteDataManager* webkitWebsiteDataManagerCreate(Ref<WebsiteDataStoreConfiguration>&& configuration)
{
WebKitWebsiteDataManager* manager = WEBKIT_WEBSITE_DATA_MANAGER(g_object_new(WEBKIT_TYPE_WEBSITE_DATA_MANAGER, nullptr));
manager->priv->websiteDataStore = API::WebsiteDataStore::createLegacy(WTFMove(configuration));
return manager;
}
API::WebsiteDataStore& webkitWebsiteDataManagerGetDataStore(WebKitWebsiteDataManager* manager)
{
WebKitWebsiteDataManagerPrivate* priv = manager->priv;
if (!priv->websiteDataStore) {
auto configuration = WebsiteDataStoreConfiguration::create();
configuration->setLocalStorageDirectory(!priv->localStorageDirectory ?
API::WebsiteDataStore::defaultLocalStorageDirectory() : WebCore::FileSystem::stringFromFileSystemRepresentation(priv->localStorageDirectory.get()));
configuration->setNetworkCacheDirectory(!priv->diskCacheDirectory ?
API::WebsiteDataStore::defaultNetworkCacheDirectory() : WebCore::FileSystem::pathByAppendingComponent(WebCore::FileSystem::stringFromFileSystemRepresentation(priv->diskCacheDirectory.get()), networkCacheSubdirectory));
configuration->setApplicationCacheDirectory(!priv->applicationCacheDirectory ?
API::WebsiteDataStore::defaultApplicationCacheDirectory() : WebCore::FileSystem::stringFromFileSystemRepresentation(priv->applicationCacheDirectory.get()));
configuration->setWebSQLDatabaseDirectory(!priv->webSQLDirectory ?
API::WebsiteDataStore::defaultWebSQLDatabaseDirectory() : WebCore::FileSystem::stringFromFileSystemRepresentation(priv->webSQLDirectory.get()));
configuration->setMediaKeysStorageDirectory(API::WebsiteDataStore::defaultMediaKeysStorageDirectory());
priv->websiteDataStore = API::WebsiteDataStore::createLegacy(WTFMove(configuration));
}
return *priv->websiteDataStore;
}
void webkitWebsiteDataManagerAddProcessPool(WebKitWebsiteDataManager* manager, WebProcessPool& processPool)
{
ASSERT(!manager->priv->processPools.contains(&processPool));
manager->priv->processPools.append(&processPool);
}
void webkitWebsiteDataManagerRemoveProcessPool(WebKitWebsiteDataManager* manager, WebProcessPool& processPool)
{
ASSERT(manager->priv->processPools.contains(&processPool));
manager->priv->processPools.removeFirst(&processPool);
}
const Vector<WebProcessPool*>& webkitWebsiteDataManagerGetProcessPools(WebKitWebsiteDataManager* manager)
{
return manager->priv->processPools;
}
WebKitWebsiteDataManager* webkit_website_data_manager_new(const gchar* firstOptionName, ...)
{
va_list args;
va_start(args, firstOptionName);
WebKitWebsiteDataManager* manager = WEBKIT_WEBSITE_DATA_MANAGER(g_object_new_valist(WEBKIT_TYPE_WEBSITE_DATA_MANAGER, firstOptionName, args));
va_end(args);
return manager;
}
WebKitWebsiteDataManager* webkit_website_data_manager_new_ephemeral()
{
return WEBKIT_WEBSITE_DATA_MANAGER(g_object_new(WEBKIT_TYPE_WEBSITE_DATA_MANAGER, "is-ephemeral", TRUE, nullptr));
}
gboolean webkit_website_data_manager_is_ephemeral(WebKitWebsiteDataManager* manager)
{
g_return_val_if_fail(WEBKIT_IS_WEBSITE_DATA_MANAGER(manager), FALSE);
return manager->priv->websiteDataStore && !manager->priv->websiteDataStore->isPersistent();
}
const gchar* webkit_website_data_manager_get_base_data_directory(WebKitWebsiteDataManager* manager)
{
g_return_val_if_fail(WEBKIT_IS_WEBSITE_DATA_MANAGER(manager), nullptr);
if (manager->priv->websiteDataStore && !manager->priv->websiteDataStore->isPersistent())
return nullptr;
return manager->priv->baseDataDirectory.get();
}
const gchar* webkit_website_data_manager_get_base_cache_directory(WebKitWebsiteDataManager* manager)
{
g_return_val_if_fail(WEBKIT_IS_WEBSITE_DATA_MANAGER(manager), nullptr);
if (manager->priv->websiteDataStore && !manager->priv->websiteDataStore->isPersistent())
return nullptr;
return manager->priv->baseCacheDirectory.get();
}
const gchar* webkit_website_data_manager_get_local_storage_directory(WebKitWebsiteDataManager* manager)
{
g_return_val_if_fail(WEBKIT_IS_WEBSITE_DATA_MANAGER(manager), nullptr);
WebKitWebsiteDataManagerPrivate* priv = manager->priv;
if (priv->websiteDataStore && !priv->websiteDataStore->isPersistent())
return nullptr;
if (!priv->localStorageDirectory)
priv->localStorageDirectory.reset(g_strdup(API::WebsiteDataStore::defaultLocalStorageDirectory().utf8().data()));
return priv->localStorageDirectory.get();
}
const gchar* webkit_website_data_manager_get_disk_cache_directory(WebKitWebsiteDataManager* manager)
{
g_return_val_if_fail(WEBKIT_IS_WEBSITE_DATA_MANAGER(manager), nullptr);
WebKitWebsiteDataManagerPrivate* priv = manager->priv;
if (priv->websiteDataStore && !priv->websiteDataStore->isPersistent())
return nullptr;
if (!priv->diskCacheDirectory) {
priv->diskCacheDirectory.reset(g_strdup(WebCore::FileSystem::directoryName(API::WebsiteDataStore::defaultNetworkCacheDirectory()).utf8().data()));
}
return priv->diskCacheDirectory.get();
}
const gchar* webkit_website_data_manager_get_offline_application_cache_directory(WebKitWebsiteDataManager* manager)
{
g_return_val_if_fail(WEBKIT_IS_WEBSITE_DATA_MANAGER(manager), nullptr);
WebKitWebsiteDataManagerPrivate* priv = manager->priv;
if (priv->websiteDataStore && !priv->websiteDataStore->isPersistent())
return nullptr;
if (!priv->applicationCacheDirectory)
priv->applicationCacheDirectory.reset(g_strdup(API::WebsiteDataStore::defaultApplicationCacheDirectory().utf8().data()));
return priv->applicationCacheDirectory.get();
}
const gchar* webkit_website_data_manager_get_indexeddb_directory(WebKitWebsiteDataManager* manager)
{
g_return_val_if_fail(WEBKIT_IS_WEBSITE_DATA_MANAGER(manager), nullptr);
WebKitWebsiteDataManagerPrivate* priv = manager->priv;
if (priv->websiteDataStore && !priv->websiteDataStore->isPersistent())
return nullptr;
if (!priv->indexedDBDirectory)
priv->indexedDBDirectory.reset(g_strdup(API::WebsiteDataStore::defaultIndexedDBDatabaseDirectory().utf8().data()));
return priv->indexedDBDirectory.get();
}
const gchar* webkit_website_data_manager_get_websql_directory(WebKitWebsiteDataManager* manager)
{
g_return_val_if_fail(WEBKIT_IS_WEBSITE_DATA_MANAGER(manager), nullptr);
WebKitWebsiteDataManagerPrivate* priv = manager->priv;
if (priv->websiteDataStore && !priv->websiteDataStore->isPersistent())
return nullptr;
if (!priv->webSQLDirectory)
priv->webSQLDirectory.reset(g_strdup(API::WebsiteDataStore::defaultWebSQLDatabaseDirectory().utf8().data()));
return priv->webSQLDirectory.get();
}
WebKitCookieManager* webkit_website_data_manager_get_cookie_manager(WebKitWebsiteDataManager* manager)
{
g_return_val_if_fail(WEBKIT_IS_WEBSITE_DATA_MANAGER(manager), nullptr);
if (!manager->priv->cookieManager)
manager->priv->cookieManager = adoptGRef(webkitCookieManagerCreate(manager));
return manager->priv->cookieManager.get();
}
static OptionSet<WebsiteDataType> toWebsiteDataTypes(WebKitWebsiteDataTypes types)
{
OptionSet<WebsiteDataType> returnValue;
if (types & WEBKIT_WEBSITE_DATA_MEMORY_CACHE)
returnValue.add(WebsiteDataType::MemoryCache);
if (types & WEBKIT_WEBSITE_DATA_DISK_CACHE)
returnValue.add(WebsiteDataType::DiskCache);
if (types & WEBKIT_WEBSITE_DATA_OFFLINE_APPLICATION_CACHE)
returnValue.add(WebsiteDataType::OfflineWebApplicationCache);
if (types & WEBKIT_WEBSITE_DATA_SESSION_STORAGE)
returnValue.add(WebsiteDataType::SessionStorage);
if (types & WEBKIT_WEBSITE_DATA_LOCAL_STORAGE)
returnValue.add(WebsiteDataType::LocalStorage);
if (types & WEBKIT_WEBSITE_DATA_WEBSQL_DATABASES)
returnValue.add(WebsiteDataType::WebSQLDatabases);
if (types & WEBKIT_WEBSITE_DATA_INDEXEDDB_DATABASES)
returnValue.add(WebsiteDataType::IndexedDBDatabases);
#if ENABLE(NETSCAPE_PLUGIN_API)
if (types & WEBKIT_WEBSITE_DATA_PLUGIN_DATA)
returnValue.add(WebsiteDataType::PlugInData);
#endif
if (types & WEBKIT_WEBSITE_DATA_COOKIES)
returnValue.add(WebsiteDataType::Cookies);
if (types & WEBKIT_WEBSITE_DATA_DEVICE_ID_HASH_SALT)
returnValue.add(WebsiteDataType::DeviceIdHashSalt);
return returnValue;
}
void webkit_website_data_manager_fetch(WebKitWebsiteDataManager* manager, WebKitWebsiteDataTypes types, GCancellable* cancellable, GAsyncReadyCallback callback, gpointer userData)
{
g_return_if_fail(WEBKIT_IS_WEBSITE_DATA_MANAGER(manager));
GRefPtr<GTask> task = adoptGRef(g_task_new(manager, cancellable, callback, userData));
manager->priv->websiteDataStore->websiteDataStore().fetchData(toWebsiteDataTypes(types), WebsiteDataFetchOption::ComputeSizes, [task = WTFMove(task)] (Vector<WebsiteDataRecord> records) {
GList* dataList = nullptr;
while (!records.isEmpty()) {
if (auto* data = webkitWebsiteDataCreate(records.takeLast()))
dataList = g_list_prepend(dataList, data);
}
g_task_return_pointer(task.get(), dataList, [](gpointer data) {
g_list_free_full(static_cast<GList*>(data), reinterpret_cast<GDestroyNotify>(webkit_website_data_unref));
});
});
}
GList* webkit_website_data_manager_fetch_finish(WebKitWebsiteDataManager* manager, GAsyncResult* result, GError** error)
{
g_return_val_if_fail(WEBKIT_IS_WEBSITE_DATA_MANAGER(manager), nullptr);
g_return_val_if_fail(g_task_is_valid(result, manager), nullptr);
return static_cast<GList*>(g_task_propagate_pointer(G_TASK(result), error));
}
void webkit_website_data_manager_remove(WebKitWebsiteDataManager* manager, WebKitWebsiteDataTypes types, GList* websiteData, GCancellable* cancellable, GAsyncReadyCallback callback, gpointer userData)
{
g_return_if_fail(WEBKIT_IS_WEBSITE_DATA_MANAGER(manager));
g_return_if_fail(websiteData);
if (types & WEBKIT_WEBSITE_DATA_COOKIES)
types = static_cast<WebKitWebsiteDataTypes>(types | WEBKIT_WEBSITE_DATA_DEVICE_ID_HASH_SALT);
Vector<WebsiteDataRecord> records;
for (GList* item = websiteData; item; item = g_list_next(item)) {
WebKitWebsiteData* data = static_cast<WebKitWebsiteData*>(item->data);
if (webkit_website_data_get_types(data) & types)
records.append(webkitWebsiteDataGetRecord(data));
}
GRefPtr<GTask> task = adoptGRef(g_task_new(manager, cancellable, callback, userData));
if (records.isEmpty()) {
g_task_return_boolean(task.get(), TRUE);
return;
}
manager->priv->websiteDataStore->websiteDataStore().removeData(toWebsiteDataTypes(types), records, [task = WTFMove(task)] {
g_task_return_boolean(task.get(), TRUE);
});
}
gboolean webkit_website_data_manager_remove_finish(WebKitWebsiteDataManager* manager, GAsyncResult* result, GError** error)
{
g_return_val_if_fail(WEBKIT_IS_WEBSITE_DATA_MANAGER(manager), FALSE);
g_return_val_if_fail(g_task_is_valid(result, manager), FALSE);
return g_task_propagate_boolean(G_TASK(result), error);
}
void webkit_website_data_manager_clear(WebKitWebsiteDataManager* manager, WebKitWebsiteDataTypes types, GTimeSpan timeSpan, GCancellable* cancellable, GAsyncReadyCallback callback, gpointer userData)
{
g_return_if_fail(WEBKIT_IS_WEBSITE_DATA_MANAGER(manager));
WallTime timePoint = timeSpan ? WallTime::now() - Seconds::fromMicroseconds(timeSpan) : WallTime::fromRawSeconds(0);
GRefPtr<GTask> task = adoptGRef(g_task_new(manager, cancellable, callback, userData));
manager->priv->websiteDataStore->websiteDataStore().removeData(toWebsiteDataTypes(types), timePoint, [task = WTFMove(task)] {
g_task_return_boolean(task.get(), TRUE);
});
}
gboolean webkit_website_data_manager_clear_finish(WebKitWebsiteDataManager* manager, GAsyncResult* result, GError** error)
{
g_return_val_if_fail(WEBKIT_IS_WEBSITE_DATA_MANAGER(manager), FALSE);
g_return_val_if_fail(g_task_is_valid(result, manager), FALSE);
return g_task_propagate_boolean(G_TASK(result), error);
}