New interfaces: EphyCookieManager, EphyPermissionManager,

2003-11-21  Christian Persch  <chpe@cvs.gnome.org>

	* embed/Makefile.am:
	* embed/ephy-cookie-manager.c: (ephy_cookie_get_type),
	(ephy_cookie_new), (ephy_cookie_copy), (ephy_cookie_free),
	(ephy_cookie_manager_get_type), (ephy_cookie_manager_base_init),
	(ephy_cookie_manager_list_cookies),
	(ephy_cookie_manager_remove_cookie), (ephy_cookie_manager_clear):
	* embed/ephy-cookie-manager.h:
	* embed/ephy-embed-single.c: (ephy_embed_single_get_type),
	(ephy_embed_single_class_init), (ephy_embed_single_clear_cache),
	(ephy_embed_single_set_offline_mode),
	(ephy_embed_single_load_proxy_autoconf),
	(ephy_embed_single_get_font_list):
	* embed/ephy-embed-single.h:
	* embed/ephy-password-manager.c: (ephy_password_info_get_type),
	(ephy_password_info_new), (ephy_password_info_copy),
	(ephy_password_info_free), (ephy_password_manager_get_type),
	(ephy_password_manager_add), (ephy_password_manager_remove),
	(ephy_password_manager_list):
	* embed/ephy-password-manager.h:
	* embed/ephy-permission-manager.c: (ephy_permission_info_get_type),
	(ephy_permission_info_new), (ephy_permission_info_copy),
	(ephy_permission_info_free), (ephy_permission_manager_get_type),
	(ephy_permission_manager_base_init), (ephy_permission_manager_add),
	(ephy_permission_manager_remove), (ephy_permission_manager_clear),
	(ephy_permission_manager_test), (ephy_permission_manager_list):
	* embed/ephy-permission-manager.h:
	* embed/mozilla/mozilla-embed-single.cpp:
	* embed/mozilla/mozilla-embed-single.h:
	* embed/mozilla/mozilla-notifiers.cpp:
	* src/Makefile.am:
	* src/pdm-dialog.c: (pdm_dialog_get_type), (pdm_dialog_cookie_add),
	(pdm_dialog_password_add), (pdm_dialog_cookie_remove),
	(pdm_dialog_password_remove), (pdm_dialog_cookies_free),
	(pdm_dialog_passwords_free), (pdm_dialog_init), (pdm_dialog_new),
	(show_cookies_properties),
	(pdm_dialog_cookies_properties_button_clicked_cb):
	* src/pdm-dialog.h:

	New interfaces: EphyCookieManager, EphyPermissionManager,
	EphyPasswordManager.
	Port all callers to new interfaces.
	Change linking order to make it link.

	Only set autoconf proxy url if it's non-empty.

12 files changed, 1527 insertions, 382 deletions

diff --git a/embed/Makefile.am b/embed/Makefile.am
index 30ff743e2..511050639 100644
--- a/embed/Makefile.am
+++ b/embed/Makefile.am
@@ -29,6 +29,7 @@ NOINST_H_FILES = \
 
 INST_H_FILES = \
 	ephy-command-manager.h		\
+	ephy-cookie-manager.h		\
 	ephy-embed.h			\
 	ephy-embed-event.h		\
 	ephy-embed-persist.h		\
@@ -36,11 +37,14 @@ INST_H_FILES = \
 	ephy-embed-single.h		\
 	ephy-embed-shell.h		\
 	ephy-encodings.h		\
-	ephy-history.h
+	ephy-history.h			\
+	ephy-password-manager.h		\
+	ephy-permission-manager.h
 
 libephyembed_la_SOURCES = \
 	downloader-view.c		\
 	ephy-command-manager.c		\
+	ephy-cookie-manager.c		\
 	ephy-download.c			\
 	ephy-embed.c			\
 	ephy-embed-dialog.c		\
@@ -52,7 +56,11 @@ libephyembed_la_SOURCES = \
 	ephy-encodings.c		\
 	ephy-favicon-cache.c		\
 	ephy-history.c			\
+	ephy-password-manager.c		\
+	ephy-permission-manager.c	\
 	find-dialog.c			\
 	print-dialog.c			\
 	$(INST_H_FILES)			\
 	$(NOINST_H_FILES)
