Merge lp:~midori/midori/tabby into lp:midori

[André Stösel]

Introduce tabby, the new session manager

Future work items:
https://bugs.launchpad.net/midori/+bugs?field.tag=tabby

[André Stösel (ivaldi)]

This is an early alpha and there are still some features missing and many bugs included.
Please open new bugs (tag "tabby") instead of adding comments.

[Cris Dywan (kalikiana)]

I made some improvements to error handling at startup and fixed it to work out of the build folder with cmake. I also resolved the "error" after first startup due to re-creating the tables.

Personally I learn towards merging now. I would look into re-factoring the database creation/ update/ import in a separate branch - I think we don't want to rush it, and it doesn't block tabby.

But I'd like a decision from Paweł before top-approving this. He expressed a strong wish to have the about: page on startup to restore other sessions asap.

review: Approve

[Paweł Forysiuk (tuxator)]

Ok lets get this in, should be no worse in any way than we have now even if some stuff is hidden.

review: Approve

=== added directory 'data/tabby'
=== added file 'data/tabby/Create.sql'
--- data/tabby/Create.sql	1970-01-01 00:00:00 +0000
+++ data/tabby/Create.sql	2013-09-07 14:18:40 +0000
@@ -0,0 +1,33 @@
+CREATE TABLE IF NOT EXISTS sessions
+(
+    id INTEGER PRIMARY KEY,
+    parent_id INTEGER DEFAULT 0,
+    crdate INTEGER DEFAULT 0,
+    tstamp INTEGER DEFAULT 0,
+    closed INTEGER DEFAULT 0,
+    title TEXT DEFAULT NULL,
+    FOREIGN KEY(parent_id) REFERENCES sessions(id)
+);
+
+CREATE TABLE IF NOT EXISTS tabs
+(
+    id INTEGER PRIMARY KEY,
+    session_id INTEGER NOT NULL,
+    uri TEXT DEFAULT NULL,
+    icon TEXT DEFAULT NULL,
+    title TEXT DEFAULT NULL,
+    crdate INTEGER DEFAULT 0,
+    tstamp INTEGER DEFAULT 0,
+    closed INTEGER DEFAULT 0,
+    FOREIGN KEY(session_id) REFERENCES sessions(id)
+);
+
+CREATE TABLE IF NOT EXISTS tab_history
+(
+    id INTEGER PRIMARY KEY,
+    tab_id INTEGER,
+    url TEXT,
+    icon TEXT,
+    title TEXT,
+    FOREIGN KEY(tab_id) REFERENCES tabs(id)
+);

=== modified file 'extensions/delayed-load.vala'
--- extensions/delayed-load.vala	2013-04-25 22:09:04 +0000
+++ extensions/delayed-load.vala	2013-09-07 14:18:40 +0000
@@ -106,7 +106,6 @@
 
     private class Manager : Midori.Extension {
         private int timeout = 0;
-        private bool initialized = false;
         private HashTable<Midori.Browser, TabShaker> tasks;
 
         public signal void preferences_changed ();
@@ -141,39 +140,12 @@
                 item.ref();
 
                 int64 delay = item.get_meta_integer ("delay");
-                if (delay == Midori.Delay.PENDING_UNDELAY && new_view.progress < 1.0 && this.initialized) {
+                if (delay == Midori.Delay.PENDING_UNDELAY && new_view.progress < 1.0) {
                     this.schedule_reload (browser, new_view);
                 }
             }
         }
 
-        private bool reload_first_tab () {
-            Midori.App app = get_app ();
-            Midori.Browser? browser = app.browser;
-            Midori.View? view = browser.tab as Midori.View;
-
-            if (view != null) {
-                this.initialized = true;
-                Katze.Item item = view.get_proxy_item ();
-                item.ref();
-
-                int64 delay = item.get_meta_integer ("delay");
-                if (delay != Midori.Delay.DELAYED) {
-                    if (view.load_status == Midori.LoadStatus.FINISHED) {
-                        if (this.timeout != 0)
-                            this.tasks.set (browser, new TabShaker (browser));
-
-                        if (view.progress < 1.0)
-                            this.schedule_reload (browser, view);
-
-                        return false;
-                    }
-                }
-            }
-
-            return true;
-        }
-
         private void browser_added (Midori.Browser browser) {
             browser.switch_tab.connect_after (this.tab_changed);
         }
