diff options
Diffstat (limited to 'WebKit/gtk/webkit/webkitwebdatabase.cpp')
| -rw-r--r-- | WebKit/gtk/webkit/webkitwebdatabase.cpp | 533 |
1 files changed, 533 insertions, 0 deletions
diff --git a/WebKit/gtk/webkit/webkitwebdatabase.cpp b/WebKit/gtk/webkit/webkitwebdatabase.cpp new file mode 100644 index 0000000..100176e --- /dev/null +++ b/WebKit/gtk/webkit/webkitwebdatabase.cpp @@ -0,0 +1,533 @@ +/* + * Copyright (C) 2009 Martin Robinson + * + * This library is free software; you can redistribute it and/or + * modify it under the terms of the GNU Library General Public + * License as published by the Free Software Foundation; either + * version 2 of the License, or (at your option) any later version. + * + * This library is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + * Library General Public License for more details. + * + * You should have received a copy of the GNU Library General Public License + * along with this library; see the file COPYING.LIB. If not, write to + * the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, + * Boston, MA 02110-1301, USA. + */ + +#include "config.h" +#include "webkitwebdatabase.h" + +#include "webkitprivate.h" + +#include "CString.h" +#include "DatabaseDetails.h" +#include "DatabaseTracker.h" + +#include <glib/gi18n-lib.h> + +/** + * SECTION:webkitwebdatabase + * @short_description: A WebKit web application database + * + * #WebKitWebDatabase is a representation of a Web Database database. The + * proposed Web Database standard introduces support for SQL databases that web + * sites can create and access on a local computer through JavaScript. + * + * To get access to all databases defined by a security origin, use + * #webkit_security_origin_get_databases. Each database has a canonical + * name, as well as a user-friendly display name. + * + * WebKit uses SQLite to create and access the local SQL databases. The location + * of a #WebKitWebDatabase can be accessed wth #webkit_web_database_get_filename. + * You can configure the location of all databases with + * #webkit_set_database_directory_path. + * + * For each database the web site can define an estimated size which can be + * accessed with #webkit_web_database_get_expected_size. The current size of the + * database in bytes is returned by #webkit_web_database_get_size. + * + * For more information refer to the Web Database specification proposal at + * http://dev.w3.org/html5/webdatabase + */ + +using namespace WebKit; + +enum { + PROP_0, + + PROP_SECURITY_ORIGIN, + PROP_NAME, + PROP_DISPLAY_NAME, + PROP_EXPECTED_SIZE, + PROP_SIZE, + PROP_PATH +}; + +G_DEFINE_TYPE(WebKitWebDatabase, webkit_web_database, G_TYPE_OBJECT) + +struct _WebKitWebDatabasePrivate { + WebKitSecurityOrigin* origin; + gchar* name; + gchar* displayName; + gchar* filename; +}; + +static gchar* webkit_database_directory_path = NULL; +static guint64 webkit_default_database_quota = 5 * 1024 * 1024; + +#define WEBKIT_WEB_DATABASE_GET_PRIVATE(obj) (G_TYPE_INSTANCE_GET_PRIVATE((obj), WEBKIT_TYPE_WEB_DATABASE, WebKitWebDatabasePrivate)) + +static void webkit_web_database_set_security_origin(WebKitWebDatabase* webDatabase, WebKitSecurityOrigin* security_origin); + +static void webkit_web_database_set_name(WebKitWebDatabase* webDatabase, const gchar* name); + +static void webkit_web_database_finalize(GObject* object) +{ + WebKitWebDatabase* webDatabase = WEBKIT_WEB_DATABASE(object); + WebKitWebDatabasePrivate* priv = webDatabase->priv; + + g_free(priv->name); + g_free(priv->displayName); + g_free(priv->filename); + + G_OBJECT_CLASS(webkit_web_database_parent_class)->finalize(object); +} + +static void webkit_web_database_dispose(GObject* object) +{ + WebKitWebDatabase* webDatabase = WEBKIT_WEB_DATABASE(object); + WebKitWebDatabasePrivate* priv = webDatabase->priv; + + if (priv->origin) { + g_object_unref(priv->origin); + priv->origin = NULL; + } + + G_OBJECT_CLASS(webkit_web_database_parent_class)->dispose(object); +} + +static void webkit_web_database_set_property(GObject* object, guint propId, const GValue* value, GParamSpec* pspec) +{ + WebKitWebDatabase* webDatabase = WEBKIT_WEB_DATABASE(object); + + switch (propId) { + case PROP_SECURITY_ORIGIN: + webkit_web_database_set_security_origin(webDatabase, WEBKIT_SECURITY_ORIGIN(g_value_get_object(value))); + break; + case PROP_NAME: + webkit_web_database_set_name(webDatabase, g_value_get_string(value)); + break; + default: + G_OBJECT_WARN_INVALID_PROPERTY_ID(object, propId, pspec); + break; + } +} + +static void webkit_web_database_get_property(GObject* object, guint propId, GValue* value, GParamSpec* pspec) +{ + WebKitWebDatabase* webDatabase = WEBKIT_WEB_DATABASE(object); + WebKitWebDatabasePrivate* priv = webDatabase->priv; + + switch (propId) { + case PROP_SECURITY_ORIGIN: + g_value_set_object(value, priv->origin); + break; + case PROP_NAME: + g_value_set_string(value, webkit_web_database_get_name(webDatabase)); + break; + case PROP_DISPLAY_NAME: + g_value_set_string(value, webkit_web_database_get_display_name(webDatabase)); + break; + case PROP_EXPECTED_SIZE: + g_value_set_uint64(value, webkit_web_database_get_expected_size(webDatabase)); + break; + case PROP_SIZE: + g_value_set_uint64(value, webkit_web_database_get_size(webDatabase)); + break; + case PROP_PATH: + g_value_set_string(value, webkit_web_database_get_filename(webDatabase)); + break; + default: + G_OBJECT_WARN_INVALID_PROPERTY_ID(object, propId, pspec); + break; + } +} + +static void webkit_web_database_class_init(WebKitWebDatabaseClass* klass) +{ + GObjectClass* gobjectClass = G_OBJECT_CLASS(klass); + gobjectClass->dispose = webkit_web_database_dispose; + gobjectClass->finalize = webkit_web_database_finalize; + gobjectClass->set_property = webkit_web_database_set_property; + gobjectClass->get_property = webkit_web_database_get_property; + + /** + * WebKitWebDatabase:security-origin: + * + * The security origin of the database. + * + * Since: 1.1.14 + */ + g_object_class_install_property(gobjectClass, PROP_SECURITY_ORIGIN, + g_param_spec_object("security-origin", + _("Security Origin"), + _("The security origin of the database"), + WEBKIT_TYPE_SECURITY_ORIGIN, + (GParamFlags) (G_PARAM_READWRITE | G_PARAM_CONSTRUCT_ONLY))); + + /** + * WebKitWebDatabase:name: + * + * The name of the Web Database database. + * + * Since: 1.1.14 + */ + g_object_class_install_property(gobjectClass, PROP_NAME, + g_param_spec_string("name", + _("Name"), + _("The name of the Web Database database"), + NULL, + (GParamFlags) (G_PARAM_READWRITE | G_PARAM_CONSTRUCT_ONLY))); + + /** + * WebKitWebDatabase:display-name: + * + * The display name of the Web Database database. + * + * Since: 1.1.14 + */ + g_object_class_install_property(gobjectClass, PROP_DISPLAY_NAME, + g_param_spec_string("display-name", + _("Display Name"), + _("The display name of the Web Storage database"), + NULL, + WEBKIT_PARAM_READABLE)); + + /** + * WebKitWebDatabase:expected-size: + * + * The expected size of the database in bytes as defined by the web author. + * + * Since: 1.1.14 + */ + g_object_class_install_property(gobjectClass, PROP_EXPECTED_SIZE, + g_param_spec_uint64("expected-size", + _("Expected Size"), + _("The expected size of the Web Database database"), + 0, G_MAXUINT64, 0, + WEBKIT_PARAM_READABLE)); + /** + * WebKitWebDatabase:size: + * + * The current size of the database in bytes. + * + * Since: 1.1.14 + */ + g_object_class_install_property(gobjectClass, PROP_SIZE, + g_param_spec_uint64("size", + _("Size"), + _("The current size of the Web Database database"), + 0, G_MAXUINT64, 0, + WEBKIT_PARAM_READABLE)); + /** + * WebKitWebDatabase:filename: + * + * The absolute filename of the Web Database database. + * + * Since: 1.1.14 + */ + g_object_class_install_property(gobjectClass, PROP_PATH, + g_param_spec_string("filename", + _("Filename"), + _("The absolute filename of the Web Storage database"), + NULL, + WEBKIT_PARAM_READABLE)); + + g_type_class_add_private(klass, sizeof(WebKitWebDatabasePrivate)); +} + +static void webkit_web_database_init(WebKitWebDatabase* webDatabase) +{ + webDatabase->priv = WEBKIT_WEB_DATABASE_GET_PRIVATE(webDatabase); +} + +// Internal use only +static void webkit_web_database_set_security_origin(WebKitWebDatabase *webDatabase, WebKitSecurityOrigin *securityOrigin) +{ + g_return_if_fail(WEBKIT_IS_WEB_DATABASE(webDatabase)); + g_return_if_fail(WEBKIT_IS_SECURITY_ORIGIN(securityOrigin)); + + WebKitWebDatabasePrivate* priv = webDatabase->priv; + + if (priv->origin) + g_object_unref(priv->origin); + + g_object_ref(securityOrigin); + priv->origin = securityOrigin; +} + +static void webkit_web_database_set_name(WebKitWebDatabase* webDatabase, const gchar* name) +{ + g_return_if_fail(WEBKIT_IS_WEB_DATABASE(webDatabase)); + + WebKitWebDatabasePrivate* priv = webDatabase->priv; + g_free(priv->name); + priv->name = g_strdup(name); +} + +/** + * webkit_web_database_get_security_origin: + * @web_database: a #WebKitWebDatabase + * + * Returns the security origin of the #WebKitWebDatabase. + * + * Returns: the security origin of the database + * + * Since: 1.1.14 + **/ +WebKitSecurityOrigin* webkit_web_database_get_security_origin(WebKitWebDatabase* webDatabase) +{ + g_return_val_if_fail(WEBKIT_IS_WEB_DATABASE(webDatabase), NULL); + WebKitWebDatabasePrivate* priv = webDatabase->priv; + + return priv->origin; +} + +/** + * webkit_web_database_get_name: + * @web_database: a #WebKitWebDatabase + * + * Returns the canonical name of the #WebKitWebDatabase. + * + * Returns: the name of the database + * + * Since: 1.1.14 + **/ +G_CONST_RETURN gchar* webkit_web_database_get_name(WebKitWebDatabase* webDatabase) +{ + g_return_val_if_fail(WEBKIT_IS_WEB_DATABASE(webDatabase), NULL); + WebKitWebDatabasePrivate* priv = webDatabase->priv; + + return priv->name; +} + +/** + * webkit_web_database_get_display_name: + * @web_database: a #WebKitWebDatabase + * + * Returns the name of the #WebKitWebDatabase as seen by the user. + * + * Returns: the name of the database as seen by the user. + * + * Since: 1.1.14 + **/ +G_CONST_RETURN gchar* webkit_web_database_get_display_name(WebKitWebDatabase* webDatabase) +{ + g_return_val_if_fail(WEBKIT_IS_WEB_DATABASE(webDatabase), NULL); + +#if ENABLE(DATABASE) + WebKitWebDatabasePrivate* priv = webDatabase->priv; + WebCore::DatabaseDetails details = WebCore::DatabaseTracker::tracker().detailsForNameAndOrigin(priv->name, core(priv->origin)); + WebCore::String displayName = details.displayName(); + + if (displayName.isEmpty()) + return ""; + + g_free(priv->displayName); + priv->displayName = g_strdup(displayName.utf8().data()); + return priv->displayName; +#else + return ""; +#endif +} + +/** + * webkit_web_database_get_expected_size: + * @web_database: a #WebKitWebDatabase + * + * Returns the expected size of the #WebKitWebDatabase in bytes as defined by the + * web author. The Web Database standard allows web authors to specify an expected + * size of the database to optimize the user experience. + * + * Returns: the expected size of the database in bytes + * + * Since: 1.1.14 + **/ +guint64 webkit_web_database_get_expected_size(WebKitWebDatabase* webDatabase) +{ + g_return_val_if_fail(WEBKIT_IS_WEB_DATABASE(webDatabase), 0); + +#if ENABLE(DATABASE) + WebKitWebDatabasePrivate* priv = webDatabase->priv; + WebCore::DatabaseDetails details = WebCore::DatabaseTracker::tracker().detailsForNameAndOrigin(priv->name, core(priv->origin)); + return details.expectedUsage(); +#else + return 0; +#endif +} + +/** + * webkit_web_database_get_size: + * @web_database: a #WebKitWebDatabase + * + * Returns the actual size of the #WebKitWebDatabase space on disk in bytes. + * + * Returns: the actual size of the database in bytes + * + * Since: 1.1.14 + **/ +guint64 webkit_web_database_get_size(WebKitWebDatabase* webDatabase) +{ + g_return_val_if_fail(WEBKIT_IS_WEB_DATABASE(webDatabase), 0); + +#if ENABLE(DATABASE) + WebKitWebDatabasePrivate* priv = webDatabase->priv; + WebCore::DatabaseDetails details = WebCore::DatabaseTracker::tracker().detailsForNameAndOrigin(priv->name, core(priv->origin)); + return details.currentUsage(); +#else + return 0; +#endif +} + +/** + * webkit_web_database_get_filename: + * @web_database: a #WebKitWebDatabase + * + * Returns the absolute filename to the #WebKitWebDatabase file on disk. + * + * Returns: the absolute filename of the database + * + * Since: 1.1.14 + **/ +G_CONST_RETURN gchar* webkit_web_database_get_filename(WebKitWebDatabase* webDatabase) +{ + g_return_val_if_fail(WEBKIT_IS_WEB_DATABASE(webDatabase), NULL); + +#if ENABLE(DATABASE) + WebKitWebDatabasePrivate* priv = webDatabase->priv; + WebCore::String coreName = WebCore::String::fromUTF8(priv->name); + WebCore::String corePath = WebCore::DatabaseTracker::tracker().fullPathForDatabase(core(priv->origin), coreName); + + if (corePath.isEmpty()) + return""; + + g_free(priv->filename); + priv->filename = g_strdup(corePath.utf8().data()); + return priv->filename; + +#else + return ""; +#endif +} + +/** + * webkit_web_database_remove: + * @web_database: a #WebKitWebDatabase + * + * Removes the #WebKitWebDatabase from its security origin and destroys all data + * stored in the database. + * + * Since: 1.1.14 + **/ +void webkit_web_database_remove(WebKitWebDatabase* webDatabase) +{ + g_return_if_fail(WEBKIT_IS_WEB_DATABASE(webDatabase)); + +#if ENABLE(DATABASE) + WebKitWebDatabasePrivate* priv = webDatabase->priv; + WebCore::DatabaseTracker::tracker().deleteDatabase(core(priv->origin), priv->name); +#endif +} + +/** + * webkit_remove_all_web_databases: + * + * Removes all web databases from the current database directory path. + * + * Since: 1.1.14 + **/ +void webkit_remove_all_web_databases() +{ +#if ENABLE(DATABASE) + WebCore::DatabaseTracker::tracker().deleteAllDatabases(); +#endif +} + +/** + * webkit_get_web_database_directory_path: + * + * Returns the current path to the directory WebKit will write Web + * Database databases. By default this path will be in the user data + * directory. + * + * Returns: the current database directory path + * + * Since: 1.1.14 + **/ +G_CONST_RETURN gchar* webkit_get_web_database_directory_path() +{ +#if ENABLE(DATABASE) + WebCore::String path = WebCore::DatabaseTracker::tracker().databaseDirectoryPath(); + + if (path.isEmpty()) + return ""; + + g_free(webkit_database_directory_path); + webkit_database_directory_path = g_strdup(path.utf8().data()); + return webkit_database_directory_path; +#else + return ""; +#endif +} + +/** + * webkit_set_web_database_directory_path: + * @path: the new database directory path + * + * Sets the current path to the directory WebKit will write Web + * Database databases. + * + * Since: 1.1.14 + **/ +void webkit_set_web_database_directory_path(const gchar* path) +{ +#if ENABLE(DATABASE) + WebCore::String corePath = WebCore::String::fromUTF8(path); + WebCore::DatabaseTracker::tracker().setDatabaseDirectoryPath(corePath); + + g_free(webkit_database_directory_path); + webkit_database_directory_path = g_strdup(corePath.utf8().data()); +#endif +} + +/** + * webkit_get_default_web_database_quota: + * + * Returns the default quota for Web Database databases. By default + * this value is 5MB. + + * Returns: the current default database quota in bytes + * + * Since: 1.1.14 + **/ +guint64 webkit_get_default_web_database_quota() +{ + return webkit_default_database_quota; +} + +/** + * webkit_set_default_web_database_quota: + * @default_quota: the new default database quota + * + * Sets the current path to the directory WebKit will write Web + * Database databases. + * + * Since: 1.1.14 + **/ +void webkit_set_default_web_database_quota(guint64 defaultQuota) +{ + webkit_default_database_quota = defaultQuota; +} |