+
+libephyembed_la_LIBADD = $(top_builddir)/embed/mozilla/libephymozillaembed.la
diff --git a/embed/ephy-cookie-manager.c b/embed/ephy-cookie-manager.c
new file mode 100644
index 000000000..a2c6805fc
--- /dev/null
+++ b/embed/ephy-cookie-manager.c
@@ -0,0 +1,262 @@
+/*
+ *  Copyright (C) 2000-2003 Marco Pesenti Gritti
+ *  Copyright (C) 2003 Christian Persch
+ *
+ *  This program is free software; you can redistribute it and/or modify
+ *  it under the terms of the GNU General Public License as published by
+ *  the Free Software Foundation; either version 2, or (at your option)
+ *  any later version.
+ *
+ *  This program 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 General Public License for more details.
+ *
+ *  You should have received a copy of the GNU General Public License
+ *  along with this program; if not, write to the Free Software
+ *  Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
+ *
+ *  $Id$
+ */
+
+#ifdef HAVE_CONFIG_H
+#include "config.h"
+#endif
+
+#include "ephy-cookie-manager.h"
+
+GType
+ephy_cookie_get_type (void)
+{
+	static GType type = 0;
+
+	if (type == 0)
+	{
+		type = g_boxed_type_register_static ("EphyCookie",
+						     (GBoxedCopyFunc) ephy_cookie_copy,
+						     (GBoxedFreeFunc) ephy_cookie_free);
+	}
+
+	return type;
+}
+
+/**
+ * ephy_cookie_new:
+ *
+ * Return value: a new #EphyCookie.
+ **/
+EphyCookie *
+ephy_cookie_new (void)
+{
+	return g_new0 (EphyCookie, 1);
+}
+
+/**
+ * ephy_cookie_copy:
+ * @cookie: a #EphyCookie
+ *
+ * Return value: a copy of @cookie.
+ **/
+EphyCookie *
+ephy_cookie_copy (EphyCookie *cookie)
+{
+	EphyCookie *copy = g_new0 (EphyCookie, 1);
+
+	copy->name = g_strdup (cookie->name);
+	copy->value = g_strdup (cookie->value);
+	copy->domain = g_strdup (cookie->domain);
+	copy->path = g_strdup (cookie->path);
+	copy->expires = cookie->expires;
+	copy->real_expires = cookie->real_expires;
+	copy->is_secure = cookie->is_secure;
+	copy->is_session = cookie->is_session;
+	copy->p3p_state = cookie->p3p_state;
+	copy->p3p_policy = cookie->p3p_policy;
+
+	return copy;
+}
+
+/**
+ * ephy_cookie_free:
+ * @cookie: a #EphyCookie
+ * 
+ * Frees @cookie.
+ **/
+void
+ephy_cookie_free (EphyCookie *cookie)
+{
+	if (cookie != NULL)
+	{
+		g_free (cookie->name);
+		g_free (cookie->value);
+		g_free (cookie->domain);
+		g_free (cookie->path);
+
+		g_free (cookie);
+	}
+}
+
+/* EphyCookieManager */
+
+static void ephy_cookie_manager_base_init (gpointer base_iface);
+
+GType
+ephy_cookie_manager_get_type (void)
+{
+       static GType type = 0;
+
+	if (type == 0)
+	{
+		static const GTypeInfo our_info =
+		{
+			sizeof (EphyCookieManagerIFace),
+			ephy_cookie_manager_base_init,
+			NULL,
+		};
+		
+		type = g_type_register_static (G_TYPE_INTERFACE,
+					       "EphyCookieManager",
+					       &our_info,
+					       (GTypeFlags) 0);
+	}
+
+	return type;
+}
+
+static void
+ephy_cookie_manager_base_init (gpointer base_iface)
+{
+	static gboolean initialised = FALSE;
+
+	if (initialised == FALSE)
+	{
+	/**
+	 * EphyCookieManager::added
+	 * @manager: the #EphyCookieManager
+	 * @cookie: the added #EphyCookie
+	 *
+	 * The added signal is emitted when a cookie has been added.
+	 **/
+	g_signal_new ("added",
+		      EPHY_TYPE_COOKIE_MANAGER,
+		      G_SIGNAL_RUN_FIRST,
+		      G_STRUCT_OFFSET (EphyCookieManagerIFace, added),
+		      NULL, NULL,
+		      g_cclosure_marshal_VOID__POINTER,
+		      G_TYPE_NONE,
+		      1,
+		      EPHY_TYPE_COOKIE);
+
+	/**
+	 * EphyCookieManager::changed
+	 * @manager: the #EphyCookieManager
+	 * @cookie: the changed #EphyCookie
+	 *
+	 * The changed signal is emitted when a cookie has been changed.
+	 **/
+	g_signal_new ("changed",
+		      EPHY_TYPE_COOKIE_MANAGER,
+		      G_SIGNAL_RUN_FIRST,
+		      G_STRUCT_OFFSET (EphyCookieManagerIFace, changed),
+		      NULL, NULL,
+		      g_cclosure_marshal_VOID__BOXED,
+		      G_TYPE_NONE,
+		      1,
+		      EPHY_TYPE_COOKIE);
+
+	/**
+	 * EphyCookieManager::deleted
+	 * @manager: the #EphyCookieManager
+	 * @cookie: the deleted #EphyCookie
+	 *
+	 * The deleted signal is emitted when a cookie has been deleted.
+	 **/
+	g_signal_new ("deleted",
+		      EPHY_TYPE_COOKIE_MANAGER,
+		      G_SIGNAL_RUN_FIRST,
+		      G_STRUCT_OFFSET (EphyCookieManagerIFace, deleted),
+		      NULL, NULL,
+		      g_cclosure_marshal_VOID__BOXED,
+		      G_TYPE_NONE,
+		      1,
+		      EPHY_TYPE_COOKIE);
+
+	/**
+	 * EphyCookieManager::rejected
+	 * @manager: the #EphyCookieManager
+	 * @address: the address of the page that wanted to set the cookie
+	 *
+	 * The rejected signal is emitted when a cookie has been rejected.
+	 **/
+	g_signal_new ("rejected",
+		      EPHY_TYPE_COOKIE_MANAGER,
+		      G_SIGNAL_RUN_FIRST,
+		      G_STRUCT_OFFSET (EphyCookieManagerIFace, rejected),
+		      NULL, NULL,
+		      g_cclosure_marshal_VOID__STRING,
+		      G_TYPE_NONE,
+		      1,
+		      G_TYPE_STRING);
+
+	/**
+	 * EphyCookieManager::cleared
+	 * @manager: the #EphyCookieManager
+	 *
+	 * The cleared signal is emitted when the cookie database has been
+	 * cleared.
+	 **/
+	g_signal_new ("cleared",
+		      EPHY_TYPE_COOKIE_MANAGER,
+		      G_SIGNAL_RUN_FIRST,
+		      G_STRUCT_OFFSET (EphyCookieManagerIFace, cleared),
+		      NULL, NULL,
+		      g_cclosure_marshal_VOID__VOID,
+		      G_TYPE_NONE,
+		      0);
+
+	initialised = TRUE;
+	}
+}
+
+/**
+ * ephy_cookie_manager_list_cookies:
+ * @manager: the #EphyCookieManager
+ * 
+ * Lists all cookies in the cookies database.
+ * 
+ * Return value: the cookies list
+ **/
+GList *
+ephy_cookie_manager_list_cookies (EphyCookieManager *manager)
+{
+	EphyCookieManagerIFace *iface = EPHY_COOKIE_MANAGER_GET_CLASS (manager);
+	return iface->list (manager);
+}
+
+/**
+ * ephy_cookie_manager_remove_cookie:
+ * @manager: the #EphyCookieManager
+ * @cookie: a #EphyCookie
+ * 
+ * Removes @cookie from the cookies database. You must free @cookie yourself.
+ **/
+void
+ephy_cookie_manager_remove_cookie (EphyCookieManager *manager,
+				   EphyCookie *cookie)
+{
+	EphyCookieManagerIFace *iface = EPHY_COOKIE_MANAGER_GET_CLASS (manager);
+	iface->remove (manager, cookie);
+}
+
+/**
+ * ephy_cookie_manager_clear:
+ * @manager: the #EphyCookieManager
+ * 
+ * Clears the cookies database.
+ **/
+void
+ephy_cookie_manager_clear (EphyCookieManager *manager)
+{
+	EphyCookieManagerIFace *iface = EPHY_COOKIE_MANAGER_GET_CLASS (manager);
+	iface->clear (manager);
+}
diff --git a/embed/ephy-cookie-manager.h b/embed/ephy-cookie-manager.h
new file mode 100644
index 000000000..f4782d2cf
--- /dev/null
+++ b/embed/ephy-cookie-manager.h
@@ -0,0 +1,122 @@
+/*
+ *  Copyright (C) 2003 Marco Pesenti Gritti
+ *  Copyright (C) 2003 Christian Persch
+ *
+ *  This program is free software; you can redistribute it and/or modify
+ *  it under the terms of the GNU General Public License as published by
+ *  the Free Software Foundation; either version 2, or (at your option)
+ *  any later version.
+ *
+ *  This program 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 General Public License for more details.
+ *
+ *  You should have received a copy of the GNU General Public License
+ *  along with this program; if not, write to the Free Software
+ *  Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
+ *
+ *  $Id$
+ */
+
+#ifndef EPHY_COOKIE_MANAGER_H
+#define EPHY_COOKIE_MANAGER_H
+
+#include <glib-object.h>
+#include <glib.h>
+
+G_BEGIN_DECLS
+
+#define EPHY_TYPE_COOKIE_MANAGER		(ephy_cookie_manager_get_type ())
+#define EPHY_COOKIE_MANAGER(o)			(G_TYPE_CHECK_INSTANCE_CAST ((o), EPHY_TYPE_COOKIE_MANAGER, EphyCookieManager))
+#define EPHY_COOKIE_MANAGER_CLASS(k)		(G_TYPE_CHECK_CLASS_CAST((k), EPHY_TYPE_COOKIE_MANAGER, EphyCookieManagerClass))
+#define EPHY_IS_COOKIE_MANAGER(o)		(G_TYPE_CHECK_INSTANCE_TYPE ((o), EPHY_TYPE_COOKIE_MANAGER))
+#define EPHY_IS_COOKIE_MANAGER_CLASS(k)		(G_TYPE_CHECK_CLASS_TYPE ((k), EPHY_TYPE_COOKIE_MANAGER))
+#define EPHY_COOKIE_MANAGER_GET_CLASS(inst)	(G_TYPE_INSTANCE_GET_INTERFACE ((inst), EPHY_TYPE_COOKIE_MANAGER, EphyCookieManagerIFace))
+
+#define EPHY_TYPE_COOKIE			(ephy_cookie_get_type ())
+
+typedef struct EphyCookieManager	EphyCookieManager;
+typedef struct EphyCookieManagerIFace	EphyCookieManagerIFace;
+
+typedef enum
+{
+	EPHY_COOKIE_P3P_STATE_UNKNOWN,
+	EPHY_COOKIE_P3P_STATE_ACCEPTED,
+	EPHY_COOKIE_P3P_STATE_DOWNGRADED,
+	EPHY_COOKIE_P3P_STATE_FLAGGED,
+	EPHY_COOKIE_P3P_STATE_REJECTED
+} EphyCookieP3PState;
+
+typedef enum
+{
+	EPHY_COOKIE_P3P_POLICY_UNKNOWN,
+	EPHY_COOKIE_P3P_POLICY_NONE,
+	EPHY_COOKIE_P3P_POLICY_NO_CONSENT,
+	EPHY_COOKIE_P3P_POLICY_IMPLICIT_CONSENT,
+	EPHY_COOKIE_P3P_POLICY_EXPLICIT_CONSENT,
+	EPHY_COOKIE_P3P_POLICY_NO_II,
+} EphyCookieP3PPolicy;
+
+typedef struct
+{
+	char *name;
+	char *value;
+	char *domain;
+	char *path;
+	gulong expires;
+	glong real_expires;
+	guint is_secure : 1;
+	guint is_session : 1;
+	guint p3p_state : 3;
+	guint p3p_policy : 3;
+} EphyCookie;
+
+struct EphyCookieManagerIFace
+{
+	GTypeInterface base_iface;
+
+	/* Signals */
+	void	(* added)	(EphyCookieManager *manager,
+				 EphyCookie *cookie);
+	void	(* changed)	(EphyCookieManager *manager,
+				 EphyCookie *cookie);
+	void	(* deleted)	(EphyCookieManager *manager,
+				 EphyCookie *cookie);
+	void	(* rejected)	(EphyCookieManager *manager,
+				 const char *url);
+	void	(* cleared)	(EphyCookieManager *manager);
+
+	/* Methods */
+	GList *	(* list)	(EphyCookieManager *manager);
+	void	(* remove)	(EphyCookieManager *manager,
+				 EphyCookie *cookie);
+	void	(* clear)	(EphyCookieManager *manager);
+};
+
+/* EphyCookie */
+
+GType		ephy_cookie_get_type	(void);
+
+EphyCookie     *ephy_cookie_new		(void);
+
+EphyCookie     *ephy_cookie_copy	(EphyCookie *cookie);
+
+void		ephy_cookie_free	(EphyCookie *cookie);
+
+/* EphyCookieManager */
+
+GType 		ephy_cookie_manager_get_type		(void);
+
+void		ephy_cookie_free			(EphyCookie *cookie);
+
+GList *		ephy_cookie_manager_list_cookies	(EphyCookieManager *manager);
+
+void		ephy_cookie_manager_remove_cookie	(EphyCookieManager *manager,
+							 EphyCookie *cookie);
+
+void		ephy_cookie_manager_clear		(EphyCookieManager *manager);
+
+G_END_DECLS
+
+#endif
diff --git a/embed/ephy-embed-single.c b/embed/ephy-embed-single.c
index e5bfd0f65..efaf2db39 100644
--- a/embed/ephy-embed-single.c
+++ b/embed/ephy-embed-single.c
@@ -22,66 +22,41 @@
 #include "config.h"
 #endif
 
-#include "ephy-embed-shell.h"
+#include "ephy-embed-single.h"
 #include "ephy-marshal.h"
-#include "ephy-favicon-cache.h"
-#include "mozilla-embed-single.h"
-#include "ephy-debug.h"
-#include "downloader-view.h"
 
-#include <string.h>
-
-#define EPHY_EMBED_SINGLE_GET_PRIVATE(object)(G_TYPE_INSTANCE_GET_PRIVATE ((object), EPHY_TYPE_EMBED_SINGLE, EphyEmbedSinglePrivate))
-
-struct EphyEmbedSinglePrivate
-{
-	EphyHistory *global_history;
-	DownloaderView *downloader_view;
-	EphyFaviconCache *favicon_cache;
-};
-
-static void
-ephy_embed_single_class_init (EphyEmbedSingleClass *klass);
-static void
-ephy_embed_single_init (EphyEmbedSingle *ges);
-
-static GObjectClass *parent_class = NULL;
+static void ephy_embed_single_class_init (gpointer g_class);
 
 GType
 ephy_embed_single_get_type (void)
 {
-       static GType ephy_embed_single_type = 0;
+	static GType type = 0;
 
-	if (ephy_embed_single_type == 0)
+	if (type == 0)
 	{
 		static const GTypeInfo our_info =
 		{
 			sizeof (EphyEmbedSingleClass),
-			NULL, /* base_init */
-			NULL, /* base_finalize */
-			(GClassInitFunc) ephy_embed_single_class_init,
-			NULL, /* class_finalize */
-			NULL, /* class_data */
-			sizeof (EphyEmbedSingle),
-			0,    /* n_preallocs */
-			(GInstanceInitFunc) ephy_embed_single_init
+			ephy_embed_single_class_init,
+			NULL,
 		};
 
-		ephy_embed_single_type = g_type_register_static (G_TYPE_OBJECT,
-								"EphyEmbedSingle",
-								&our_info, 0);
+		type = g_type_register_static (G_TYPE_INTERFACE,
+					       "EphyEmbedSingle",
+					       &our_info,
+					       (GTypeFlags) 0);
 	}
 
-	return ephy_embed_single_type;
+	return type;
 }
 
 static void