@@ -188,12 +160,6 @@
 
             this.preferences_changed ();
 
-            Midori.Browser? focused_browser = app.browser;
-            if (focused_browser == null)
-                Midori.Timeout.add (50, this.reload_first_tab);
-            else
-                this.initialized = true;
-
             foreach (Midori.Browser browser in app.get_browsers ()) {
                 browser_added (browser);
             }

=== added file 'extensions/tabby.vala'
--- extensions/tabby.vala	1970-01-01 00:00:00 +0000
+++ extensions/tabby.vala	2013-09-07 14:18:40 +0000
@@ -0,0 +1,402 @@
+/*
+   Copyright (C) 2013 André Stösel <[e-mail]>
+
+   This library is free software; you can redistribute it and/or
+   modify it under the terms of the GNU Lesser General Public
+   License as published by the Free Software Foundation; either
+   version 2.1 of the License, or (at your option) any later version.
+
+   See the file COPYING for the full license text.
+*/
+
+namespace Tabby {
+    /* function called from Manager object */
+    public interface IStorage : GLib.Object {
+        public abstract Katze.Array get_sessions ();
+        public abstract Base.Session get_new_session ();
+        public abstract void restore_last_sessions ();
+        public abstract void import_session (Katze.Array tabs);
+    }
+
+    public interface ISession : GLib.Object {
+        public abstract Katze.Array get_tabs ();
+        public abstract void add_item (Katze.Item item);
+        public abstract void attach (Midori.Browser browser);
+        public abstract void restore (Midori.Browser browser);
+        public abstract void close ();
+    }
+
+    namespace Base {
+        /* each base class should connect to all necessary signals and provide an abstract function to handle them */
+
+        public abstract class Storage : GLib.Object, IStorage {
+            public Midori.App app { get; construct; }
+
+            public abstract Katze.Array get_sessions ();
+            public abstract Base.Session get_new_session ();
+            public void restore_last_sessions () {
+                Katze.Array sessions = this.get_sessions ();
+                if (sessions.is_empty ()) {
+                    sessions.add_item (this.get_new_session ());
+                }
+
+                GLib.List<unowned Katze.Item> items = sessions.get_items ();
+                foreach (Katze.Item item in items) {
+                    Session session = item as Session;
+                    Midori.Browser browser = this.app.create_browser ();
+
+                    /* FixMe: tabby-session should be set in .restore and .attch */
+                    browser.set_data<Base.Session> ("tabby-session", session as Base.Session);
+
+                    app.add_browser (browser);
+                    browser.show ();
+
+                    session.restore (browser);
+                }
+            }
+
+            public void import_session (Katze.Array tabs) {
+                Session session = this.get_new_session ();
+                GLib.List<unowned Katze.Item> items = tabs.get_items ();
+                foreach (Katze.Item item in items) {
+                    session.add_item (item);
+                }
+            }
+        }
+
+        public abstract class Session : GLib.Object, ISession {
+            public abstract void add_item (Katze.Item item);
+            public abstract void uri_changed (Midori.View view, string uri);
+            public abstract void tab_added (Midori.Browser browser, Midori.View view);
+            public abstract void tab_removed (Midori.Browser browser, Midori.View view);
+            public abstract void close ();
+            public abstract Katze.Array get_tabs ();
+
+            public void attach (Midori.Browser browser) {
+                browser.add_tab.connect (this.tab_added);
+                browser.add_tab.connect (this.helper_uri_changed);
+                browser.remove_tab.connect (this.tab_removed);
+
+                foreach (Midori.View view in browser.get_tabs ()) {
+                    this.tab_added (browser, view);
+                    this.helper_uri_changed (browser, view);
+                }
+            }
+
+            public void restore (Midori.Browser browser) {
+                Katze.Array tabs = this.get_tabs ();
+
+                if(tabs.is_empty ()) {
+                    Katze.Item item = new Katze.Item ();
+                    item.uri = "about:home";
+                    tabs.add_item (item);
+                }
+
+                browser.add_tab.connect (this.tab_added);
+                browser.add_tab.connect (this.helper_uri_changed);
+                browser.remove_tab.connect (this.tab_removed);
+
+                GLib.List<unowned Katze.Item> items = tabs.get_items ();
+                unowned GLib.List<unowned Katze.Item> u_items = items;
+
+                bool delay = false;
+
+                GLib.Idle.add (() => {
+                    /* Note: we need to use `items` for something to maintain a valid reference */
+                    if (items.length () > 0) {
+                        for (int i = 0; i < 3; i++) {
+                            if (u_items == null)
+                                return false;
+
+                            Katze.Item t_item = u_items.data<Katze.Item>;
+
+                            if (delay)
+                                t_item.set_meta_integer ("delay", Midori.Delay.DELAYED);
+                            else
+                                delay = true;
+
+                            browser.add_item (t_item);
+
+                            u_items = u_items.next;
+                        }
+                    }
+                    return u_items != null;
+                });
+            }
+
+            private void helper_uri_changed (Midori.Browser browser, Midori.View view) {
+                /* FixMe: skip first event while restoring the session */
+                view.web_view.notify["uri"].connect ( () => {
+                    this.uri_changed (view, view.web_view.uri);
+                });
+            }
+        }
+    }
+
+    namespace Local {
+        private class Session : Base.Session {
+            public static int open_sessions = 0;
+            public int64 id { get; private set; }
+            private unowned Sqlite.Database db;
+
+            public override void add_item (Katze.Item item) {
+                GLib.DateTime time = new DateTime.now_local ();
+                string sqlcmd = "INSERT INTO `tabs` (`crdate`, `tstamp`, `session_id`, `uri`) VALUES (:tstamp, :tstamp, :session_id, :uri);";
+                Sqlite.Statement stmt;
+                if (this.db.prepare_v2 (sqlcmd, -1, out stmt, null) != Sqlite.OK)
+                    critical (_("Failed to update database: %s"), db.errmsg);
+                stmt.bind_int64 (stmt.bind_parameter_index (":tstamp"), time.to_unix ());
+                stmt.bind_int64 (stmt.bind_parameter_index (":session_id"), this.id);
+                stmt.bind_text (stmt.bind_parameter_index (":uri"), item.uri);
+                if (stmt.step () != Sqlite.DONE)
+                    critical (_("Failed to update database: %s"), db.errmsg);
+                else {
+                    int64 tab_id = this.db.last_insert_rowid ();
+                    item.set_meta_integer ("tabby-id", tab_id);
+                }
+            }
+
+            protected override void uri_changed (Midori.View view, string uri) {
+                unowned Katze.Item item = view.get_proxy_item ();
+                int64 tab_id = item.get_meta_integer ("tabby-id");
+                string sqlcmd = "UPDATE `tabs` SET uri = :uri, title = :title WHERE session_id = :session_id AND id = :tab_id;";
+                Sqlite.Statement stmt;
+                if (this.db.prepare_v2 (sqlcmd, -1, out stmt, null) != Sqlite.OK)
+                    critical (_("Failed to update database: %s"), db.errmsg ());
+                stmt.bind_text (stmt.bind_parameter_index (":uri"), uri);
+                stmt.bind_text (stmt.bind_parameter_index (":title"), view.get_display_title ());
+                stmt.bind_int64 (stmt.bind_parameter_index (":session_id"), this.id);
+                stmt.bind_int64 (stmt.bind_parameter_index (":tab_id"), tab_id);
+                if (stmt.step () != Sqlite.DONE)
+                    critical (_("Failed to update database: %s"), db.errmsg ());
+            }
+
+            protected override void tab_added (Midori.Browser browser, Midori.View view) {
+                unowned Katze.Item item = view.get_proxy_item ();
+                int64 tab_id = item.get_meta_integer ("tabby-id");
+                if (tab_id < 1) {
+                    this.add_item (item);
+                }
+           }
+
+            protected override void tab_removed (Midori.Browser browser, Midori.View view) {
+                unowned Katze.Item item = view.get_proxy_item ();
+                int64 tab_id = item.get_meta_integer ("tabby-id");
+                /* FixMe: mark as deleted */
+                string sqlcmd = "DELETE FROM `tabs` WHERE session_id = :session_id AND id = :tab_id;";
+                Sqlite.Statement stmt;
+                if (this.db.prepare_v2 (sqlcmd, -1, out stmt, null) != Sqlite.OK)
+                    critical (_("Failed to update database: %s"), db.errmsg ());
+                stmt.bind_int64 (stmt.bind_parameter_index (":session_id"), this.id);
+                stmt.bind_int64 (stmt.bind_parameter_index (":tab_id"), tab_id);
+                if (stmt.step () != Sqlite.DONE)
+                    critical (_("Failed to update database: %s"), db.errmsg ());
+            }
+
+            public override void close() {
+                if (Session.open_sessions == 1)
+                    return;
+
+                GLib.DateTime time = new DateTime.now_local ();
+                string sqlcmd = "UPDATE `sessions` SET closed = 1, tstamp = :tstamp WHERE id = :session_id;";
+                Sqlite.Statement stmt;
+                if (this.db.prepare_v2 (sqlcmd, -1, out stmt, null) != Sqlite.OK)
+                    critical (_("Failed to update database: %s"), db.errmsg ());
+
+                stmt.bind_int64 (stmt.bind_parameter_index (":session_id"), this.id);
+                stmt.bind_int64 (stmt.bind_parameter_index (":tstamp"), time.to_unix ());
+                if (stmt.step () != Sqlite.DONE)
+                    critical (_("Failed to update database: %s"), db.errmsg ());
+            }
+
+            public override Katze.Array get_tabs() {
+                Katze.Array tabs = new Katze.Array (typeof (Katze.Item));
+
+                string sqlcmd = "SELECT id, uri, title FROM tabs WHERE session_id = :session_id";
+                Sqlite.Statement stmt;
+                if (this.db.prepare_v2 (sqlcmd, -1, out stmt, null) != Sqlite.OK)
+                    critical (_("Failed to select from database: %s"), db.errmsg ());
+                stmt.bind_int64 (stmt.bind_parameter_index (":session_id"), this.id);
+                int result = stmt.step ();
+                if (!(result == Sqlite.DONE || result == Sqlite.ROW)) {
+                    critical (_("Failed to select from database: %s"), db.errmsg ());
+                    return tabs;
+                }
+
+                while (result == Sqlite.ROW) {
+                    Katze.Item item = new Katze.Item ();
+                    int64 id = stmt.column_int64 (0);
+                    string uri = stmt.column_text (1);
+                    string title = stmt.column_text (2);
+                    item.uri = uri;
+                    item.name = title;
+                    item.set_meta_integer ("tabby-id", id);
+                    tabs.add_item (item);
+                    result = stmt.step ();
+                 }
+
+                 return tabs;
+            }
+
+            internal Session (Sqlite.Database db) {
+                this.db = db;
+
+                GLib.DateTime time = new DateTime.now_local ();
+
+                string sqlcmd = "INSERT INTO `sessions` (`tstamp`) VALUES (:tstamp);";
+                Sqlite.Statement stmt;
+                if (this.db.prepare_v2 (sqlcmd, -1, out stmt, null) != Sqlite.OK)
+                    critical (_("Failed to update database: %s"), db.errmsg);
+                stmt.bind_int64 (stmt.bind_parameter_index (":tstamp"), time.to_unix ());
+                if (stmt.step () != Sqlite.DONE)
+                    critical (_("Failed to update database: %s"), db.errmsg);
+                else
+                    this.id = this.db.last_insert_rowid ();
+            }
+
+            internal Session.with_id (Sqlite.Database db, int64 id) {
+                this.db = db;
+                this.id = id;
+
+                GLib.DateTime time = new DateTime.now_local ();
+                string sqlcmd = "UPDATE `sessions` SET closed = 0, tstamp = :tstamp WHERE id = :session_id;";
+                Sqlite.Statement stmt;
+                if (this.db.prepare_v2 (sqlcmd, -1, out stmt, null) != Sqlite.OK)
+                    critical (_("Failed to update database: %s"), db.errmsg);
+
+                stmt.bind_int64 (stmt.bind_parameter_index (":session_id"), this.id);
+                stmt.bind_int64 (stmt.bind_parameter_index (":tstamp"), time.to_unix ());
+                if (stmt.step () != Sqlite.DONE)
+                    critical (_("Failed to update database: %s"), db.errmsg);
+            }
+
+            construct {
+                Session.open_sessions++;
+            }
+
+            ~Session () {
+                Session.open_sessions--;
+            }
+
+        }
+
+        private class Storage : Base.Storage {
+            protected Sqlite.Database db;
+
+            public override Katze.Array get_sessions () {
+                Katze.Array sessions = new Katze.Array (typeof (Session));
+
+                string sqlcmd = "SELECT id FROM sessions WHERE closed = 0;";
+                Sqlite.Statement stmt;
+                if (this.db.prepare_v2 (sqlcmd, -1, out stmt, null) != Sqlite.OK)
+                    critical (_("Failed to select from database: %s"), db.errmsg);
+                int result = stmt.step ();
+                if (!(result == Sqlite.DONE || result == Sqlite.ROW)) {
+                    critical (_("Failed to select from database: %s"), db.errmsg);
+                    return sessions;
+                }
+
+                while (result == Sqlite.ROW) {
+                    int64 id = stmt.column_int64 (0);
+                    sessions.add_item (new Session.with_id (this.db, id));
+                    result = stmt.step ();
+                 }
+ 
+                if (sessions.is_empty ()) {
+                    sessions.add_item (new Session (this.db));
+                }
+
+                return sessions;
+            }
+
+            public override Base.Session get_new_session () {
+                return new Session (this.db) as Base.Session;
+            }
+
+            internal Storage (Midori.App app) {
+                GLib.Object (app: app);
+
+                string db_path = Midori.Paths.get_config_filename_for_writing ("tabby.db");
+
+                /* FixMe: why does GLib.FileUtils.test(db_path, GLib.FileTest.EXISTS); randomly work or not? */
+
+                if (Sqlite.Database.open_v2 (db_path, out this.db) != Sqlite.OK)
+                    critical (_("Failed to open stored session: %s"), db.errmsg);
+
+                string filename = Midori.Paths.get_res_filename ("tabby/Create.sql");
+                string schema;
+                try {
+                        bool success = FileUtils.get_contents (filename, out schema, null);
+                        if (!success || schema == null)
+                            critical (_("Failed to open database schema file: %s"), filename);
+                        if (success && schema != null)
+                            if (this.db.exec (schema) != Sqlite.OK)
+                                critical (_("Failed to execute database schema: %s"), filename);
+                            else {
+                                string config_file = Midori.Paths.get_config_filename_for_reading ("session.xbel");
+                                try {
+                                    Katze.Array old_session = new Katze.Array (typeof (Katze.Item));
+                                    Midori.array_from_file (old_session, config_file, "xbel-tiny");
+                                    this.import_session (old_session);
+                                } catch (GLib.FileError file_error) {
+                                    /* no old session.xbel -> could be a new profile -> ignore it */
+                                } catch (GLib.Error error) {
+                                    critical (_("Failed to import legacy session: %s"), error.message);
+                                }
+                            }
+                } catch (GLib.FileError schema_error) {
+                    critical (_("Failed to open database schema file: %s"), schema_error.message);
+                }
+            }
+        }
+    }
+
+    private class Manager : Midori.Extension {
+        private Base.Storage storage;
+        private bool load_session () {
+            this.storage.restore_last_sessions ();
+            return false;
+        }
+
+        private void browser_added (Midori.Browser browser) {
+            Base.Session session = browser.get_data<Base.Session> ("tabby-session");
+            if (session == null) {
+                session = this.storage.get_new_session () as Base.Session;
+                browser.set_data<Base.Session> ("tabby-session", session);
+                session.attach (browser);
+            }
+        }
+
+        private void browser_removed (Midori.Browser browser) {
+            Base.Session session = browser.get_data<Base.Session> ("tabby-session");
+            if (session == null) {
+                GLib.warning ("missing session");
+            } else {
+                session.close ();
+            }
+        }
+
+        private void activated (Midori.App app) {
+            /* FixMe: provide an option to replace Local.Storage with IStorage based Objects */
+            this.storage = new Local.Storage (this.get_app ()) as Base.Storage;
+
+            app.add_browser.connect (browser_added);
+            app.remove_browser.connect (browser_removed);
+
+            GLib.Idle.add (this.load_session);
+        }
+
+        internal Manager () {
+            GLib.Object (name: _("Tabby"),
+                         description: _("Tab and session management."),
+                         version: "0.1",
+                         authors: "André Stösel <[e-mail]>");
+
+            activate.connect (this.activated);
+        }
+    }
+}
+
+public Midori.Extension extension_init () {
+    return new Tabby.Manager ();
+}

