--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/WebKit/gtk/webkit/webkitwebdatabase.cpp Fri Sep 17 09:02:29 2010 +0300
@@ -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 "DatabaseDetails.h"
+#include "DatabaseTracker.h"
+#include <wtf/text/CString.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;
+}