-ephy_embed_single_class_init (EphyEmbedSingleClass *klass)
+ephy_embed_single_class_init (gpointer g_class)
 {
-	GObjectClass *object_class = G_OBJECT_CLASS (klass);
-
-	parent_class = (GObjectClass *) g_type_class_peek_parent (klass);
+	static gboolean initialised = FALSE;
 
+	if (initialised == FALSE)
+	{
 	g_signal_new ("handle_content",
 		      EPHY_TYPE_EMBED_SINGLE,
 		      G_SIGNAL_RUN_LAST,
@@ -93,118 +68,37 @@ ephy_embed_single_class_init (EphyEmbedSingleClass *klass)
 		      G_TYPE_STRING,
 		      G_TYPE_STRING);
 
-	g_type_class_add_private (object_class, sizeof(EphyEmbedSinglePrivate));
-}
-
-static void
-ephy_embed_single_init (EphyEmbedSingle *ges)
-{
-	ges->priv = EPHY_EMBED_SINGLE_GET_PRIVATE (ges);
-
-	ges->priv->global_history = NULL;
-	ges->priv->downloader_view = NULL;
-
-	ges->priv->favicon_cache = NULL;
+	initialised = TRUE;
+	}
 }
 
 void
-ephy_embed_single_clear_cache (EphyEmbedSingle *shell)
+ephy_embed_single_clear_cache (EphyEmbedSingle *single)
 {
-	EphyEmbedSingleClass *klass = EPHY_EMBED_SINGLE_GET_CLASS (shell);
-	klass->clear_cache (shell);
+	EphyEmbedSingleClass *klass = EPHY_EMBED_SINGLE_GET_CLASS (single);
+	klass->clear_cache (single);
 }
 
 void
-ephy_embed_single_set_offline_mode (EphyEmbedSingle *shell,
-				   gboolean offline)
+ephy_embed_single_set_offline_mode (EphyEmbedSingle *single,
+				    gboolean offline)
 {
-	EphyEmbedSingleClass *klass = EPHY_EMBED_SINGLE_GET_CLASS (shell);
-	klass->set_offline_mode (shell, offline);
+	EphyEmbedSingleClass *klass = EPHY_EMBED_SINGLE_GET_CLASS (single);
+	klass->set_offline_mode (single, offline);
 }
 
 void
-ephy_embed_single_load_proxy_autoconf (EphyEmbedSingle *shell,
-				      const char* url)
+ephy_embed_single_load_proxy_autoconf (EphyEmbedSingle *single,
+				       const char* url)
 {
-	EphyEmbedSingleClass *klass = EPHY_EMBED_SINGLE_GET_CLASS (shell);
-	klass->load_proxy_autoconf (shell, url);
+	EphyEmbedSingleClass *klass = EPHY_EMBED_SINGLE_GET_CLASS (single);
+	klass->load_proxy_autoconf (single, url);
 }
 
 GList *
-ephy_embed_single_get_font_list (EphyEmbedSingle *shell,
+ephy_embed_single_get_font_list (EphyEmbedSingle *single,
 				 const char *langGroup)
 {
-	EphyEmbedSingleClass *klass = EPHY_EMBED_SINGLE_GET_CLASS (shell);
-	return klass->get_font_list (shell, langGroup);
-}
-
-GList *
-ephy_embed_single_list_cookies (EphyEmbedSingle *shell)
-{
-	EphyEmbedSingleClass *klass = EPHY_EMBED_SINGLE_GET_CLASS (shell);
-	return klass->list_cookies (shell);
-}
-
-void
-ephy_embed_single_remove_cookies (EphyEmbedSingle *shell,
-				 GList *cookies)
-{
-	EphyEmbedSingleClass *klass = EPHY_EMBED_SINGLE_GET_CLASS (shell);
-	klass->remove_cookies (shell, cookies);
-}
-
-GList *
-ephy_embed_single_list_passwords (EphyEmbedSingle *shell,
-				  PasswordType type)
-{
-	EphyEmbedSingleClass *klass = EPHY_EMBED_SINGLE_GET_CLASS (shell);
-	return klass->list_passwords (shell, type);
-}
-
-void
-ephy_embed_single_remove_passwords (EphyEmbedSingle *shell,
-				    GList *passwords,
-				    PasswordType type)
-{
-	EphyEmbedSingleClass *klass = EPHY_EMBED_SINGLE_GET_CLASS (shell);
-	klass->remove_passwords (shell, passwords, type);
-}
-
-void
-ephy_embed_single_free_cookies (EphyEmbedSingle *shell,
-				GList *cookies)
-{
-	GList *l;
-
-	for (l = cookies; l != NULL; l = l->next)
-	{
-		CookieInfo *info = (CookieInfo *)l->data;
-
-		g_free (info->domain);
-		g_free (info->name);
-		g_free (info->value);
-		g_free (info->path);
-		g_free (info->secure);
-		g_free (info->expire);
-		g_free (info);
-	}
-
-	g_list_free (cookies);
-}
-
-void
-ephy_embed_single_free_passwords (EphyEmbedSingle *shell,
-				  GList *passwords)
-{
-	GList *l;
-
-	for (l = passwords; l != NULL; l = l->next)
-	{
-		PasswordInfo *info = (PasswordInfo *)l->data;
-		g_free (info->host);
-		g_free (info->username);
-		g_free (info);
-	}
-
-	g_list_free (passwords);
+	EphyEmbedSingleClass *klass = EPHY_EMBED_SINGLE_GET_CLASS (single);
+	return klass->get_font_list (single, langGroup);
 }
diff --git a/embed/ephy-embed-single.h b/embed/ephy-embed-single.h
index a30eb4194..dac415cc1 100644
--- a/embed/ephy-embed-single.h
+++ b/embed/ephy-embed-single.h
@@ -21,10 +21,6 @@
 #ifndef EPHY_EMBED_SINGLE_H
 #define EPHY_EMBED_SINGLE_H
 
-#include "ephy-embed.h"
-#include "ephy-history.h"
-#include "ephy-langs.h"
-
 #include <glib-object.h>
 #include <glib.h>
 
@@ -35,60 +31,14 @@ G_BEGIN_DECLS
 #define EPHY_EMBED_SINGLE_CLASS(k)	(G_TYPE_CHECK_CLASS_CAST((k), EPHY_TYPE_EMBED_SINGLE, EphyEmbedSingleClass))
 #define EPHY_IS_EMBED_SINGLE(o)		(G_TYPE_CHECK_INSTANCE_TYPE ((o), EPHY_TYPE_EMBED_SINGLE))
 #define EPHY_IS_EMBED_SINGLE_CLASS(k)	(G_TYPE_CHECK_CLASS_TYPE ((k), EPHY_TYPE_EMBED_SINGLE))
-#define EPHY_EMBED_SINGLE_GET_CLASS(o)	(G_TYPE_INSTANCE_GET_CLASS ((o), EPHY_TYPE_EMBED_SINGLE, EphyEmbedSingleClass))
-
-typedef struct EphyEmbedSingleClass EphyEmbedSingleClass;
-typedef struct EphyEmbedSingle EphyEmbedSingle;
-typedef struct EphyEmbedSinglePrivate EphyEmbedSinglePrivate;
+#define EPHY_EMBED_SINGLE_GET_CLASS(i)	(G_TYPE_INSTANCE_GET_INTERFACE ((i), EPHY_TYPE_EMBED_SINGLE, EphyEmbedSingleClass))
 
-/**
- * Cookie: the type of cookies
- */
-typedef struct
-{
-	gchar *domain;
-	gchar *name;
-	gchar *value;
-	gchar *path;
-	gchar *secure;
-	gchar *expire;
-} CookieInfo;
-
-/**
- * Password: a password manager entry
- */
-typedef struct
-{
-	gchar *host;
-	gchar *username;
-} PasswordInfo;
-
-/**
- * PasswordType: To distinguish actual passwords from blocked password sites
- */
-typedef enum
-{
-	PASSWORD_PASSWORD,
-	PASSWORD_REJECT
-} PasswordType;
-
-typedef enum
-{
-	COOKIES_PERMISSION,
-	IMAGES_PERMISSION
-} PermissionType;
-
-struct EphyEmbedSingle
-{
-	GObject parent;
-
-	/*< private >*/
-	EphyEmbedSinglePrivate *priv;
-};
+typedef struct EphyEmbedSingleClass	EphyEmbedSingleClass;
+typedef struct EphyEmbedSingle		EphyEmbedSingle;
 
 struct EphyEmbedSingleClass
 {
-	GObjectClass parent_class;
+	GTypeInterface base_iface;
 
 	/* Signals */
 
@@ -103,18 +53,8 @@ struct EphyEmbedSingleClass
 					 gboolean offline);
 	void	(* load_proxy_autoconf) (EphyEmbedSingle *shell,
 					 const char* url);
-	void	(* show_java_console)   (EphyEmbedSingle *shell);
-	void	(* show_js_console)     (EphyEmbedSingle *shell);
 	GList *	(* get_font_list)	(EphyEmbedSingle *shell,
 					 const char *langGroup);
-	GList *	(* list_cookies)        (EphyEmbedSingle *shell);
-	void	(* remove_cookies)      (EphyEmbedSingle *shell,
-					 GList *cookies);
-	GList *	(* list_passwords)      (EphyEmbedSingle *shell,
-					 PasswordType type);
-	void	(* remove_passwords)    (EphyEmbedSingle *shell,
-					 GList *passwords,
-					 PasswordType type);
 };
 
 GType	ephy_embed_single_get_type		(void);
@@ -125,31 +65,11 @@ void	ephy_embed_single_set_offline_mode	(EphyEmbedSingle *shell,
 						 gboolean offline);
 
 void	ephy_embed_single_load_proxy_autoconf	(EphyEmbedSingle *shell,
-						const char* url);
+						 const char* url);
 
 GList  *ephy_embed_single_get_font_list		(EphyEmbedSingle *shell,
 						 const char *langGroup);
 
-/* Cookies */
-GList  *ephy_embed_single_list_cookies		(EphyEmbedSingle *shell);
-
-void	ephy_embed_single_remove_cookies	(EphyEmbedSingle *shell,
-						 GList *cookies);
-
-void	ephy_embed_single_free_cookies		(EphyEmbedSingle *shell,
-						 GList *cookies);
-
-/* Passwords */
-GList  *ephy_embed_single_list_passwords	(EphyEmbedSingle *shell,
-						 PasswordType type);
-
-void	ephy_embed_single_free_passwords	(EphyEmbedSingle *shell,
-						 GList *passwords);
-
-void	ephy_embed_single_remove_passwords	(EphyEmbedSingle *shell,
-						 GList *passwords,
-						 PasswordType type);
-
 G_END_DECLS
 
 #endif