=== modified file 'katze/midori-paths.vala'
--- katze/midori-paths.vala	2013-08-02 18:35:37 +0000
+++ katze/midori-paths.vala	2013-09-07 14:18:40 +0000
@@ -354,7 +354,7 @@
 
             /* Fallback to build folder */
             path = Path.build_filename ((File.new_for_path (exec_path)
-                .get_parent ().get_parent ().get_path ()), "data", filename);
+                .get_parent ().get_path ()), "data", filename);
             if (Posix.access (path, Posix.F_OK) == 0)
                 return path;
 

=== modified file 'midori/midori-extension.c'
--- midori/midori-extension.c	2013-07-07 11:29:11 +0000
+++ midori/midori-extension.c	2013-09-07 14:18:40 +0000
@@ -561,6 +561,8 @@
         /* FIXME need proper stock extension mechanism */
         g_assert (midori_extension_activate_gracefully (app, extension_path, "libtransfers." G_MODULE_SUFFIX, activate));
         g_assert (midori_extension_activate_gracefully (app, extension_path, "libapps." G_MODULE_SUFFIX, activate));
+        g_assert (midori_extension_activate_gracefully (app, extension_path, "libdelayed-load." G_MODULE_SUFFIX, activate));
+        g_assert (midori_extension_activate_gracefully (app, extension_path, "libtabby." G_MODULE_SUFFIX, activate));
     }
     else
     {
@@ -673,7 +675,9 @@
         return;
     /* FIXME need proper stock extension mechanism */
     if (!strcmp (filename, "libtransfers." G_MODULE_SUFFIX)
-     || !strcmp (filename, "libapps." G_MODULE_SUFFIX))
+     || !strcmp (filename, "libapps." G_MODULE_SUFFIX)
+     || !strcmp (filename, "libdelayed-load." G_MODULE_SUFFIX)
+     || !strcmp (filename, "libtabby." G_MODULE_SUFFIX))
         return;
 
     katze_array_add_item (extensions, extension);