diff --git a/embed/ephy-password-manager.c b/embed/ephy-password-manager.c
new file mode 100644
index 000000000..d9b7e8dc2
--- /dev/null
+++ b/embed/ephy-password-manager.c
@@ -0,0 +1,175 @@
+/*
+ *  Copyright (C) 2003 Marco Pesenti Gritti
+ *  Copyright (C) 2003 Christian Persch
+ *
+ *  This program is free software; you can redistribute it and/or modify
+ *  it under the terms of the GNU General Public License as published by
+ *  the Free Software Foundation; either version 2, or (at your option)
+ *  any later version.
+ *
+ *  This program 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 General Public License for more details.
+ *
+ *  You should have received a copy of the GNU General Public License
+ *  along with this program; if not, write to the Free Software
+ *  Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
+ *
+ *  $Id$
+ */
+
+#ifdef HAVE_CONFIG_H
+#include "config.h"
+#endif
+
+#include "ephy-password-manager.h"
+#include "ephy-marshal.h"
+#include "ephy-debug.h"
+
+/* EphyPasswordInfo */
+
+GType
+ephy_password_info_get_type (void)
+{
+	static GType type = 0;
+
+	if (type == 0)
+	{
+		type = g_boxed_type_register_static ("EphyPasswordInfo",
+						     (GBoxedCopyFunc) ephy_password_info_copy,
+						     (GBoxedFreeFunc) ephy_password_info_free);
+	}
+
+	return type;
+}
+
+/**
+ * ephy_password_info_new:
+ * @host: a host name
+ * @username: a user name
+ * @password: a password, or NULL
+ *
+ * Generates a new #EphyPasswordInfo.
+ *
+ * Return value: the new password info.
+ **/
+EphyPasswordInfo *
+ephy_password_info_new (const char *host,
+			const char *username,
+			const char *password)
+{
+	EphyPasswordInfo *info = g_new0 (EphyPasswordInfo, 1);
+
+	info->host = g_strdup (host);
+	info->username = g_strdup (username);
+	info->password = g_strdup (password);
+
+	return info;
+}
+
+/**
+ * ephy_password_info_copy:
+ * @info: a #EphyPasswordInfo
+ *
+ * Return value: a copy of @info
+ **/
+EphyPasswordInfo *
+ephy_password_info_copy (EphyPasswordInfo *info)
+{
+	EphyPasswordInfo *copy = g_new0 (EphyPasswordInfo, 1);
+
+	copy->host = g_strdup (info->host);
+	copy->username = g_strdup (info->username);
+	copy->password = g_strdup (info->password);
+
+	return copy;
+}
+
+/**
+ * ephy_password_info_free:
+ * @info:
+ *
+ * Frees @info.
+ **/
+void
+ephy_password_info_free (EphyPasswordInfo *info)
+{
+	if (info != NULL)
+	{
+		g_free (info->host);
+		g_free (info->username);
+		g_free (info->password);
+		g_free (info);
+	}
+}
+
+/* EphyPasswordManager */
+
+GType
+ephy_password_manager_get_type (void)
+{
+       static GType type = 0;
+
+	if (type == 0)
+	{
+		static const GTypeInfo our_info =
+		{
+			sizeof (EphyPasswordManagerIFace),
+			NULL,
+			NULL,
+		};
+		
+		type = g_type_register_static (G_TYPE_INTERFACE,
+					       "EphyPasswordManager",
+					       &our_info,
+					       (GTypeFlags) 0);
+	}
+
+	return type;
+}
+
+/**
+ * ephy_password_manager_add:
+ * @manager: the #EphyPasswordManager
+ * @info: a #EphyPasswordInfo
+ * 
+ * Adds the password entry @info to the the passwords database.
+ **/
+void
+ephy_password_manager_add (EphyPasswordManager *manager,
+			   EphyPasswordInfo *info)
+{
+	EphyPasswordManagerIFace *iface = EPHY_PASSWORD_MANAGER_GET_IFACE (manager);
+	iface->add (manager, info);
+}
+
+/**
+ * ephy_password_manager_remove:
+ * @manager: the #EphyPasswordManager
+ * @info: a #EphyPasswordInfo
+ * 
+ * Removes the password entry @info from the passwords database.
+ **/
+void
+ephy_password_manager_remove (EphyPasswordManager *manager,
+			      EphyPasswordInfo *info)
+{
+	EphyPasswordManagerIFace *iface = EPHY_PASSWORD_MANAGER_GET_IFACE (manager);
+	iface->remove (manager, info);
+}
+
+/**
+ * ephy_password_manager_list:
+ * @manager: the #EphyPasswordManager
+ * 
+ * Lists all password entries in the passwords database.
+ * 
+ * Return value: the list of password entries
+ **/
+GList *
+ephy_password_manager_list (EphyPasswordManager *manager)
+{
+	EphyPasswordManagerIFace *iface = EPHY_PASSWORD_MANAGER_GET_IFACE (manager);
+	return iface->list (manager);
+}
diff --git a/embed/ephy-password-manager.h b/embed/ephy-password-manager.h
new file mode 100644
index 000000000..34d33b0f9
--- /dev/null
+++ b/embed/ephy-password-manager.h
@@ -0,0 +1,87 @@
+/*
+ *  Copyright (C) 2003 Marco Pesenti Gritti
+ *  Copyright (C) 2003 Christian Persch
+ *
+ *  This program is free software; you can redistribute it and/or modify
+ *  it under the terms of the GNU General Public License as published by
+ *  the Free Software Foundation; either version 2, or (at your option)
+ *  any later version.
+ *
+ *  This program 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 General Public License for more details.
+ *
+ *  You should have received a copy of the GNU General Public License
+ *  along with this program; if not, write to the Free Software
+ *  Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
+ *
+ *  $Id$
+ */
+
+#ifndef EPHY_PASSWORD_MANAGER_H
+#define EPHY_PASSWORD_MANAGER_H
+
+#include <glib-object.h>
+#include <glib.h>
+
+G_BEGIN_DECLS
+
+#define EPHY_TYPE_PASSWORD_MANAGER		(ephy_password_manager_get_type ())
+#define EPHY_PASSWORD_MANAGER(o)		(G_TYPE_CHECK_INSTANCE_CAST ((o), EPHY_TYPE_PASSWORD_MANAGER, EphyPasswordManager))
+#define EPHY_PASSWORD_MANAGER_CLASS(k)		(G_TYPE_CHECK_CLASS_CAST((k), EPHY_TYPE_PASSWORD_MANAGER, EphyPasswordManagerClass))
+#define EPHY_IS_PASSWORD_MANAGER(o)		(G_TYPE_CHECK_INSTANCE_TYPE ((o), EPHY_TYPE_PASSWORD_MANAGER))
+#define EPHY_IS_PASSWORD_MANAGER_CLASS(k)	(G_TYPE_CHECK_CLASS_TYPE ((k), EPHY_TYPE_PASSWORD_MANAGER))
+#define EPHY_PASSWORD_MANAGER_GET_IFACE(inst)	(G_TYPE_INSTANCE_GET_INTERFACE ((inst), EPHY_TYPE_PASSWORD_MANAGER, EphyPasswordManagerIFace))
+
+#define EPHY_TYPE_PASSWORD_INFO			(ephy_password_info_get_type ())
+
+typedef struct EphyPasswordManager	EphyPasswordManager;
+typedef struct EphyPasswordManagerIFace	EphyPasswordManagerIFace;
+
+typedef struct
+{
+	char *host;
+	char *username;
+	char *password;
+} EphyPasswordInfo;
+
+struct EphyPasswordManagerIFace
+{
+	GTypeInterface base_iface;
+
+	/* Methods */
+	void	(* add)		(EphyPasswordManager *manager,
+				 EphyPasswordInfo *info);
+	void	(* remove)	(EphyPasswordManager *manager,
+				 EphyPasswordInfo *info);
+	GList *	(* list)	(EphyPasswordManager *manager);
+};
+
+/* EphyPasswordInfo */
+
+GType			ephy_password_info_get_type	(void);
+
+EphyPasswordInfo       *ephy_password_info_new		(const char *host,
+							 const char *username,
+							 const char *password);
+
+EphyPasswordInfo       *ephy_password_info_copy		(EphyPasswordInfo *info);
+
+void			ephy_password_info_free		(EphyPasswordInfo *info);
+
+/* EphyPasswordManager */
+
+GType 		ephy_password_manager_get_type	(void);
+
+void		ephy_password_manager_add		(EphyPasswordManager *manager,
+							 EphyPasswordInfo *info);
+
+void		ephy_password_manager_remove		(EphyPasswordManager *manager,
+							 EphyPasswordInfo *info);
+
+GList *		ephy_password_manager_list		(EphyPasswordManager *manager);
+
+G_END_DECLS
+
+#endif
diff --git a/embed/ephy-permission-manager.c b/embed/ephy-permission-manager.c
new file mode 100644
index 000000000..878ead738
--- /dev/null
+++ b/embed/ephy-permission-manager.c
@@ -0,0 +1,295 @@
+/*
+ *  Copyright (C) 2003 Marco Pesenti Gritti
+ *  Copyright (C) 2003 Christian Persch
+ *
+ *  This program is free software; you can redistribute it and/or modify
+ *  it under the terms of the GNU General Public License as published by
+ *  the Free Software Foundation; either version 2, or (at your option)
+ *  any later version.
+ *
+ *  This program 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 General Public License for more details.
+ *
+ *  You should have received a copy of the GNU General Public License
+ *  along with this program; if not, write to the Free Software
+ *  Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
+ *
+ *  $Id$
+ */
+
+#ifdef HAVE_CONFIG_H
+#include "config.h"
+#endif
+
+#include "ephy-permission-manager.h"
+#include "ephy-marshal.h"
+#include "ephy-debug.h"
+
+/* EphyPermissionInfo */
+
+GType
+ephy_permission_info_get_type (void)
+{
+	static GType type = 0;
+
+	if (type == 0)
+	{
+		type = g_boxed_type_register_static ("EphyPermissionInfo",
+						     (GBoxedCopyFunc) ephy_permission_info_copy,
+						     (GBoxedFreeFunc) ephy_permission_info_free);
+	}
+
+	return type;
+}
+
+/**
+ * ephy_permission_info_new:
+ * @host: a host name
+ * @type: a #EphyPermissionType
+ * @allowed: whether @host should be allowed to do what @type specifies
+ *
+ * Return value: the new #EphyPermissionInfo
+ **/
+EphyPermissionInfo *
+ephy_permission_info_new (const char *host,
+			  EphyPermissionType type,
+			  gboolean allowed)
+{
+	EphyPermissionInfo *info = g_new0 (EphyPermissionInfo, 1);
+
+	info->host = g_strdup (host);
+	info->type = type;
+	info->allowed = allowed;
+
+	return info;
+}
+
+/**
+ * ephy_permission_info_copy:
+ * @info: a #EphyPermissionInfo
+ *
+ * Return value: a copy of @info
+ **/
+EphyPermissionInfo *
+ephy_permission_info_copy (EphyPermissionInfo *info)
+{
+	EphyPermissionInfo *copy = g_new0 (EphyPermissionInfo, 1);
+
+	copy->host = g_strdup (info->host);
+	copy->type = info->type;
+	copy->allowed = info->allowed;
+
+	return copy;
+}
+
+/**
+ * ephy_permission_info_free:
+ * @info: a #EphyPermissionInfo
+ *
+ * Frees @info.
+ **/
+void
+ephy_permission_info_free (EphyPermissionInfo *info)
+{
+	if (info != NULL)
+	{
+		g_free (info->host);
+		g_free (info);
+	}
+}
+
+/* EphyPermissionManager */
+
+static void ephy_permission_manager_base_init (gpointer g_class);
+
+GType
+ephy_permission_manager_get_type (void)
+{
+       static GType type = 0;
+
+	if (type == 0)
+	{
+		static const GTypeInfo our_info =
+		{
+		sizeof (EphyPermissionManagerIFace),
+		ephy_permission_manager_base_init,
+		NULL,
+		};
+		
+		type = g_type_register_static (G_TYPE_INTERFACE,
+					       "EphyPermissionManager",
+					       &our_info,
+					       (GTypeFlags) 0);
+	}
+
+	return type;
+}
+
+static void
+ephy_permission_manager_base_init (gpointer g_class)
+{
+	static gboolean initialised = FALSE;
+
+	if (initialised == FALSE)
+	{
+	/**
+	 * EphyPermissionManager::added
+	 * @manager: the #EphyPermissionManager
+	 * @info: a #EphyPermissionInfo
+	 *
+	 * The added signal is emitted when a permission entry has been added.
+	 */
+	g_signal_new ("added",
+		      EPHY_TYPE_PERMISSION_MANAGER,
+		      G_SIGNAL_RUN_FIRST,
+		      G_STRUCT_OFFSET (EphyPermissionManagerIFace, added),
+		      NULL, NULL,
+		      g_cclosure_marshal_VOID__BOXED,
+		      G_TYPE_NONE,
+		      1,
+		      EPHY_TYPE_PERMISSION_INFO);
+
+	/**
+	 * EphyPermissionManager::changed
+	 * @manager: the #EphyPermissionManager
+	 * @info: a #EphyPermissionInfo
+	 *
+	 * The changed signal is emitted when a permission entry has been
+	 * changed.
+	 */
+	g_signal_new ("changed",
+		      EPHY_TYPE_PERMISSION_MANAGER,
+		      G_SIGNAL_RUN_FIRST,
+		      G_STRUCT_OFFSET (EphyPermissionManagerIFace, changed),
+		      NULL, NULL,
+		      g_cclosure_marshal_VOID__BOXED,
+		      G_TYPE_NONE,
+		      1,
+		      EPHY_TYPE_PERMISSION_INFO);
+
+	/**
+	 * EphyPermissionManager::deleted
+	 * @manager: the #EphyPermissionManager
+	 * @info: a #EphyPermissionInfo
+	 *
+	 * The deleted signal is emitted when a permission entry has been
+	 * deleted.
+	 */
+	g_signal_new ("deleted",
+		      EPHY_TYPE_PERMISSION_MANAGER,
+		      G_SIGNAL_RUN_FIRST,
+		      G_STRUCT_OFFSET (EphyPermissionManagerIFace, deleted),
+		      NULL, NULL,
+		      g_cclosure_marshal_VOID__BOXED,
+		      G_TYPE_NONE,
+		      1,
+		      EPHY_TYPE_PERMISSION_INFO);
+
+	/**
+	 * EphyPermissionManager::cleared
+	 * @manager: the #EphyPermissionManager
+	 *
+	 * The cleared signal is emitted when the permissions database has
+	 * been cleared.
+	 */
+	g_signal_new ("cleared",
+		      EPHY_TYPE_PERMISSION_MANAGER,
+		      G_SIGNAL_RUN_FIRST,
+		      G_STRUCT_OFFSET (EphyPermissionManagerIFace, cleared),
+		      NULL, NULL,
+		      g_cclosure_marshal_VOID__VOID,
+		      G_TYPE_NONE,
+		      0);
+
+	initialised = TRUE;
+	}
+}
+
+/**
+ * ephy_permission_manager_add:
+ * @manager: the #EphyPermissionManager
+ * @host: a host name
+ * @type: a #EphyPermissionType
+ * @allow: the permission itself
+ * 
+ * Adds the permission @allow of type @type for host @host to the permissions
+ * database.
+ **/
+void
+ephy_permission_manager_add (EphyPermissionManager *manager,
+			     const char *host,
+			     EphyPermissionType type,
+			     gboolean allow)
+{
+	EphyPermissionManagerIFace *iface = EPHY_PERMISSION_MANAGER_GET_IFACE (manager);
+	iface->add (manager, host, type, allow);
+}
+
+/**
+ * ephy_permission_manager_remove:
+ * @manager: the #EphyPermissionManager
+ * @host: a host name
+ * @type: a #EphyPermissionType
+ * 
+ * Removes the permission of type @type for host @host from the permissions
+ * database.
+ **/
+void
+ephy_permission_manager_remove (EphyPermissionManager *manager,
+				const char *host,
+				EphyPermissionType type)
+{
+	EphyPermissionManagerIFace *iface = EPHY_PERMISSION_MANAGER_GET_IFACE (manager);
+	iface->remove (manager, host, type);
+}
+
+/**
+ * ephy_permission_manager_clear:
+ * @manager: the #EphyPermissionManager
+ * 
+ * Clears the permissions database.
+ **/
+void
+ephy_permission_manager_clear (EphyPermissionManager *manager)
+{
+	EphyPermissionManagerIFace *iface = EPHY_PERMISSION_MANAGER_GET_IFACE (manager);
+	iface->clear (manager);
+}
+
+/**
+ * ephy_permission_manager_test:
+ * @manager: the #EphyPermissionManager
+ * @host: a host name
+ * @type: a #EphyPermissionType
+ * 
+ * Tests whether the host @host is allowed to do the action specified by @type.
+ * 
+ * Return value: TRUE if allowed
+ **/
+gboolean
+ephy_permission_manager_test (EphyPermissionManager *manager,
+			      const char *host,
+			      EphyPermissionType type)
+{
+	EphyPermissionManagerIFace *iface = EPHY_PERMISSION_MANAGER_GET_IFACE (manager);
+	return iface->test (manager, host, type);
+}
+
+/**
+ * ephy_permission_manager_list:
+ * @manager: the #EphyPermissionManager
+ * @type: a #EphyPermissionType
+ * 
+ * Lists all permission entries of type @type in the permissions database.
+ * 
+ * Return value: the list of permission entries
+ **/
+GList *
+ephy_permission_manager_list (EphyPermissionManager *manager,
+			      EphyPermissionType type)
+{
+	EphyPermissionManagerIFace *iface = EPHY_PERMISSION_MANAGER_GET_IFACE (manager);
+	return iface->list (manager, type);
+}
diff --git a/embed/ephy-permission-manager.h b/embed/ephy-permission-manager.h
new file mode 100644
index 000000000..e8e2a5fb2
--- /dev/null
+++ b/embed/ephy-permission-manager.h
@@ -0,0 +1,121 @@
+/*
+ *  Copyright (C) 2003 Marco Pesenti Gritti
+ *  Copyright (C) 2003 Christian Persch
+ *
+ *  This program is free software; you can redistribute it and/or modify
+ *  it under the terms of the GNU General Public License as published by
+ *  the Free Software Foundation; either version 2, or (at your option)
+ *  any later version.
+ *
+ *  This program 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 General Public License for more details.
+ *
+ *  You should have received a copy of the GNU General Public License
+ *  along with this program; if not, write to the Free Software
+ *  Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
+ *
+ *  $Id$
+ */
+
+#ifndef EPHY_PERMISSION_MANAGER_H
+#define EPHY_PERMISSION_MANAGER_H
+
+#include <glib-object.h>
+#include <glib.h>
+
+G_BEGIN_DECLS
+
+#define EPHY_TYPE_PERMISSION_MANAGER		(ephy_permission_manager_get_type ())
+#define EPHY_PERMISSION_MANAGER(o)		(G_TYPE_CHECK_INSTANCE_CAST ((o), EPHY_TYPE_PERMISSION_MANAGER, EphyPermissionManager))
+#define EPHY_PERMISSION_MANAGER_CLASS(k)	(G_TYPE_CHECK_CLASS_CAST((k), EPHY_TYPE_PERMISSION_MANAGER, EphyPermissionManagerClass))
+#define EPHY_IS_PERMISSION_MANAGER(o)		(G_TYPE_CHECK_INSTANCE_TYPE ((o), EPHY_TYPE_PERMISSION_MANAGER))
+#define EPHY_IS_PERMISSION_MANAGER_CLASS(k)	(G_TYPE_CHECK_CLASS_TYPE ((k), EPHY_TYPE_PERMISSION_MANAGER))
+#define EPHY_PERMISSION_MANAGER_GET_IFACE(inst)	(G_TYPE_INSTANCE_GET_INTERFACE ((inst), EPHY_TYPE_PERMISSION_MANAGER, EphyPermissionManagerIFace))
+
+#define EPHY_TYPE_PERMISSION_INFO		(ephy_permission_info_get_type ())
+
+typedef struct EphyPermissionManager		EphyPermissionManager;
+typedef struct EphyPermissionManagerIFace	EphyPermissionManagerIFace;
+
+typedef enum
+{
+	EPT_COOKIE,
+	EPT_IMAGE,
+	EPT_PASSWORD
+} EphyPermissionType;
+
+typedef struct
+{
+	char *host;
+	EphyPermissionType type;
+	gboolean allowed;
+} EphyPermissionInfo;
+
+struct EphyPermissionManagerIFace
+{
+	GTypeInterface base_iface;
+
+	/* Signals */
+	void	(* added)	(EphyPermissionManager *manager,
+				 EphyPermissionInfo *info);
+	void	(* changed)	(EphyPermissionManager *manager,
+				 EphyPermissionInfo *info);
+	void	(* deleted)	(EphyPermissionManager *manager,
+				 EphyPermissionInfo *info);
+	void	(* cleared)	(EphyPermissionManager *manager);
+
+	/* Methods */
+	void		(* add)		(EphyPermissionManager *manager,
+					 const char *host,
+					 EphyPermissionType type,
+					 gboolean allow);
+	void		(* remove)	(EphyPermissionManager *manager,
+					 const char *host,
+					 EphyPermissionType type);
+	void		(* clear)	(EphyPermissionManager *manager);
+	gboolean	(* test)	(EphyPermissionManager *manager,
+					 const char *host,
+					 EphyPermissionType type);
+	GList *		(* list)	(EphyPermissionManager *manager,
+					 EphyPermissionType type);
+};
+
+/* EphyPermissionInfo */
+
+GType			ephy_permission_info_get_type	(void);
+
+EphyPermissionInfo     *ephy_permission_info_new	(const char *host,
+							 EphyPermissionType type,
+							 gboolean allowed);
+
+EphyPermissionInfo     *ephy_permission_info_copy	(EphyPermissionInfo *info);
+
+void			ephy_permission_info_free	(EphyPermissionInfo *info);
+
+/* EphyPermissionManager */
+
+GType 		ephy_permission_manager_get_type	(void);
+
+void		ephy_permission_manager_add		(EphyPermissionManager *manager,
+							 const char *host,
+							 EphyPermissionType type,
+							 gboolean allow);
+
+void		ephy_permission_manager_remove		(EphyPermissionManager *manager,
+							 const char *host,
+							 EphyPermissionType type);
+
+void		ephy_permission_manager_clear		(EphyPermissionManager *manager);
+
+gboolean	ephy_permission_manager_test		(EphyPermissionManager *manager,
+							 const char *host,
+							 EphyPermissionType type);
+
+GList *		ephy_permission_manager_list		(EphyPermissionManager *manager,
+							 EphyPermissionType type);
+
+G_END_DECLS
+
+#endif
diff --git a/embed/mozilla/mozilla-embed-single.cpp b/embed/mozilla/mozilla-embed-single.cpp
index 28b1a3b23..4277dfc0a 100644
--- a/embed/mozilla/mozilla-embed-single.cpp
+++ b/embed/mozilla/mozilla-embed-single.cpp
@@ -1,5 +1,6 @@
 /*
  *  Copyright (C) 2000-2003 Marco Pesenti Gritti
+ *  Copyright (C) 2003 Christian Persch
  *
  *  This program is free software; you can redistribute it and/or modify
  *  it under the terms of the GNU General Public License as published by
@@ -22,11 +23,16 @@
 #include "config.h"
 #endif
 
+#include "mozilla-embed-single.h"
+
+#include "ephy-cookie-manager.h"
+#include "ephy-password-manager.h"
+#include "ephy-permission-manager.h"
+
 #include "glib.h"
 #include "ephy-debug.h"
 #include "gtkmozembed.h"
 #include "mozilla-embed.h"
-#include "mozilla-embed-single.h"
 #include "ephy-file-helpers.h"
 #include "mozilla-notifiers.h"
 #include "ephy-langs.h"
@@ -34,7 +40,6 @@
 #include "ephy-embed-prefs.h"
 #include "MozRegisterComponents.h"
 
-#include <time.h>
 #include <glib/gi18n.h>
 #include <libgnomevfs/gnome-vfs-utils.h>
 #include <nsICacheService.h>
@@ -48,7 +53,9 @@
 #include <nsIFontEnumerator.h>
 #include <nsISupportsPrimitives.h>
 #include <nsReadableUtils.h>
+#include <nsICookie2.h>
 #include <nsICookieManager.h>
+#include <nsIPassword.h>
 #include <nsIPasswordManager.h>
 #include <nsIPassword.h>
 #include <nsICookie.h>
@@ -58,8 +65,12 @@
 #include <nsCCookieManager.h>
 #endif
 #include <nsCPasswordManager.h>
+#include <nsIPermission.h>
+#include <nsIPermissionManager.h>
 #include <nsString.h>
 #include <nsILocalFile.h>
+#include <nsIURI.h>
+#include <nsNetUtil.h>
 
 // FIXME: For setting the locale. hopefully gtkmozembed will do itself soon
 #include <nsIChromeRegistry.h>
@@ -70,13 +81,6 @@
 #define MOZILLA_PROFILE_FILE "prefs.js"
 #define DEFAULT_PROFILE_FILE SHARE_DIR"/default-prefs.js"
 
-static void
-mozilla_embed_single_class_init (MozillaEmbedSingleClass *klass);
-static void
-mozilla_embed_single_init (MozillaEmbedSingle *ges);
-static void
-mozilla_embed_single_finalize (GObject *object);
-
 #define MOZILLA_EMBED_SINGLE_GET_PRIVATE(object)(G_TYPE_INSTANCE_GET_PRIVATE ((object), MOZILLA_TYPE_EMBED_SINGLE, MozillaEmbedSinglePrivate))
 
 struct MozillaEmbedSinglePrivate
@@ -87,14 +91,21 @@ struct MozillaEmbedSinglePrivate
 	GtkWidget *theme_window;
 };
 
+static void mozilla_embed_single_class_init	(MozillaEmbedSingleClass *klass);
+static void ephy_embed_single_iface_init	(EphyEmbedSingleClass *iface);
+static void ephy_cookie_manager_iface_init	(EphyCookieManagerIFace *iface);
+static void ephy_password_manager_iface_init	(EphyPasswordManagerIFace *iface);
+static void ephy_permission_manager_iface_init	(EphyPermissionManagerIFace *iface);
+static void mozilla_embed_single_init		(MozillaEmbedSingle *ges);
+
 static GObjectClass *parent_class = NULL;
 
 GType
 mozilla_embed_single_get_type (void)
 {
-       static GType mozilla_embed_single_type = 0;
+       static GType type = 0;
 
-        if (mozilla_embed_single_type == 0)
+        if (type == 0)
         {
                 static const GTypeInfo our_info =
                 {
@@ -109,12 +120,57 @@ mozilla_embed_single_get_type (void)
                         (GInstanceInitFunc) mozilla_embed_single_init
                 };
 
-                mozilla_embed_single_type = g_type_register_static (EPHY_TYPE_EMBED_SINGLE,
-								   "MozillaEmbedSingle",
-								   &our_info, (GTypeFlags)0);
-        }
+		static const GInterfaceInfo embed_single_info =
+		{
+			(GInterfaceInitFunc) ephy_embed_single_iface_init,
+			NULL,
+			NULL
+		};
+
+		static const GInterfaceInfo cookie_manager_info =
+		{
+			(GInterfaceInitFunc) ephy_cookie_manager_iface_init,
+			NULL,
+			NULL
+		};
+
+		static const GInterfaceInfo password_manager_info =
+		{
+			(GInterfaceInitFunc) ephy_password_manager_iface_init,
+			NULL,
+			NULL
+		};
+
+		static const GInterfaceInfo permission_manager_info =
+		{
+			(GInterfaceInitFunc) ephy_permission_manager_iface_init,
+			NULL,
+			NULL
+		};
+
+		type = g_type_register_static (G_TYPE_OBJECT,
+					       "MozillaEmbedSingle",
+					       &our_info,
+					       (GTypeFlags)0);
+
+		g_type_add_interface_static (type,
+					     EPHY_TYPE_EMBED_SINGLE,
+					     &embed_single_info);
+
+		g_type_add_interface_static (type,
+					     EPHY_TYPE_COOKIE_MANAGER,
+					     &cookie_manager_info);
+
+		g_type_add_interface_static (type,
+					     EPHY_TYPE_PASSWORD_MANAGER,
+					     &password_manager_info);
+
+		g_type_add_interface_static (type,
+					     EPHY_TYPE_PERMISSION_MANAGER,
+					     &permission_manager_info);
+	}
 
-        return mozilla_embed_single_type;
+        return type;
 }
 
 EphyEmbedSingle *
@@ -495,8 +551,9 @@ static void
 impl_load_proxy_autoconf (EphyEmbedSingle *shell,
 			  const char* url)
 {
-	nsresult rv;
+	g_assert (url != NULL);
 
+	nsresult rv;
         nsCOMPtr<nsIProtocolProxyService> pps =
                 do_GetService ("@mozilla.org/network/protocol-proxy-service;1",
                                &rv);
@@ -537,174 +594,376 @@ impl_get_font_list (EphyEmbedSingle *shell,
 	return g_list_reverse (l);
 }
 
+static EphyCookie *
+mozilla_cookie_to_ephy_cookie (nsICookie2 *keks)
+{
+	EphyCookie *cookie;
+
+	cookie = ephy_cookie_new ();
+
+	nsCAutoString transfer;
+
+	keks->GetHost (transfer);
+	cookie->domain = g_strdup (transfer.get());
+	keks->GetName (transfer);
+	cookie->name = g_strdup (transfer.get());
+	keks->GetValue (transfer);
+	cookie->value = g_strdup (transfer.get());
+	keks->GetPath (transfer);
+	cookie->path = g_strdup (transfer.get());
+
+	PRBool isSecure;
+	keks->GetIsSecure (&isSecure);
+	cookie->is_secure = isSecure != PR_FALSE;
+
+	PRUint64 dateTime;
+	keks->GetExpires (&dateTime);
+	cookie->expires = dateTime;
+
+	PRInt64 expiry;
+	keks->GetExpiry (&expiry);
+	cookie->real_expires = expiry;
+
+	nsCookieStatus status;
+	keks->GetStatus (&status);
+	cookie->p3p_state = status;
+
+	nsCookiePolicy policy;
+	keks->GetPolicy (&policy);
+	cookie->p3p_policy = policy;
+
+	PRBool isSession;
+	keks->GetIsSession (&isSession);
+	cookie->is_session = isSession != PR_FALSE;
+
+	return cookie;
+}
+
 static GList *
-impl_list_cookies (EphyEmbedSingle *shell)
+impl_list_cookies (EphyCookieManager *manager)
 {
-        nsresult result;
+	nsresult result;
 	GList *cookies = NULL;
-
-        nsCOMPtr<nsICookieManager> cookieManager = 
-                        do_CreateInstance (NS_COOKIEMANAGER_CONTRACTID);
-        nsCOMPtr<nsISimpleEnumerator> cookieEnumerator;
-        result = 
-            cookieManager->GetEnumerator (getter_AddRefs(cookieEnumerator));
-        if (NS_FAILED(result)) return NULL;
 	
-        PRBool enumResult;
-        for (cookieEnumerator->HasMoreElements(&enumResult) ;
-             enumResult == PR_TRUE ;
-             cookieEnumerator->HasMoreElements(&enumResult))
-        {
-                CookieInfo *c;
-        
-                nsCOMPtr<nsICookie> nsCookie;
-                result = cookieEnumerator->GetNext (getter_AddRefs(nsCookie));
-                if (NS_FAILED(result)) return NULL;
-
-                c = g_new0 (CookieInfo, 1);
-
-                nsCAutoString transfer;
-
-                nsCookie->GetHost (transfer);
-                c->domain = g_strdup (transfer.get());
-                nsCookie->GetName (transfer);
-                c->name = g_strdup (transfer.get());
-                nsCookie->GetValue (transfer);
-                c->value = g_strdup (transfer.get());
-                nsCookie->GetPath (transfer);
-                c->path = g_strdup (transfer.get());
-
-		PRBool isSecure;
-                nsCookie->GetIsSecure (&isSecure);
-                if (isSecure == PR_TRUE) 
-                        c->secure = g_strdup (_("Yes"));
-                else 
-                        c->secure = g_strdup (_("No"));
-
-                PRUint64 dateTime;
-                nsCookie->GetExpires (&dateTime);
-		if(dateTime == 0)
-			c->expire = g_strdup (_("End of current session"));
-		else
-	                c->expire = g_strdup_printf ("%s",ctime((time_t*)&dateTime));
-                
-                cookies = g_list_prepend (cookies, c);
-        }       
-
-	return g_list_reverse (cookies);
+	nsCOMPtr<nsICookieManager> cookieManager = 
+			do_CreateInstance (NS_COOKIEMANAGER_CONTRACTID);
+	nsCOMPtr<nsISimpleEnumerator> cookieEnumerator;
+	result = cookieManager->GetEnumerator (getter_AddRefs(cookieEnumerator));
+	if (NS_FAILED(result) || !cookieEnumerator) return NULL;
+	
+	PRBool enumResult;
+	for (cookieEnumerator->HasMoreElements(&enumResult) ;
+	     enumResult == PR_TRUE ;
+	     cookieEnumerator->HasMoreElements(&enumResult))
+	{
+		nsCOMPtr<nsICookie> keks;
+		result = cookieEnumerator->GetNext (getter_AddRefs(keks));
+		if (NS_FAILED (result) || !keks) continue;
+
+		nsCOMPtr<nsICookie2> keks2 = do_QueryInterface (keks, &result);
+		if (NS_FAILED (result) || !keks2) continue;
+
+		EphyCookie *cookie = mozilla_cookie_to_ephy_cookie (keks2);
+		if (cookie != NULL)
+		{			
+			cookies = g_list_prepend (cookies, cookie);
+		}
+	}       
+	
+	return cookies;
 }
 
 static void
-impl_remove_cookies (EphyEmbedSingle *shell,
-		     GList *cookies)
+impl_remove_cookie (EphyCookieManager *manager,
+		    EphyCookie *cookie)
 {
-	nsresult result;
-	GList *cl;
-        nsCOMPtr<nsICookieManager> cookieManager =
-                        do_CreateInstance (NS_COOKIEMANAGER_CONTRACTID);
-
-	for (cl = cookies; cl != NULL; cl = cl->next)
-        {
-                CookieInfo *c = (CookieInfo *)cl->data;
+	nsresult rv;
+	nsCOMPtr<nsICookieManager> cookieManager =
+		do_CreateInstance (NS_COOKIEMANAGER_CONTRACTID, &rv);
+	if (NS_FAILED (rv) || !cookieManager) return;
+
+	cookieManager->Remove (nsDependentCString(cookie->domain),
+			       nsDependentCString(cookie->name),
+			       nsDependentCString(cookie->path),
+			       PR_FALSE /* block */);
+}
 
-                result = cookieManager->Remove (nsDependentCString(c->domain),
-                                                nsDependentCString(c->name),
-                                                nsDependentCString(c->path),
-                                                PR_FALSE);
-        };
+static void
+impl_clear_cookies (EphyCookieManager *manager)
+{
+	nsresult rv;
+	nsCOMPtr<nsICookieManager> cookieManager =
+		do_CreateInstance (NS_COOKIEMANAGER_CONTRACTID, &rv);
+	if (NS_SUCCEEDED (rv))
+	{
+		cookieManager->RemoveAll ();
+	}
 }
 	
 static GList *
-impl_list_passwords (EphyEmbedSingle *shell,
-		     PasswordType type)
+impl_list_passwords (EphyPasswordManager *manager)
 {
-        nsresult result = NS_ERROR_FAILURE;
 	GList *passwords = NULL;
 
-        nsCOMPtr<nsIPasswordManager> passwordManager =
-                        do_CreateInstance (NS_PASSWORDMANAGER_CONTRACTID);
-        nsCOMPtr<nsISimpleEnumerator> passwordEnumerator;
-        if (type == PASSWORD_PASSWORD)
-                result = passwordManager->GetEnumerator 
-                                (getter_AddRefs(passwordEnumerator));
-        else if (type == PASSWORD_REJECT)
-                result = passwordManager->GetRejectEnumerator 
-                                (getter_AddRefs(passwordEnumerator));
-        if (NS_FAILED(result)) return NULL;      
-
-        PRBool enumResult;
-        for (passwordEnumerator->HasMoreElements(&enumResult) ;
-             enumResult == PR_TRUE ;
-             passwordEnumerator->HasMoreElements(&enumResult))
-        {
-                nsCOMPtr<nsIPassword> nsPassword;
-                result = passwordEnumerator->GetNext 
-                                        (getter_AddRefs(nsPassword));
-                if (NS_FAILED(result)) return NULL;
+	nsresult result;
+	nsCOMPtr<nsIPasswordManager> passwordManager =
+			do_CreateInstance (NS_PASSWORDMANAGER_CONTRACTID);
+	if (!passwordManager) return NULL;
+
+	nsCOMPtr<nsISimpleEnumerator> passwordEnumerator;
+	result = passwordManager->GetEnumerator 
+				(getter_AddRefs(passwordEnumerator));
+	if (NS_FAILED(result) || !passwordEnumerator) return NULL;      
+
+	PRBool enumResult;
+	for (passwordEnumerator->HasMoreElements(&enumResult) ;
+	     enumResult == PR_TRUE ;
+	     passwordEnumerator->HasMoreElements(&enumResult))
+	{
+		nsCOMPtr<nsIPassword> nsPassword;
+		result = passwordEnumerator->GetNext 
+					(getter_AddRefs(nsPassword));
+		if (NS_FAILED(result) || !nsPassword) continue;
 
-                PasswordInfo *p = g_new0 (PasswordInfo, 1);
+		EphyPasswordInfo *p = g_new0 (EphyPasswordInfo, 1);
 
-                nsCAutoString transfer;
-                nsPassword->GetHost (transfer);
-                p->host = g_strdup (transfer.get());
+		nsCAutoString transfer;
+		nsPassword->GetHost (transfer);
+		p->host = g_strdup (transfer.get());
 
-                if (type == PASSWORD_PASSWORD)
-                {
-                        nsAutoString unicodeName;
-                        nsPassword->GetUser (unicodeName);
-                        p->username = g_strdup(NS_ConvertUCS2toUTF8(unicodeName).get());
-                }
+		nsAutoString unicodeName;
+		nsPassword->GetUser (unicodeName);
+		p->username = g_strdup(NS_ConvertUCS2toUTF8(unicodeName).get());
 
-		passwords = g_list_prepend (passwords, p);
-        }       
+		p->password = NULL;
 
-	return g_list_reverse (passwords);
+		passwords = g_list_prepend (passwords, p);
+	}       
+	
+	return passwords;
 }
 
 static void