=== modified file 'midori/midori-frontend.c'
--- midori/midori-frontend.c	2013-08-29 20:27:55 +0000
+++ midori/midori-frontend.c	2013-09-07 14:18:40 +0000
@@ -585,9 +585,10 @@
     g_signal_connect (app, "add-browser",
         G_CALLBACK (midori_app_add_browser_cb), NULL);
 
+    midori_session_persistent_settings (settings, app);
+
     g_idle_add (midori_load_soup_session_full, settings);
     g_idle_add (midori_load_extensions, app);
-    g_idle_add (midori_load_session, session);
     return app;
 }
 

=== modified file 'midori/midori-session.c'
--- midori/midori-session.c	2013-09-02 20:05:07 +0000
+++ midori/midori-session.c	2013-09-07 14:18:40 +0000
@@ -395,38 +395,6 @@
     g_free (config_file);
 }
 
-void
-midori_session_persistent_settings (MidoriWebSettings* settings,
-                                    MidoriApp*         app)
-{
-    g_signal_connect_after (settings, "notify", G_CALLBACK (settings_notify_cb), app);
-}
-
-static void
-midori_browser_action_last_session_activate_cb (GtkAction*     action,
-                                                MidoriBrowser* browser)
-{
-    KatzeArray* old_session = katze_array_new (KATZE_TYPE_ITEM);
-    gchar* config_file = midori_paths_get_config_filename_for_reading ("session.old.xbel");
-    GError* error = NULL;
-    if (midori_array_from_file (old_session, config_file, "xbel-tiny", &error))
-    {
-        KatzeItem* item;
-        KATZE_ARRAY_FOREACH_ITEM (item, old_session)
-            midori_browser_add_item (browser, item);
-    }
-    else
-    {
-        sokoke_message_dialog (GTK_MESSAGE_ERROR,
-            _("The session couldn't be loaded: %s\n"), error->message, FALSE);
-        g_error_free (error);
-    }
-    g_free (config_file);
-    gtk_action_set_sensitive (action, FALSE);
-    g_signal_handlers_disconnect_by_func (action,
-        midori_browser_action_last_session_activate_cb, browser);
-}
-
 static void
 midori_session_accel_map_changed_cb (GtkAccelMap*    accel_map,
                                      gchar*          accel_path,
@@ -438,153 +406,12 @@
     g_free (config_file);
 }
 