-impl_remove_passwords (EphyEmbedSingle *shell,
-		       GList *passwords, 
-		       PasswordType type)
+impl_remove_password (EphyPasswordManager *manager,
+		      EphyPasswordInfo *info)
 {
-	nsresult result = NS_ERROR_FAILURE;
-        nsCOMPtr<nsIPasswordManager> passwordManager =
+        nsCOMPtr<nsIPasswordManager> pm =
                         do_CreateInstance (NS_PASSWORDMANAGER_CONTRACTID);
-	GList *l;
+	if (pm)
+	{
+		pm->RemoveUser (nsDependentCString(info->host),
+				NS_ConvertUTF8toUCS2(nsDependentCString(info->username)));
+	}
+}
 
-	for (l = passwords; l != NULL; l = l->next)
-        {
-                PasswordInfo *p = (PasswordInfo *)l->data;
-                if (type == PASSWORD_PASSWORD)
-                {
-                        result = passwordManager->RemoveUser (NS_LITERAL_CSTRING(p->host),
-                                                              NS_ConvertUTF8toUCS2(nsDependentCString(p->username)));
-                }
-                else if (type == PASSWORD_REJECT)
-                {
-                        result = passwordManager->RemoveReject
-                                        (nsDependentCString(p->host));
-                };
-        };
+static const char *permission_type_string [] =
+{
+	"cookie",
+	"image",
+	"popup"
+};
+
+void
+impl_permission_manager_add (EphyPermissionManager *manager,
+			     const char *host,
+			     EphyPermissionType type,
+			     gboolean allow)
+{
+	nsresult result;
+        nsCOMPtr<nsIPermissionManager> pm
+		(do_CreateInstance (NS_PERMISSIONMANAGER_CONTRACTID, &result));
+	if (NS_FAILED (result) || !pm) return;
+
+	nsCOMPtr<nsIURI> uri;
+        result = NS_NewURI(getter_AddRefs(uri), host);
+        if (NS_FAILED(result) || !uri) return;
+
+	pm->Add (uri,
+#if MOZILLA_SNAPSHOT >= 10
+		 permission_type_string [type],
+#else
+		 type,
+#endif
+		 allow ? (PRUint32) nsIPermissionManager::ALLOW_ACTION :
+			 (PRUint32) nsIPermissionManager::DENY_ACTION);
+}
+
+void
+impl_permission_manager_remove (EphyPermissionManager *manager,
+				const char *host,
+				EphyPermissionType type)
+{
+	nsresult result;
+        nsCOMPtr<nsIPermissionManager> pm
+		(do_CreateInstance (NS_PERMISSIONMANAGER_CONTRACTID, &result));
+	if (NS_SUCCEEDED (result))
+	{
+#if MOZILLA_SNAPSHOT >= 10
+		pm->Remove (nsDependentCString (host), permission_type_string [type]);
+#else
+		pm->Remove (nsDependentCString (host), type);
+#endif
+	}
+}
+
+void
+impl_permission_manager_clear (EphyPermissionManager *manager)
+{
+	nsresult result;
+        nsCOMPtr<nsIPermissionManager> pm
+		(do_CreateInstance (NS_PERMISSIONMANAGER_CONTRACTID, &result));
+	if (NS_SUCCEEDED (result))
+	{
+		pm->RemoveAll ();
+	}
+}
+
+gboolean
+impl_permission_manager_test (EphyPermissionManager *manager,
+			      const char *host,
+			      EphyPermissionType type)
+{
+	nsresult result;
+        nsCOMPtr<nsIPermissionManager> pm
+		(do_CreateInstance (NS_PERMISSIONMANAGER_CONTRACTID, &result));
+	if (NS_FAILED (result) || !pm) return FALSE;
+
+	nsCOMPtr<nsIURI> uri;
+        result = NS_NewURI(getter_AddRefs(uri), host);
+        if (NS_FAILED(result) || !uri) return FALSE;
+
+	PRUint32 action;
+#if MOZILLA_SNAPSHOT >= 10
+	result = pm->TestPermission (uri, permission_type_string [type], &action);
+#else
+	result = pm->TestPermission (uri, type, &action);
+#endif
+	if (NS_FAILED (result)) return FALSE;
+
+	gboolean allow;
+	switch (action)
+	{
+		case nsIPermissionManager::ALLOW_ACTION:
+			allow = TRUE;
+			break;
+		case nsIPermissionManager::DENY_ACTION:
+		case nsIPermissionManager::UNKNOWN_ACTION:
+		default:
+			allow = FALSE;
+			break;
+	}
+
+	return allow;
+}
+
+GList *
+impl_permission_manager_list (EphyPermissionManager *manager,
+			      EphyPermissionType type)
+{
+	GList *list = NULL;
+
+	nsresult result;
+        nsCOMPtr<nsIPermissionManager> pm
+		(do_CreateInstance (NS_PERMISSIONMANAGER_CONTRACTID, &result));
+	if (NS_FAILED (result) || !pm) return NULL;
+
+	nsCOMPtr<nsISimpleEnumerator> pe;
+	result = pm->GetEnumerator(getter_AddRefs(pe));
+	if (NS_FAILED(result) || !pe) return NULL;
+	
+	PRBool more;
+	for (pe->HasMoreElements (&more); more == PR_TRUE; pe->HasMoreElements (&more))
+	{
+		nsCOMPtr<nsIPermission> perm;
+		result = pe->GetNext(getter_AddRefs(perm));
+		if (NS_FAILED(result) || !perm) continue;
+
+#if MOZILLA_SNAPSHOT >= 10
+		nsCAutoString str;
+		result = perm->GetType(str);
+		if (NS_FAILED (result)) continue;
+
+		if (str.Equals(permission_type_string[type]))
+#else
+		PRUint32 num;
+		result = perm->GetType(&num);
+		if (NS_FAILED (result)) continue;
+
+		if ((PRUint32) num == (PRUint32) type)
+#endif
+		{
+			EphyPermissionInfo *info = g_new0 (EphyPermissionInfo, 1);
+
+			info->type = type;
+
+			nsCString host;
+			perm->GetHost(host);
+			info->host = g_strdup (host.get());
+
+			PRUint32 cap;
+			perm->GetCapability(&cap);
+			switch (cap)
+			{
+				case nsIPermissionManager::ALLOW_ACTION :
+					info->allowed = TRUE;
+					break;
+				case nsIPermissionManager::DENY_ACTION :
+					/* fallthrough */
+				default :
+					info->allowed = FALSE;
+					break;
+			}
+
+			list = g_list_prepend (list, info);
+		}
+	}
+
+	return list;
 }
 
 static void
 mozilla_embed_single_class_init (MozillaEmbedSingleClass *klass)
 {
 	GObjectClass *object_class = G_OBJECT_CLASS (klass);
-	EphyEmbedSingleClass *shell_class = EPHY_EMBED_SINGLE_CLASS (klass);
-	
+
 	parent_class = (GObjectClass *) g_type_class_peek_parent (klass);
-	
-        object_class->finalize = mozilla_embed_single_finalize;
 
-	shell_class->clear_cache = impl_clear_cache;
-	shell_class->set_offline_mode = impl_set_offline_mode;
-	shell_class->load_proxy_autoconf = impl_load_proxy_autoconf;
-	shell_class->get_font_list = impl_get_font_list;
-	shell_class->list_cookies = impl_list_cookies;
-	shell_class->remove_cookies = impl_remove_cookies;
-	shell_class->list_passwords = impl_list_passwords;
-	shell_class->remove_passwords = impl_remove_passwords;
+	object_class->finalize = mozilla_embed_single_finalize;
 
 	g_type_class_add_private (object_class, sizeof(MozillaEmbedSinglePrivate));
 }
+
+static void
+ephy_embed_single_iface_init (EphyEmbedSingleClass *iface)
+{
+	iface->clear_cache = impl_clear_cache;
+	iface->set_offline_mode = impl_set_offline_mode;
+	iface->load_proxy_autoconf = impl_load_proxy_autoconf;
+	iface->get_font_list = impl_get_font_list;
+}
+
+static void
+ephy_cookie_manager_iface_init (EphyCookieManagerIFace *iface)
+{
+	iface->list = impl_list_cookies;
+	iface->remove = impl_remove_cookie;
+	iface->clear = impl_clear_cookies;
+}
+
+static void
+ephy_password_manager_iface_init (EphyPasswordManagerIFace *iface)
+{
+	iface->add = NULL; /* not implemented yet */
+	iface->remove = impl_remove_password;
+	iface->list = impl_list_passwords;
+}
+
+static void
+ephy_permission_manager_iface_init (EphyPermissionManagerIFace *iface)
+{
+	iface->add = impl_permission_manager_add;
+	iface->remove = impl_permission_manager_remove;
+	iface->clear = impl_permission_manager_clear;
+	iface->test = impl_permission_manager_test;
+	iface->list = impl_permission_manager_list;
+}
diff --git a/embed/mozilla/mozilla-embed-single.h b/embed/mozilla/mozilla-embed-single.h
index 63ce78267..08732a837 100644
--- a/embed/mozilla/mozilla-embed-single.h
+++ b/embed/mozilla/mozilla-embed-single.h
@@ -1,5 +1,6 @@
 /*
  *  Copyright (C) 2000-2003 Marco Pesenti Gritti
+ *  Copyright (C) 2003 Christian Persch
  *
  *  This program is free software; you can redistribute it and/or modify
  *  it under the terms of the GNU General Public License as published by
@@ -21,8 +22,8 @@
 #ifndef MOZILLA_EMBED_SINGLE_H
 #define MOZILLA_EMBED_SINGLE_H
 
-#include "glib.h"
-#include "ephy-embed-shell.h"
+#include "ephy-embed-single.h"
+
 #include <glib-object.h>
 
 G_BEGIN_DECLS
@@ -34,20 +35,21 @@ G_BEGIN_DECLS
 #define MOZILLA_IS_EMBED_SINGLE_CLASS(k)	(G_TYPE_CHECK_CLASS_TYPE ((k), MOZILLA_TYPE_EMBED_SINGLE))
 #define MOZILLA_EMBED_SINGLE_GET_CLASS(o)	(G_TYPE_INSTANCE_GET_CLASS ((o), MOZILLA_TYPE_EMBED_SINGLE, MozillaEmbedSingleClass))
 
-typedef struct MozillaEmbedSingle MozillaEmbedSingle;
-typedef struct MozillaEmbedSinglePrivate MozillaEmbedSinglePrivate;
+typedef struct MozillaEmbedSingle		MozillaEmbedSingle;
+typedef struct MozillaEmbedSingleClass		MozillaEmbedSingleClass;
+typedef struct MozillaEmbedSinglePrivate	MozillaEmbedSinglePrivate;
 
 struct MozillaEmbedSingle
 {
-	EphyEmbedSingle parent;
+	GObject parent;
 
 	/*< private >*/
-        MozillaEmbedSinglePrivate *priv;
+	MozillaEmbedSinglePrivate *priv;
 };
 
 struct MozillaEmbedSingleClass
 {
-        EphyEmbedSingleClass parent_class;
+	GObjectClass parent_class;
 };
 
 GType             mozilla_embed_single_get_type	     (void);
diff --git a/embed/mozilla/mozilla-notifiers.cpp b/embed/mozilla/mozilla-notifiers.cpp
index 955dc00bb..037fead15 100644
--- a/embed/mozilla/mozilla-notifiers.cpp
+++ b/embed/mozilla/mozilla-notifiers.cpp
@@ -351,7 +351,7 @@ mozilla_proxy_autoconfig_notifier (GConfClient *client,
 
 	url = eel_gconf_get_string (entry->key);
 
-	if (url)
+	if (url && url[0] != '\0')
 	{
 		ephy_embed_single_load_proxy_autoconf (single, url);
 	}