-static guint save_timeout = 0;
-
-static gboolean
-midori_session_save_timeout_cb (KatzeArray* session)
-{
-    gchar* config_file = midori_paths_get_config_filename_for_writing ("session.xbel");
-    GError* error = NULL;
-    if (!midori_array_to_file (session, config_file, "xbel-tiny", &error))
-    {
-        g_warning (_("The session couldn't be saved. %s"), error->message);
-        g_error_free (error);
-    }
-    g_free (config_file);
-
-    save_timeout = 0;
-    return FALSE;
-}
-
-static void
-midori_browser_session_cb (MidoriBrowser* browser,
-                           gpointer       pspec,
-                           KatzeArray*    session)
-{
-    if (!save_timeout)
-        save_timeout = midori_timeout_add_seconds (
-            5, (GSourceFunc)midori_session_save_timeout_cb, session, NULL);
-}
-
-static void
-midori_app_quit_cb (MidoriBrowser* browser,
-                    KatzeArray*    session)
-{
-    midori_session_save_timeout_cb (session);
-}
-
-static void
-midori_browser_weak_notify_cb (MidoriBrowser* browser,
-                               KatzeArray*    session)
-{
-    g_object_disconnect (browser, "any-signal",
-                         G_CALLBACK (midori_browser_session_cb), session, NULL);
-}
-
-gboolean
-midori_load_session (gpointer data)
-{
-    KatzeArray* saved_session = KATZE_ARRAY (data);
-    MidoriBrowser* browser;
-    MidoriApp* app = katze_item_get_parent (KATZE_ITEM (saved_session));
-    MidoriWebSettings* settings = katze_object_get_object (app, "settings");
-    MidoriStartup load_on_startup;
-    gchar* config_file;
-    KatzeArray* session;
-    KatzeItem* item;
-    gint64 current;
-    gchar** open_uris = g_object_get_data (G_OBJECT (app), "open-uris");
-    gchar** execute_commands = g_object_get_data (G_OBJECT (app), "execute-commands");
-    gchar* uri;
-    guint i = 0;
-    gboolean startup_timer = midori_debug ("startup");
-    GTimer* timer = startup_timer ? g_timer_new () : NULL;
-
-    browser = midori_app_create_browser (app);
-    midori_session_persistent_settings (settings, app);
-
-    config_file = midori_paths_get_config_filename_for_reading ("session.old.xbel");
-    if (g_access (config_file, F_OK) == 0)
-    {
-        GtkActionGroup* action_group = midori_browser_get_action_group (browser);
-        GtkAction* action = gtk_action_group_get_action (action_group, "LastSession");
-        g_signal_connect (action, "activate",
-            G_CALLBACK (midori_browser_action_last_session_activate_cb), browser);
-        gtk_action_set_visible (action, TRUE);
-    }
-    midori_app_add_browser (app, browser);
-    gtk_widget_show (GTK_WIDGET (browser));
-
-    katze_assign (config_file, midori_paths_get_config_filename_for_reading ("accels"));
+void
+midori_session_persistent_settings (MidoriWebSettings* settings,
+                                    MidoriApp*         app)
+{
+    g_signal_connect_after (settings, "notify", G_CALLBACK (settings_notify_cb), app);
     g_signal_connect_after (gtk_accel_map_get (), "changed",
         G_CALLBACK (midori_session_accel_map_changed_cb), NULL);
 
-    load_on_startup = (MidoriStartup)g_object_get_data (G_OBJECT (settings), "load-on-startup");
-    if (katze_array_is_empty (saved_session))
-    {
-        item = katze_item_new ();
-        if (open_uris)
-        {
-            uri = sokoke_magic_uri (open_uris[i], TRUE, TRUE);
-            katze_item_set_uri (item, uri);
-            g_free (uri);
-            i++;
-        } else if (load_on_startup == MIDORI_STARTUP_BLANK_PAGE)
-            katze_item_set_uri (item, "about:new");
-        else
-            katze_item_set_uri (item, "about:home");
-        katze_array_add_item (saved_session, item);
-        g_object_unref (item);
-    }
-
-    session = midori_browser_get_proxy_array (browser);
-    KATZE_ARRAY_FOREACH_ITEM (item, saved_session)
-    {
-        katze_item_set_meta_integer (item, "append", 1);
-        katze_item_set_meta_integer (item, "dont-write-history", 1);
-        if (load_on_startup == MIDORI_STARTUP_DELAYED_PAGES
-         || katze_item_get_meta_integer (item, "delay") == MIDORI_DELAY_PENDING_UNDELAY)
-            katze_item_set_meta_integer (item, "delay", MIDORI_DELAY_DELAYED);
-        midori_browser_add_item (browser, item);
-    }
-
-    current = katze_item_get_meta_integer (KATZE_ITEM (saved_session), "current");
-    if (!(item = katze_array_get_nth_item (saved_session, current)))
-    {
-        current = 0;
-        item = katze_array_get_nth_item (saved_session, 0);
-    }
-    midori_browser_set_current_page (browser, current);
-    if (midori_uri_is_blank (katze_item_get_uri (item)))
-        midori_browser_activate_action (browser, "Location");
-
-    /* `i` also used above; in that case we won't re-add the same URLs here */
-    for (; open_uris && open_uris[i]; i++)
-    {
-        uri = sokoke_magic_uri (open_uris[i], TRUE, TRUE);
-        midori_browser_add_uri (browser, uri);
-        g_free (uri);
-    }
-
-    g_object_unref (settings);
-    g_object_unref (saved_session);
-    g_free (config_file);
-
-    g_signal_connect_after (browser, "add-tab",
-        G_CALLBACK (midori_browser_session_cb), session);
-    g_signal_connect_after (browser, "remove-tab",
-        G_CALLBACK (midori_browser_session_cb), session);
-    g_signal_connect (app, "quit",
-        G_CALLBACK (midori_app_quit_cb), session);
-    g_object_weak_ref (G_OBJECT (session),
-        (GWeakNotify)(midori_browser_weak_notify_cb), browser);
-
-    if (execute_commands != NULL)
-        midori_app_send_command (app, execute_commands);
-
-    if (startup_timer)
-        g_debug ("Session setup:\t%f", g_timer_elapsed (timer, NULL));
-
-    return FALSE;
 }
-

=== modified file 'midori/midori-session.h'
--- midori/midori-session.h	2013-05-23 22:15:27 +0000
+++ midori/midori-session.h	2013-09-07 14:18:40 +0000
@@ -25,9 +25,6 @@
 gboolean
 midori_load_extensions (gpointer data);
 
-gboolean
-midori_load_session (gpointer data);
-
 void
 midori_session_persistent_settings (MidoriWebSettings* settings,
                                     MidoriApp*         app);

=== modified file 'midori/midori.vapi'
--- midori/midori.vapi	2013-08-20 08:24:46 +0000
+++ midori/midori.vapi	2013-09-07 14:18:40 +0000
@@ -21,6 +21,9 @@
         [CCode (array_length = false)] string[]? uris, [CCode (array_length = false)] string[]? commands, int reset, string? block);
     public static void normal_app_on_quit (App app);
 
+    [CCode (cheader_filename = "midori/midori-array.h")]
+    public static bool array_from_file (Katze.Array array, string filename, string format) throws GLib.Error;
+
     [CCode (cheader_filename = "midori/midori.h")]
     public class App : GLib.Object {
         public App (string? name=null);