Merge lp:~midori/midori/moreBeans into lp:midori

[Cris Dywan]

Implement Peas plugin loading for GUI and web process

[lp:~midori/midori/moreBeans]

6967. By Cris Dywan on 2015-06-21

HSTS and Minimized Tabs implemented with activatables

6968. By Cris Dywan on 2015-06-21

Use HAVE_PEAS for easier build testing

6969. By Cris Dywan on 2015-06-22

Reincarnate Extensions panel as Extension Manager with Peas support

Unmerged revisions

6969. By Cris Dywan on 2015-06-22

Reincarnate Extensions panel as Extension Manager with Peas support

6968. By Cris Dywan on 2015-06-21

Use HAVE_PEAS for easier build testing

6967. By Cris Dywan on 2015-06-21

HSTS and Minimized Tabs implemented with activatables

6966. By Cris Dywan on 2015-06-20

Implement Peas plugin loading for GUI and web process

6965. By Cris Dywan on 2015-06-13

Implement HSTS as a web extension

=== modified file 'CMakeLists.txt'
--- CMakeLists.txt	2015-06-18 05:03:38 +0000
+++ CMakeLists.txt	2015-06-22 22:20:28 +0000
@@ -193,6 +193,12 @@
     add_definitions("-DHAVE_GCR")
     set(OPTS_INCLUDE_DIRS ${OPTS_INCLUDE_DIRS} ${GCR_INCLUDE_DIRS})
     set(OPTS_LIBRARIES ${OPTS_LIBRARIES} ${GCR_LIBRARIES})
+
+    pkg_check_modules(PEAS REQUIRED libpeas-1.0>=1.4)
+    set(OPTS_INCLUDE_DIRS ${OPTS_INCLUDE_DIRS} ${PEAS_INCLUDE_DIRS})
+    set(OPTS_LIBRARIES ${OPTS_LIBRARIES} ${PEAS_LIBRARIES})
+    set(PKGS ${PKGS} libpeas-1.0)
+    set(VALAFLAGS ${VALAFLAGS} -D HAVE_PEAS)
 endif ()
 
 if (HALF_BRO_INCOM_WEBKIT2)
@@ -204,7 +210,6 @@
     add_definitions("-DGTK_VERSION=\"${DEPS_GTK_gtk+-3.0_VERSION}\"")
     add_definitions("-DWEBKIT_VERSION=\"${DEPS_GTK_webkit2gtk-4.0_VERSION}\"")
     set(PKGS ${PKGS} gtk+-3.0)
-    # set(EXTRA_VAPIS ${EXTRA_VAPIS} "${CMAKE_SOURCE_DIR}/midori/webkit2gtk-web-extension-4.0.vapi")
     set(EXTRA_VAPIS ${EXTRA_VAPIS} "${CMAKE_SOURCE_DIR}/midori/webkit2gtk-4.0.vapi")
     set(VALAFLAGS ${VALAFLAGS} -D HAVE_GTK3)
     set(VALAFLAGS ${VALAFLAGS} -D HAVE_WEBKIT2)
@@ -272,9 +277,13 @@
 install(FILES AUTHORS COPYING ChangeLog EXPAT README DESTINATION ${CMAKE_INSTALL_DOCDIR})
 
 add_subdirectory (midori)
-add_subdirectory (extensions)
+if (HALF_BRO_INCOM_WEBKIT2)
+    set(LIBMIDORI2 "${CMAKE_PROJECT_NAME}-ipc")
+    add_subdirectory (ipc)
+endif ()
 enable_testing()
 add_subdirectory (tests)
+add_subdirectory (extensions)
 add_subdirectory (po)
 add_subdirectory (icons)
 add_subdirectory (data)

=== modified file 'extensions/CMakeLists.txt'
--- extensions/CMakeLists.txt	2015-04-19 14:06:12 +0000
+++ extensions/CMakeLists.txt	2015-06-22 22:20:28 +0000
@@ -8,9 +8,9 @@
                     ${DEPS_INCLUDE_DIRS}
                     ${OPTS_INCLUDE_DIRS}
                     ${DEPS_GTK_INCLUDE_DIRS}
-                    ${OPTS_GTK_INCLUDE_DIRS}
                     ${CMAKE_BINARY_DIR}
                     "${CMAKE_BINARY_DIR}/midori"
+                    "${CMAKE_BINARY_DIR}/ipc"
                     )
 file(GLOB EXTENSIONS RELATIVE ${CMAKE_CURRENT_SOURCE_DIR} *)
 if (HALF_BRO_INCOM_WEBKIT2)
@@ -23,6 +23,11 @@
          "nsplugin-manager.vala"
          "tabs2one.c"
          )
+else ()
+    list(REMOVE_ITEM EXTENSIONS
+         "hsts.web.vala"
+         "web-extension.web.vala"
+         )
 endif ()
 
 # FIXME: re-enable webmedia extension
@@ -36,99 +41,111 @@
     list(REMOVE_ITEM EXTENSIONS "tabs2one.c")
 endif()
 
-foreach(UNIT_SRC ${EXTENSIONS})
-    string(FIND ${UNIT_SRC} ".c" UNIT_EXTENSION)
-    if (UNIT_EXTENSION GREATER -1)
-        string(REPLACE ".c" "" UNIT ${UNIT_SRC})
-        add_library(${UNIT} MODULE ${UNIT_SRC})
-        target_link_libraries(${UNIT}
-                              ${LIBMIDORI}
-                              )
-        set_target_properties(${UNIT} PROPERTIES
-                              COMPILE_FLAGS ${CFLAGS}
-                              )
-        install(TARGETS ${UNIT}
-            LIBRARY DESTINATION ${EXTENSIONDIR}
-                )
+include(ValaPrecompile)
+
+macro(build_extension name)
+    set(source "${ARGN}")
+    set(SOURCE_VALA "")
+
+    set(PLUGIN "${CMAKE_CURRENT_SOURCE_DIR}/${name}.plugin")
+    if (EXISTS ${PLUGIN})
+        file(COPY ${PLUGIN} DESTINATION ${CMAKE_CURRENT_BINARY_DIR})
     endif ()
-endforeach ()
 
-foreach(UNIT_SRC ${EXTENSIONS})
-    string(FIND ${UNIT_SRC} "." UNIT_EXTENSION)
-    if (UNIT_EXTENSION EQUAL -1)
-        file(GLOB UNIT_FILES RELATIVE ${CMAKE_CURRENT_SOURCE_DIR} "${UNIT_SRC}/*.c")
-        file(GLOB UNIT_FILES_VALA RELATIVE ${CMAKE_CURRENT_SOURCE_DIR} "${UNIT_SRC}/*.vala")
-        if (UNIT_FILES_VALA)
-            include(ValaPrecompile)
-            vala_precompile(UNIT_SRC_C ${UNIT_SRC}
-                ${UNIT_FILES_VALA}
+    foreach(FILE ${source})
+        string(FIND ${FILE} ".web." WEB_EXTENSION)
+        string(FIND ${FILE} ".vala" VALA_EXTENSION)
+        if (WEB_EXTENSION GREATER -1)
+            string(REPLACE ".vala" "" WEB_NAME "${name}_${FILE}")
+            string(REPLACE "." "_" WEB_NAME "${WEB_NAME}")
+            vala_precompile(WEB_EXTENSION_C "${WEB_NAME}"
+                ${FILE}
             PACKAGES
                 ${PKGS}
             OPTIONS
                 ${VALAFLAGS}
-                --use-header="${CMAKE_PROJECT_NAME}-core.h"
-            GENERATE_HEADER
-                "${UNIT_SRC}"
-            GENERATE_HEADER
-                ${UNIT}
+            GENERATE_HEADER
+                ${FILE}
             CUSTOM_VAPIS
-                ${EXTRA_VAPIS}
-                "${CMAKE_SOURCE_DIR}/midori/midori.vapi"
-                "${CMAKE_BINARY_DIR}/midori/${LIBMIDORI}.vapi"
+                "${CMAKE_BINARY_DIR}/ipc/${LIBMIDORI2}.vapi"
+                "${CMAKE_SOURCE_DIR}/midori/webkit2gtk-web-extension-4.0.vapi"
             )
-            set(UNIT_FILES ${UNIT_FILES} ${UNIT_SRC_C})
-        endif ()
-        if (UNIT_FILES)
-            add_library(${UNIT_SRC} MODULE ${UNIT_FILES})
-            target_link_libraries(${UNIT_SRC}
-                                  ${LIBMIDORI}
-                                  )
-            install(TARGETS ${UNIT_SRC}
+            add_library(${WEB_NAME} MODULE ${WEB_EXTENSION_C})
+            target_link_libraries(${WEB_NAME}
+                                  ${LIBMIDORI2}
+                                   )
+            install(TARGETS ${WEB_NAME}
                     LIBRARY DESTINATION ${EXTENSIONDIR}
                     )
-            # extensions with vala code get the lenient VALA_CFLAGS
-            # others get the usual CFLAGS with -Wall and -Werror
-	    if (UNIT_FILES_VALA)
-		set_target_properties(${UNIT_SRC} PROPERTIES
-				      COMPILE_FLAGS ${VALA_CFLAGS}
-				      )
-	    else ()
-		set_target_properties(${UNIT_SRC} PROPERTIES
-				      COMPILE_FLAGS ${CFLAGS}
-				      )
-	    endif ()
+            # Extensions with Vala code get the lenient VALA_CFLAGS
+            set_target_properties(${WEB_NAME} PROPERTIES
+                                  COMPILE_FLAGS ${VALA_CFLAGS}
+                                  )
+            list(REMOVE_ITEM source ${FILE})
+
+            # Mandatory unit testing
+            add_test(NAME "test-${WEB_NAME}" COMMAND $<TARGET_FILE:midori> -t $<TARGET_FILE:${WEB_NAME}>)
+            contain_test("test-${WEB_NAME}" $<TARGET_FILE:midori> -t $<TARGET_FILE:${WEB_NAME}>)
+        elseif (VALA_EXTENSION GREATER -1)
+            list(APPEND SOURCE_VALA ${FILE})
         endif ()
-    endif ()
-endforeach ()
-
-foreach(UNIT_SRC ${EXTENSIONS})
-    string(FIND ${UNIT_SRC} ".vala" UNIT_EXTENSION)
-    if (UNIT_EXTENSION GREATER -1)
-        string(REPLACE ".vala" "" UNIT ${UNIT_SRC})
-        include(ValaPrecompile)
-        vala_precompile(UNIT_SRC_C ${UNIT}
-            ${UNIT_SRC}
+    endforeach()
+    if (SOURCE_VALA)
+        vala_precompile(SOURCE_C ${name}
+            ${SOURCE_VALA}
         PACKAGES
             ${PKGS}
         OPTIONS
-            ${VALAFLAGS}
-            --use-header="${CMAKE_PROJECT_NAME}-core.h"
+             ${VALAFLAGS}
         GENERATE_HEADER
-            ${UNIT}
+            ${name}
         CUSTOM_VAPIS
-            ${EXTRA_VAPIS}
+             ${EXTRA_VAPIS}
             "${CMAKE_SOURCE_DIR}/midori/midori.vapi"
             "${CMAKE_BINARY_DIR}/midori/${LIBMIDORI}.vapi"
         )
-        add_library(${UNIT} MODULE ${UNIT_SRC_C})
-        target_link_libraries(${UNIT}
+        set(source ${SOURCE_C})
+    endif ()
+    if (source)
+        add_library(${name} MODULE ${source})
+        target_link_libraries(${name}
                               ${LIBMIDORI}
                               )
-        set_target_properties(${UNIT} PROPERTIES
-                              COMPILE_FLAGS "${VALA_CFLAGS}"
-                              )
-        install(TARGETS ${UNIT}
+        install(TARGETS ${name}
                 LIBRARY DESTINATION ${EXTENSIONDIR}
                 )
+        if (SOURCE_VALA)
+            # Extensions with Vala code get the lenient VALA_CFLAGS
+            set_target_properties(${name} PROPERTIES
+                                  COMPILE_FLAGS ${VALA_CFLAGS}
+                                  )
+        else ()
+            set_target_properties(${name} PROPERTIES
+                                  COMPILE_FLAGS ${CFLAGS}
+                                  )
+        endif ()
+        # Optional unit test
+        add_test(NAME "test-${name}" COMMAND $<TARGET_FILE:midori> -t $<TARGET_FILE:${name}>)
+        contain_test("test-${name}" $<TARGET_FILE:midori> -t $<TARGET_FILE:${name}>)
+    endif ()
+endmacro(build_extension)
+
+foreach(UNIT_SRC ${EXTENSIONS})
+    string(FIND ${UNIT_SRC} ".c" UNIT_EXTENSION)
+    if (UNIT_EXTENSION GREATER -1)
+        string(REPLACE ".c" "" UNIT ${UNIT_SRC})
+        build_extension(${UNIT} ${UNIT_SRC})
+    endif ()
+
+    string(FIND ${UNIT_SRC} "." UNIT_EXTENSION)
+    if (UNIT_EXTENSION GREATER -1)
+        file(GLOB UNIT_FILES RELATIVE ${CMAKE_CURRENT_SOURCE_DIR} "${UNIT_SRC}/*.c" "${UNIT_SRC}/*.vala")
+        build_extension(${UNIT_SRC} ${UNIT_FILES})
+    endif ()
+
+    string(FIND ${UNIT_SRC} ".vala" UNIT_EXTENSION)
+    if (UNIT_EXTENSION GREATER -1)
+        string(REPLACE ".vala" "" UNIT ${UNIT_SRC})
+        build_extension(${UNIT} ${UNIT_SRC})
     endif ()
 endforeach ()

=== modified file 'extensions/about.vala'
--- extensions/about.vala	2015-06-11 22:33:48 +0000
+++ extensions/about.vala	2015-06-22 22:20:28 +0000
@@ -140,7 +140,12 @@
             GLib.StringBuilder ns_plugins = new GLib.StringBuilder ();
             view.list_plugins (ns_plugins, true);
 
-            /* TODO: list active extensions */
+#if HAVE_PEAS
+            ns_plugins.append_printf ("</table><h2>%s</h2><table>", _("Extensions"));
+            var engine = Peas.Engine.get_default ();
+            foreach (unowned Peas.PluginInfo info in engine.get_plugin_list ())
+                ns_plugins.append_printf ("<tr><td>%s <em>%s</em></td></tr>\n", info.get_name (), info.get_module_name ());
+#endif
 
             this.load_html (view, contents.printf (
                 _("Version numbers in brackets show the version used at runtime."),

=== added file 'extensions/example.py'
--- extensions/example.py	1970-01-01 00:00:00 +0000
+++ extensions/example.py	2015-06-22 22:20:28 +0000
@@ -0,0 +1,14 @@
+# -*- coding: utf-8 py-indent-offset: 4 -*-
+from gi.repository import GObject, Gtk, Peas
+import os, gettext
+
+class ExamplePlugin(GObject.Object, Peas.Activatable):
+    __gtype_name__ = "ExamplePlugin"
+    object = GObject.property(type=GObject.Object)
+
+    def __init__(self):
+        print("Example init")
+        GObject.Object.__init__(self)
+
+    def do_activate(self):
+        print("Example %s" % (self.object.props.uri))

=== added file 'extensions/examplepy.plugin'
--- extensions/examplepy.plugin	1970-01-01 00:00:00 +0000
+++ extensions/examplepy.plugin	2015-06-22 22:20:28 +0000
@@ -0,0 +1,9 @@
+[Plugin]
+Loader=python
+Module=example
+IAge=3
+Name=Example in Python
+Name[de]=Beispiel in Python
+Author=Christian Dywan <[e-mail]>
+Copyright=Copyright © 2015 Christian Dywan
+Website=http://www.midori-browser.org

=== added file 'extensions/extension-manager.vala'
--- extensions/extension-manager.vala	1970-01-01 00:00:00 +0000
+++ extensions/extension-manager.vala	2015-06-22 22:20:28 +0000
@@ -0,0 +1,273 @@
+/*
+ Copyright (C) 2008-2015 Christian Dywan <[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 Extensions {
+    public class Sidebar : Gtk.VBox, Midori.Viewable {
+        Gtk.Toolbar? toolbar = null;
+        Gtk.ListStore store = new Gtk.ListStore (1, typeof (GLib.Object));
+        Gtk.TreeView treeview;
+        Midori.App app;
+
+        void on_add_item (Katze.Array extensions, GLib.Object item) {
+            var extension = (Midori.Extension)item;
+            Gtk.TreeIter iter;
+            store.append (out iter);
+            store.set (iter, 0, extension);
+            extension.activate.connect (on_activate);
+            extension.deactivate.connect (on_deactivate);
+        }
+
+        void on_activate (Midori.Extension extension, Midori.App app) {
+            treeview.queue_draw ();
+        }
+
+        void on_deactivate (Midori.Extension extension) {
+            treeview.queue_draw ();
+        }
+
+        public unowned string get_stock_id () {
+            return Midori.Stock.EXTENSION;
+        }
+
+        public unowned string get_label () {
+            return _("Extensions");
+        }
+
+        public Gtk.Widget get_toolbar () {
+            if (toolbar == null) {
+                toolbar = new Gtk.Toolbar ();
+                toolbar.set_icon_size (Gtk.IconSize.BUTTON);
+            }
+            return toolbar;
+        }
+
+        internal Sidebar (Midori.App app) {
+            Gtk.TreeViewColumn column;
+
+            treeview = new Gtk.TreeView.with_model (store);
+            treeview.button_press_event.connect (on_button_pressed);
+            store.set_sort_column_id (0, Gtk.SortType.ASCENDING);
+            store.set_sort_func (0, tree_sort_func);
+            treeview.headers_visible = false;
+
+            column = new Gtk.TreeViewColumn ();
+            Gtk.CellRendererToggle renderer_toggle = new Gtk.CellRendererToggle ();
+            column.pack_start (renderer_toggle, false);
+            column.set_cell_data_func (renderer_toggle, on_render_tick);
+            renderer_toggle.toggled.connect (on_renderer_toggled);
+            treeview.append_column (column);
+
+            column = new Gtk.TreeViewColumn ();
+            Gtk.CellRendererPixbuf renderer_icon = new Gtk.CellRendererPixbuf ();
+            column.pack_start (renderer_icon, false);
+            column.set_cell_data_func (renderer_icon, on_render_icon);
+            treeview.append_column (column);
+
+            column = new Gtk.TreeViewColumn ();
+            column.set_sizing (Gtk.TreeViewColumnSizing.AUTOSIZE);
+            Gtk.CellRendererText renderer_text = new Gtk.CellRendererText ();
+            column.pack_start (renderer_text, true);
+            column.set_expand (true);
+            column.set_cell_data_func (renderer_text, on_render_text);
+            treeview.append_column (column);
+
+            column = new Midori.ExtensionsColumn ();
+            (column as Midori.ExtensionsColumn).row_clicked.connect (on_preferences_clicked);
+            Gtk.CellRendererPixbuf renderer_preferences = new Gtk.CellRendererPixbuf ();
+            column.pack_start (renderer_preferences, false);
+            column.set_sizing (Gtk.TreeViewColumnSizing.FIXED);
+            column.set_fixed_width (30);
+            column.set_cell_data_func (renderer_preferences, on_render_preferences);
+            treeview.append_column (column);
+            treeview.row_activated.connect (on_row_activated);
+
+            treeview.show ();
+            pack_start (treeview, true, true, 0);
+            assert (treeview.get_n_columns () > 0);
+
+            Katze.Array extensions = app.extensions;
+            extensions.add_item.connect (on_add_item);
+            foreach (GLib.Object extension in extensions.get_items ())
+                on_add_item (extensions, extension);
+
+            this.app = app;
+
+#if HAVE_PEAS
+            var engine = Peas.Engine.get_default ();
+            engine.rescan_plugins ();
+            foreach (unowned Peas.PluginInfo info in engine.get_plugin_list ()) {
+                var extension = (Midori.Extension)GLib.Object.new (typeof (Midori.Extension),
+                    name: info.get_name (),
+                    description: info.get_description (),
+                    version: info.get_version () + Midori.VERSION_SUFFIX,
+                    website: info.get_website (),
+                    authors: string.joinv (",", info.get_authors ()));
+                extension.set_data<string?> ("filename", info.get_module_name ());
+                extension.activate.connect ((app) => { engine.try_load_plugin (info); });
+                extension.deactivate.connect (() => { engine.try_unload_plugin (info); });
+                extensions.add_item (extension);
+            }
+#endif
+        }
+
+        int tree_sort_func (Gtk.TreeModel model, Gtk.TreeIter a, Gtk.TreeIter b) {
+            Midori.Extension e1, e2;
+            model.get (a, 0, out e1);
+            model.get (b, 0, out e2);
+            return strcmp (e1.name, e2.name);
+        }
+
+        bool on_button_pressed (Gtk.Widget widget, Gdk.EventButton event) {
+            bool ret = false;
+            Gtk.TreePath path;
+            Gtk.TreeViewColumn column;
+            if (treeview.get_path_at_pos ((int)event.x, (int)event.y, out path, out column, null, null)) {
+                if (path != null) {
+                    if (column is Midori.ExtensionsColumn) {
+                        uint signal_id = Signal.lookup ("row-clicked", typeof (Midori.ExtensionsColumn));
+                        if (signal_id > 0 && Signal.has_handler_pending (column, signal_id, 0, false)) {
+                            (column as Midori.ExtensionsColumn).row_clicked (treeview, path);
+                            ret = true;
+                        }
+                    }
+                }
+            }
+            return ret;
+        }
+
+        void on_renderer_toggled (Gtk.CellRendererToggle renderer, string path) {
+            Gtk.TreeIter iter;
+            if (store.get_iter_from_string (out iter, path)) {
+                Midori.Extension extension;
+                store.get (iter, 0, out extension);
+                if (extension.is_active ())
+                    extension.deactivate ();
+                else if (extension.is_prepared ())
+                    extension.activate (app);
+                /* Make it easy for listeners to see that extensions changed */
+                app.extensions.update ();
+            }
+        }
+
+        void on_render_tick (Gtk.CellLayout column, Gtk.CellRenderer renderer,
+            Gtk.TreeModel model, Gtk.TreeIter iter) {
+
+            Midori.Extension extension;
+            model.get (iter, 0, out extension);
+            renderer.set ("activatable", extension.is_prepared (),
+                          "active", extension.is_active ()
+                                 || extension.get_data<string>("static") != null,
+                          "xpad", 4);
+        }
+
+        void on_render_icon (Gtk.CellLayout column, Gtk.CellRenderer renderer,
+            Gtk.TreeModel model, Gtk.TreeIter iter) {
+
+            Midori.Extension extension;
+            model.get (iter, 0, out extension);
+            renderer.set ("stock-id", Midori.Stock.EXTENSION,
+                          "stock-size", Gtk.IconSize.BUTTON,
+                          "sensitive", extension.is_prepared (),
+                          "xpad", 4);
+        }
+
+        void on_render_text (Gtk.CellLayout column, Gtk.CellRenderer renderer,
+            Gtk.TreeModel model, Gtk.TreeIter iter) {
+
+            Midori.Extension extension;
+            model.get (iter, 0, out extension);
+            renderer.set ("markup", Markup.printf_escaped ("<b>%s</b> %s\n%s",
+                extension.name, extension.version ?? "", extension.description),
+                          "ellipsize", Pango.EllipsizeMode.END,
+                          "sensitive", extension.is_prepared ());
+        }
+
+        void on_render_preferences (Gtk.CellLayout column, Gtk.CellRenderer renderer,
+            Gtk.TreeModel model, Gtk.TreeIter iter) {
+
+            Midori.Extension extension;
+            model.get (iter, 0, out extension);
+            renderer.set ("stock-id", Gtk.Stock.PREFERENCES,
+                          "stock-size", Gtk.IconSize.BUTTON,
+                          "visible", extension.has_preferences (),
+                          "sensitive", extension.is_active (),
+                          "xpad", 4);
+        }
+
+        void on_preferences_clicked (Gtk.TreeView treeview, Gtk.TreePath path) {
+            Gtk.TreeIter iter;
+            if (store.get_iter (out iter, path)) {
+                Midori.Extension extension;
+                store.get (iter, 0, out extension);
+                if (extension.is_active ())
+                    extension.open_preferences ();
+            }
+        }
+
+        void on_row_activated (Gtk.TreeView treeview, Gtk.TreePath path, Gtk.TreeViewColumn column) {
+            Gtk.TreeIter iter;
+            if (store.get_iter (out iter, path)) {
+                Midori.Extension extension;
+                store.get (iter, 0, out extension);
+                if (extension.is_active ())
+                    extension.deactivate ();
+                else if (extension.is_prepared ())
+                    extension.activate (app);
+                /* Make it easy for listeners to see that extensions changed */
+                app.extensions.update ();
+            }
+        }
+    }
+
+    class Manager : Midori.Extension {
+        void activated (Midori.App app) {
+            foreach (var browser in app.get_browsers ())
+                browser_added (browser);
+            app.add_browser.connect (browser_added);
+        }
+
+        void browser_added (Midori.Browser browser) {
+            browser.show_preferences.connect (show_preferences);
+        }
+
+        void show_preferences (Katze.Preferences preferences) {
+            /* Check for new extensions */
+            Midori.Extension.load_from_folder (get_app (), null, false);
+            /* Hide if there are no extensions at all */
+            if (get_app ().extensions.is_empty ())
+                return;
+            /* Reset frozen list: allow active extensions to be saved */
+            get_app ().set_data<string[]?> ("extensions", null);
+
+            var viewable = new Sidebar (get_app ());
+            viewable.show ();
+            var scrolled = new Gtk.ScrolledWindow (null, null);
+            /* For lack of a better way of keeping descriptions visible */
+            scrolled.show ();
+            scrolled.hscrollbar_policy = Gtk.PolicyType.NEVER;
+            viewable.get_children ().nth_data (0).reparent (scrolled);
+            var category = preferences.add_category (_("Extensions"), Midori.Stock.EXTENSION);
+            category.pack_start (scrolled, true, true, 0);
+        }
+
+        internal Manager () {
+            GLib.Object (name: "Extension Manager",
+                         description: "Manage your extensions",
+                         version: "0.2" + Midori.VERSION_SUFFIX,
+                         authors: "Christian Dywan <[e-mail]>");
+            activate.connect (activated);
+        }
+    }
+}
+
+public Midori.Extension extension_init () {
+    return new Extensions.Manager ();
+}

=== added file 'extensions/hsts.web.plugin'
--- extensions/hsts.web.plugin	1970-01-01 00:00:00 +0000
+++ extensions/hsts.web.plugin	2015-06-22 22:20:28 +0000
@@ -0,0 +1,8 @@
+[Plugin]
+Module=hsts_web_hsts_web
+IAge=3
+Name=HSTS
+Description=HTTP Strict Transport Security
+Author=Christian Dywan <[e-mail]>
+Copyright=Copyright © 2015 Christian Dywan
+Website=http://www.midori-browser.org

=== added file 'extensions/hsts.web.vala'
--- extensions/hsts.web.vala	1970-01-01 00:00:00 +0000
+++ extensions/hsts.web.vala	2015-06-22 22:20:28 +0000
@@ -0,0 +1,176 @@
+/*
+ Copyright (C) 2012-2014 Christian Dywan <[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 HSTS {
+    public class Directive {
+        public Soup.Date? expires = null;
+        public bool sub_domains = false;
+
+        public Directive (bool include_sub_domains) {
+            expires = new Soup.Date.from_now (int.MAX);
+            sub_domains = include_sub_domains;
+        }
+
+        public Directive.from_header (string header) {
+            var param_list = Soup.header_parse_param_list (header);
+            if (param_list == null)
+                return;
+
+            string? max_age = param_list.lookup ("max-age");
+            if (max_age != null)
+                expires = new Soup.Date.from_now (max_age.to_int ());
+            if ("includeSubDomains" in header)
+                sub_domains = true;
+            Soup.header_free_param_list (param_list);
+        }
+
+        public bool is_valid () {
+            return expires != null && !expires.is_past ();
+        }
+    }
+
+    public class Whitelist : Object {
+        HashTable<string, Directive> whitelist;
+        string preset = "/etc/xdg/midori/hsts";
+        File config;
+
+        public Whitelist () {
+            whitelist = new HashTable<string, Directive> (str_hash, str_equal);
+            read_cache.begin (File.new_for_path (preset));
+            // FIXME: config = File.new_for_path (Midori.Paths.get_config_filename_for_writing ("hsts"));
+            string config_dir = Path.build_path (Path.DIR_SEPARATOR_S,
+                Environment.get_user_config_dir (), "midori");
+            config = File.new_for_path (Path.build_path (Path.DIR_SEPARATOR_S, config_dir, "hsts"));
+            read_cache.begin (config);
+        }
+
+        async void read_cache (File file) {
+            try {
+                var stream = new DataInputStream (yield file.read_async ());
+                do {
+                    string? line = yield stream.read_line_async ();
+                    if (line == null)
+                        break;
+                    string[] parts = line.split (" ", 2);
+                    if (parts[0] == null || parts[1] == null)
+                        break;
+                    var directive = new Directive.from_header (parts[1]);
+                    if (directive.is_valid ())
+                        append_to_whitelist (parts[0], directive);
+                } while (true);
+            } catch (IOError.NOT_FOUND exist_error) {
+                /* It's no error if no cache file exists */
+            } catch (Error error) {
+                warning ("Failed to read cache %s: %s", file.get_path (), error.message);
+            }
+        }
+
+        public bool should_secure_host (string host) {
+            Directive? directive = whitelist.lookup (host);
+            if (directive == null)
+                directive = whitelist.lookup ("*." + host);
+            return directive != null && directive.is_valid ();
+        }
+
+        void append_to_whitelist (string host, Directive directive) {
+            whitelist.insert (host, directive);
+            if (directive.sub_domains)
+                whitelist.insert ("*." + host, directive);
+        }
+
+        async void append_to_cache (string host, string header) {
+            /* FIXME: Don't write in private browsing */
+
+            try {
+                var stream = yield config.append_to_async (FileCreateFlags.NONE);
+                yield stream.write_async ((host + " " + header + "\n").data);
+                yield stream.flush_async ();
+            }
+            catch (Error error) {
+                critical ("Failed to update %s: %s", config.get_path (), error.message);
+            }
+        }
+
+        public Directive? strict_transport_security_handled (string host, Soup.MessageHeaders headers) {
+            unowned string? hsts = headers.get_one ("Strict-Transport-Security");
+            if (hsts == null)
+                return null;
+
+            var directive = new Directive.from_header (hsts);
+            if (directive.is_valid ()) {
+                append_to_whitelist (host, directive);
+                append_to_cache.begin (host, hsts);
+            }
+            return directive;
+        }
+
+    }
+
+    public class WebPage : Peas.ExtensionBase, Midori.WebPageActivatable {
+        Whitelist whitelist;
+        bool debug = false;
+
+        public WebKit.WebPage web_page { owned get; set; }
+
+        construct {
+            if (strcmp (Environment.get_variable ("MIDORI_DEBUG"), "hsts") == 0)
+                debug = true;
+            whitelist = new Whitelist ();
+        }
+
+        public void document_loaded (WebKit.DOM.Document dom_document) {
+        }
+
+        public bool send_request (WebKit.URIRequest request, WebKit.URIResponse? redirected_response) {
+            Soup.MessageHeaders? headers = request.get_http_headers ();
+            if (headers == null || !request.uri.contains ("/"))
+                return false;
+
+            string host = request.uri.split ("/")[2];
+            if (whitelist.should_secure_host (host)) {
+                request.uri = request.uri.replace ("http://", "https://");
+                if (debug)
+                    stdout.printf ("HSTS: Enforce %s\n", host);
+            } else if (request.uri.has_prefix ("http://")) {
+                var directive = whitelist.strict_transport_security_handled (host, headers);
+                if (debug)
+                    stdout.printf ("HSTS: %s valid? %s\n",
+                        host, directive != null ? directive.is_valid ().to_string () : "/");
+            }
+            return false;
+        }
+    }
+}
+
+[ModuleInit]
+public static void peas_register_types (GLib.TypeModule module) {
+    var object_module = (Peas.ObjectModule)module;
+    object_module.register_extension_type (typeof (Midori.WebPageActivatable), typeof (HSTS.WebPage));
+}
+
+void hsts_directive () {
+    HSTS.Directive d;
+    d = new HSTS.Directive.from_header ("max-age=31536000");
+    assert (d.is_valid () && !d.sub_domains);
+    d = new HSTS.Directive.from_header ("max-age=15768000 ; includeSubDomains");
+    assert (d.is_valid () && d.sub_domains);
+
+    /* Invalid */
+    d = new HSTS.Directive.from_header ("");
+    assert (!d.is_valid () && !d.sub_domains);
+    d = new HSTS.Directive.from_header ("includeSubDomains");
+    assert (!d.is_valid () && d.sub_domains);
+}
+
+public void extension_test () {
+    Test.add_func ("/hsts/directive", hsts_directive);
+}
+

=== removed file 'extensions/tabs-minimized.c'
--- extensions/tabs-minimized.c	2011-11-08 00:53:53 +0000
+++ extensions/tabs-minimized.c	1970-01-01 00:00:00 +0000
@@ -1,87 +0,0 @@
-/*
- Copyright (C) 2008-2010 Christian Dywan <[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.
-*/
-
-#include <midori/midori.h>
-
-static void
-tabs_minimized_app_add_browser_cb (MidoriApp*       app,
-                                   MidoriBrowser*   browser,
-                                   MidoriExtension* extension);
-
-static void
-tabs_minimized_add_tab_cb (MidoriBrowser*   browser,
-                           MidoriView*      tab,
-                           MidoriExtension* extension);
-
-static void
-tabs_minimized_deactivate_cb (MidoriExtension* extension,
-                              MidoriBrowser*   browser)
-{
-    MidoriApp* app = midori_extension_get_app (extension);
-
-    g_signal_handlers_disconnect_by_func (
-        extension, tabs_minimized_deactivate_cb, browser);
-    g_signal_handlers_disconnect_by_func (
-        app, tabs_minimized_app_add_browser_cb, extension);
-    g_signal_handlers_disconnect_by_func (
-        browser, tabs_minimized_add_tab_cb, extension);
-}
-
-static void
-tabs_minimized_add_tab_cb (MidoriBrowser*   browser,
-                           MidoriView*      tab,
-                           MidoriExtension* extension)
-{
-    g_object_set (tab, "minimized", TRUE, NULL);
-}
-
-static void
-tabs_minimized_app_add_browser_cb (MidoriApp*       app,
-                                   MidoriBrowser*   browser,
-                                   MidoriExtension* extension)
-{
-    g_signal_connect (browser, "add-tab",
-        G_CALLBACK (tabs_minimized_add_tab_cb), extension);
-    g_signal_connect (extension, "deactivate",
-        G_CALLBACK (tabs_minimized_deactivate_cb), browser);
-}
-
-static void
-tabs_minimized_activate_cb (MidoriExtension* extension,
-                            MidoriApp*       app)
-{
-    KatzeArray* browsers;
-    MidoriBrowser* browser;
-
-    browsers = katze_object_get_object (app, "browsers");
-    KATZE_ARRAY_FOREACH_ITEM (browser, browsers)
-        tabs_minimized_app_add_browser_cb (app, browser, extension);
-    g_object_unref (browsers);
-    g_signal_connect (app, "add-browser",
-        G_CALLBACK (tabs_minimized_app_add_browser_cb), extension);
-}
-
-MidoriExtension*
-extension_init (void)
-{
-    MidoriExtension* extension = g_object_new (MIDORI_TYPE_EXTENSION,
-        "name", _("Only Icons on Tabs by default"),
-        "description", _("New tabs have no label by default"),
-        "version", "0.1" MIDORI_VERSION_SUFFIX,
-        "authors", "MonkeyOfDoom <[e-mail]>",
-        NULL);
-
-    g_signal_connect (extension, "activate",
-        G_CALLBACK (tabs_minimized_activate_cb), NULL);
-
-    return extension;
-}
-

=== added file 'extensions/tabs-minimized.plugin'
--- extensions/tabs-minimized.plugin	1970-01-01 00:00:00 +0000
+++ extensions/tabs-minimized.plugin	2015-06-22 22:20:28 +0000
@@ -0,0 +1,9 @@
+[Plugin]
+Module=tabs-minimized
+IAge=3
+Name=Only Icons on Tabs by default
+Description=New tabs have no label by default
+Version=0.1
+Author=MonkeyOfDoom <[e-mail]>
+Copyright=Copyright © 2008-2010 Christian Dywan
+Website=http://www.midori-browser.org

=== added file 'extensions/tabs-minimized.vala'
--- extensions/tabs-minimized.vala	1970-01-01 00:00:00 +0000
+++ extensions/tabs-minimized.vala	2015-06-22 22:20:28 +0000
@@ -0,0 +1,68 @@
+/*
+ Copyright (C) 2008-2010 Christian Dywan <[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 Minimizer {
+    class Manager : Midori.Extension {
+        internal Manager () {
+            GLib.Object (name: _("Only Icons on Tabs by default"),
+                         description: _("New tabs have no label by default"),
+                         version: "0.1" + Midori.VERSION_SUFFIX,
+                         authors: "MonkeyOfDoom <[e-mail]>");
+            activate.connect (activated);
+            deactivate.connect (deactivated);
+        }
+
+        void activated (Midori.App app) {
+            foreach (var browser in app.get_browsers ())
+                browser_added (browser);
+            app.add_browser.connect (browser_added);
+        }
+
+        void deactivated () {
+            var app = get_app ();
+            app.add_browser.disconnect (browser_added);
+            foreach (var browser in app.get_browsers ())
+                browser.add_tab.disconnect (tab_added);
+        }
+
+        void browser_added (Midori.Browser browser) {
+            browser.add_tab.connect (tab_added);
+            foreach (var tab in browser.get_tabs ())
+                tab_added (tab);
+        }
+
+        void tab_added (Midori.Tab tab) {
+            tab.minimized = true;
+        }
+    }
+}
+
+public Midori.Extension extension_init () {
+    return new Minimizer.Manager ();
+}
+
+#if HAVE_PEAS
+namespace Minimizer {
+    public class Tab : Peas.ExtensionBase, Midori.TabActivatable {
+        public Midori.Tab tab { owned get; set; }
+
+        public void created (string uri) {
+            tab.minimized = true;
+        }
+    }
+}
+
+[ModuleInit]
+public static void peas_register_types (GLib.TypeModule module) {
+    var object_module = (Peas.ObjectModule)module;
+    object_module.register_extension_type (typeof (Midori.TabActivatable), typeof (Minimizer.Tab));
+}
+#endif

=== added file 'extensions/web-extension.web.vala'
--- extensions/web-extension.web.vala	1970-01-01 00:00:00 +0000
+++ extensions/web-extension.web.vala	2015-06-22 22:20:28 +0000
@@ -0,0 +1,68 @@
+/*
+ Copyright (C) 2015 Christian Dywan <[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 WebExtension {
+    public class Extension : Object {
+        bool debug = false;
+        Peas.Engine engine;
+
+        public Extension (WebKit.WebExtension web_extension, GLib.Variant user_data) {
+            debug = (strcmp (Environment.get_variable ("MIDORI_DEBUG"), "paths") == 0);
+            if (debug)
+                stdout.printf ("WebKit.WebExtension: %s\n", user_data.print (true));
+            var config = (GLib.HashTable<string, string>)user_data;
+            var keyfile = new GLib.KeyFile ();
+            try {
+                keyfile.load_from_file (config["config_dir"] + "/config", GLib.KeyFileFlags.NONE);
+                string plugins = keyfile.get_string ("settings", "plugins");
+
+                engine = Peas.Engine.get_default ();
+                engine.enable_loader ("python");
+                foreach (unowned string path in config["plugin_dirs"].split (","))
+                    engine.add_search_path (path, null);
+                engine.loaded_plugins = plugins.split (",");
+
+                web_extension.page_created.connect (page_created);
+            } catch (GLib.Error error) {
+                // Missing config file or plugins key is no error
+            }
+        }
+
+        void page_created (WebKit.WebPage web_page) {
+            var extensions = new Peas.ExtensionSet (null,
+                typeof (Midori.WebPageActivatable), "web-page", web_page);
+            web_page.set_data<Peas.ExtensionSet> ("extensions", extensions);
+            web_page.send_request.connect (send_request);
+        }
+
+        public void document_loaded (WebKit.WebPage web_page) {
+            var extensions = web_page.get_data<Peas.ExtensionSet> ("extensions");
+            extensions.foreach ((@set, info, extension) => {
+                ((Midori.WebPageActivatable)extension).document_loaded (web_page.get_dom_document ());
+            });
+        }
+
+        bool send_request (WebKit.WebPage web_page, WebKit.URIRequest request, WebKit.URIResponse? redirected_response) {
+            bool block = false;
+            var extensions = web_page.get_data<Peas.ExtensionSet> ("extensions");
+            extensions.foreach ((@set, info, extension) => {
+                if (((Midori.WebPageActivatable)extension).send_request (request, redirected_response))
+                    block = true;
+            });
+            return block;
+        }
+    }
+}
+
+WebExtension.Extension? web_extension;
+public void webkit_web_extension_initialize_with_user_data (WebKit.WebExtension extension, GLib.Variant user_data) {
+    web_extension = new WebExtension.Extension (extension, user_data);
+}

=== added directory 'ipc'
=== added file 'ipc/CMakeLists.txt'
--- ipc/CMakeLists.txt	1970-01-01 00:00:00 +0000
+++ ipc/CMakeLists.txt	2015-06-22 22:20:28 +0000
@@ -0,0 +1,50 @@
+include(ValaPrecompile)
+
+set(LIBMIDORI2_VERSION 0.6.0)
+set(LIBMIDORI2_SOVERSION 0)
+file(GLOB LIBMIDORI2_SOURCE *.vala)
+
+vala_precompile(LIBMIDORI2_SOURCE_C ${LIBMIDORI2}
+    ${LIBMIDORI2_SOURCE}
+PACKAGES
+    ${PKGS}
+CUSTOM_VAPIS
+    "${CMAKE_SOURCE_DIR}/midori/webkit2gtk-web-extension-4.0.vapi"
+OPTIONS
+    ${VALAFLAGS}
+GENERATE_VAPI
+    "${LIBMIDORI2}"
+GENERATE_HEADER
+    "${LIBMIDORI2}"
+)
+
+add_library("${LIBMIDORI2}" SHARED ${LIBMIDORI2_SOURCE_C})
+target_link_libraries("${LIBMIDORI2}"
+                      ${DEPS_LIBRARIES}
+                      ${PEAS_LIBRARIES}
+                      )
+set_target_properties("${LIBMIDORI2}" PROPERTIES
+                      COMPILE_FLAGS "${VALA_CFLAGS}"
+                      POSITION_INDEPENDENT_CODE ON
+                      VERSION ${LIBMIDORI2_VERSION}
+                      SOVERSION ${LIBMIDORI2_SOVERSION}
+                      )
+
+include_directories(
+                    ${CMAKE_SOURCE_DIR}
+                    ${CMAKE_CURRENT_SOURCE_DIR}
+                    ${CMAKE_BINARY_DIR}
+                    ${DEPS_INCLUDE_DIRS}
+                    ${OPTS_INCLUDE_DIRS}
+                    ${DEPS_GTK_INCLUDE_DIRS}
+                    )
+if (WIN32)
+    install(TARGETS ${LIBMIDORI2}
+            LIBRARY DESTINATION ${CMAKE_INSTALL_BINDIR}
+            RUNTIME DESTINATION ${CMAKE_INSTALL_BINDIR}
+            )
+else ()
+    install(TARGETS ${LIBMIDORI2}
+            LIBRARY DESTINATION ${CMAKE_INSTALL_LIBDIR}
+            )
+endif ()

=== added file 'ipc/ipc-tab.vala'
--- ipc/ipc-tab.vala	1970-01-01 00:00:00 +0000
+++ ipc/ipc-tab.vala	2015-06-22 22:20:28 +0000
@@ -0,0 +1,19 @@
+/*
+ Copyright (C) 2015 Christian Dywan <[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 Midori {
+    public interface WebPageActivatable : GLib.Object {
+        public abstract WebKit.WebPage web_page { owned get; set; }
+
+        public abstract void document_loaded (WebKit.DOM.Document dom_document);
+        public abstract bool send_request (WebKit.URIRequest request, WebKit.URIResponse? redirected_response);
+    }
+}

=== modified file 'katze/katze.vapi'
--- katze/katze.vapi	2014-02-22 14:06:19 +0000
+++ katze/katze.vapi	2015-06-22 22:20:28 +0000
@@ -21,6 +21,7 @@
         public uint get_length ();
         public GLib.List<unowned Item> get_items ();
         public bool is_empty ();
+        public void update ();
     }
 
     [CCode (cheader_filename = "katze/katze.h")]

=== modified file 'katze/midori-paths.vala'
--- katze/midori-paths.vala	2015-06-11 22:33:48 +0000
+++ katze/midori-paths.vala	2015-06-22 22:20:28 +0000
@@ -99,6 +99,7 @@
 
         public static void init (RuntimeMode new_mode, string? config) {
             assert (mode == RuntimeMode.UNDEFINED);
+            assert (exec_path != null);
             assert (new_mode != RuntimeMode.UNDEFINED);
             mode = new_mode;
             if (mode == RuntimeMode.PORTABLE || mode == RuntimeMode.PRIVATE)
@@ -147,17 +148,48 @@
                 user_data_dir = Environment.get_user_data_dir ();
                 tmp_dir = get_runtime_dir ();
             }
+
+#if HAVE_PEAS
+            var paths = new GLib.StringBuilder ();
+            paths.append (Path.build_filename (user_data_dir, PACKAGE_NAME, "plugins"));
+            paths.append_c (',');
+            paths.append (Path.build_filename (get_lib_path (PACKAGE_NAME)));
+            string plugin_dirs = paths.str;
+
+            var engine = Peas.Engine.get_default ();
+            engine.ref ();
+            engine.load_plugin.connect ((info) => {
+                if (strcmp (Environment.get_variable ("MIDORI_DEBUG"), "paths") == 0)
+                    stdout.printf ("Plugin %s loaded (%s)\n", info.get_name (), info.get_module_name ());
+            });
+            engine.enable_loader ("python");
+            foreach (unowned string path in plugin_dirs.split (","))
+                engine.add_search_path (path, null);
+            if (strcmp (Environment.get_variable ("MIDORI_DEBUG"), "paths") == 0) {
+                stdout.printf ("plugins: %s\n", plugin_dirs);
+                foreach (unowned Peas.PluginInfo info in engine.get_plugin_list ())
+                    stdout.printf ("Plugin %s (%s)\n", info.get_name (), info.get_module_name ());
+            }
+#endif
+
 #if HAVE_WEBKIT2
+            var context = WebKit.WebContext.get_default ();
+#if HAVE_PEAS
+            context.set_web_extensions_directory (get_lib_path (PACKAGE_NAME));
+            context.initialize_web_extensions.connect (() => {
+                var user_data = new GLib.HashTable<string, string> (str_hash, str_equal);
+                user_data.insert ("config_dir", config_dir);
+                user_data.insert ("plugin_dirs", plugin_dirs);
+                context.set_web_extensions_initialization_user_data (user_data);
+            });
+#endif
             if (cache_dir != null) {
-                /* Cache and extension dir MUST be set no later than here to work */
-                WebKit.WebContext.get_default ().set_web_extensions_directory (
-                    Path.build_path (Path.DIR_SEPARATOR_S, cache_dir, "wk2ext"));
-                WebKit.WebContext.get_default ().set_disk_cache_directory (
+                context.set_disk_cache_directory (
                     Path.build_path (Path.DIR_SEPARATOR_S, cache_dir, "web"));
             }
 
             if (config_dir != null) {
-                var cookie_manager = WebKit.WebContext.get_default ().get_cookie_manager ();
+                var cookie_manager = context.get_cookie_manager ();
                 cookie_manager.set_persistent_storage (Path.build_filename (config_dir, "cookies.db"),
                     WebKit.CookiePersistentStorage.SQLITE);
             }
@@ -165,7 +197,7 @@
             if (user_data_dir != null) {
                 string folder = Path.build_filename (user_data_dir, "webkit", "icondatabase");
 #if HAVE_WEBKIT2
-                WebKit.WebContext.get_default ().set_favicon_database_directory (folder);
+                context.set_favicon_database_directory (folder);
 #else
                 WebKit.get_favicon_database ().set_path (folder);
 #endif

=== modified file 'midori/main.c'
--- midori/main.c	2014-04-23 03:34:23 +0000
+++ midori/main.c	2015-06-22 22:20:28 +0000
@@ -62,6 +62,7 @@
     gchar* config;
     gboolean private;
     gboolean portable;
+    gchar* test;
     gboolean plain;
     gboolean diagnostic_dialog = FALSE;
     gboolean debug = FALSE;
@@ -85,6 +86,8 @@
        { "portable", 'P', 0, G_OPTION_ARG_NONE, &portable,
        N_("Portable mode, all runtime files are stored in one place"), NULL },
        #endif
+       { "test", 't', 0, G_OPTION_ARG_STRING, &test,
+       N_("Run unit tests for the specified extension"), NULL },
        { "plain", '\0', 0, G_OPTION_ARG_NONE, &plain,
        N_("Plain GTK+ window with WebKit, akin to GtkLauncher"), NULL },
        { "diagnostic-dialog", 'd', 0, G_OPTION_ARG_NONE, &diagnostic_dialog,
@@ -118,6 +121,7 @@
     config = NULL;
     private = FALSE;
     portable = FALSE;
+    test = NULL;
     plain = FALSE;
     run = FALSE;
     snapshot = NULL;
@@ -287,6 +291,52 @@
         return 0;
     }
 
+    if (test != NULL)
+    {
+        g_assert (g_module_supported ());
+
+        GModule* module = g_module_open (test, G_MODULE_BIND_LOCAL);
+        if (module == NULL)
+            g_error (_("Failed to load %s."), test);
+
+        midori_test_init (&argc, &argv);
+
+        typedef void (*extension_test_func)(void);
+        extension_test_func extension_test;
+        /* Midori.Extension */
+        typedef GObject* (*extension_init_func)(void);
+        extension_init_func extension_init;
+        /* WebKit.WebExtension */
+        typedef void (*webkit_web_extension_initialize_func)(GObject* extension);
+        webkit_web_extension_initialize_func web_extension_init;
+
+        if (g_module_symbol (module, "extension_init",
+                             (gpointer) &extension_init))
+        {
+            /* It's fine to conditionally return no extension */
+            if (!(extension_init ()))
+                return 0;
+            midori_paths_init (MIDORI_RUNTIME_MODE_NORMAL, NULL);
+
+            /* Not all extensions have unit tests :-( */
+            if (!g_module_symbol (module, "extension_test", (gpointer) &extension_test))
+                return 0;
+        }
+        else if (g_module_symbol (module, "webkit_web_extension_initialize",
+                                  (gpointer) &web_extension_init)
+              || g_module_symbol (module, "webkit_web_extension_initialize_with_user_data",
+                                  (gpointer) &web_extension_init))
+        {
+            if (!g_module_symbol (module, "extension_test", (gpointer) &extension_test))
+                g_error (_("%s doesn't provide unit tests."), test);
+        }
+        else
+            g_error (_("%s doesn't look like a Midori extension."), test);
+
+        extension_test ();
+        return g_test_run ();
+    }
+
     if (plain)
     {
         GtkWidget* window = gtk_window_new (GTK_WINDOW_TOPLEVEL);

=== modified file 'midori/midori-app.c'
--- midori/midori-app.c	2015-04-14 19:13:57 +0000
+++ midori/midori-app.c	2015-06-22 22:20:28 +0000
@@ -1183,7 +1183,7 @@
 
         { STOCK_BOOKMARKS,    N_("_Bookmarks"), GDK_CONTROL_MASK | GDK_SHIFT_MASK, GDK_KEY_B },
         { STOCK_BOOKMARK_ADD, N_("Add Boo_kmark") },
-        { STOCK_EXTENSION,    N_("_Extensions") },
+        { MIDORI_STOCK_EXTENSION,    N_("_Extensions") },
         { STOCK_HISTORY,      N_("_History"), GDK_CONTROL_MASK | GDK_SHIFT_MASK, GDK_KEY_H },
         { STOCK_SCRIPT,       N_("_Userscripts") },
         { STOCK_STYLE,        N_("User_styles") },

=== modified file 'midori/midori-extension.c'
--- midori/midori-extension.c	2014-04-05 19:15:34 +0000
+++ midori/midori-extension.c	2015-06-22 22:20:28 +0000
@@ -562,6 +562,7 @@
         g_assert (midori_extension_activate_gracefully (app, extension_path, "libtabby." G_MODULE_SUFFIX, activate));
         g_assert (midori_extension_activate_gracefully (app, extension_path, "libopen-with." G_MODULE_SUFFIX, activate));
         g_assert (midori_extension_activate_gracefully (app, extension_path, "libflummi." G_MODULE_SUFFIX, activate));
+        g_assert (midori_extension_activate_gracefully (app, extension_path, "libextension-manager." G_MODULE_SUFFIX, activate));
 
         gint i = 0;
         const gchar* filename;
@@ -623,6 +624,17 @@
     if ((extension = g_hash_table_lookup (modules, module)))
         return extension;
 
+    if (module && g_module_symbol (module, "peas_register_types", (gpointer) &extension_init))
+    {
+        /* Peas plugin: not handled here */
+        return NULL;
+    }
+    if (module && g_module_symbol (module, "webkit_web_extension_initialize_with_user_data", (gpointer) &extension_init))
+    {
+        /* WebKit2 web extension: not handled here */
+        return NULL;
+    }
+
     if (module && g_module_symbol (module, "extension_init",
                                    (gpointer) &extension_init))
     {
@@ -684,6 +696,7 @@
      && strcmp (filename, "libabout." G_MODULE_SUFFIX)
      && strcmp (filename, "libtabby." G_MODULE_SUFFIX)
      && strcmp (filename, "libopen-with." G_MODULE_SUFFIX)
+     && strcmp (filename, "libextension-manager." G_MODULE_SUFFIX)
      && strcmp (filename, "libflummi." G_MODULE_SUFFIX))
         katze_array_add_item (extensions, extension);
 

=== modified file 'midori/midori-frontend.c'
--- midori/midori-frontend.c	2015-06-12 20:43:52 +0000
+++ midori/midori-frontend.c	2015-06-22 22:20:28 +0000
@@ -261,14 +261,6 @@
 }
 
 static void
-midori_browser_show_preferences_cb (MidoriBrowser*    browser,
-                                    KatzePreferences* preferences,
-                                    MidoriApp*        app)
-{
-    midori_preferences_add_extension_category (preferences, app);
-}
-
-static void
 midori_app_add_browser_cb (MidoriApp*     app,
                            MidoriBrowser* browser,
                            gpointer       user_data)
@@ -287,8 +279,6 @@
     /* Extensions */
     g_signal_connect (browser, "show-preferences",
         G_CALLBACK (midori_browser_privacy_preferences_cb), NULL);
-    g_signal_connect (browser, "show-preferences",
-        G_CALLBACK (midori_browser_show_preferences_cb), app);
 
     g_object_unref (panel);
 }

=== modified file 'midori/midori-preferences.c'
--- midori/midori-preferences.c	2015-06-06 13:03:43 +0000
+++ midori/midori-preferences.c	2015-06-22 22:20:28 +0000
@@ -14,7 +14,6 @@
 #include "midori-app.h"
 #include "midori-core.h"
 #include "midori-extension.h"
-#include "panels/midori-extensions.h"
 #include "midori-platform.h"
 
 #include <string.h>
@@ -603,35 +602,6 @@
 midori_preferences_add_extension_category (KatzePreferences*  preferences,
                                            MidoriApp*         app)
 {
-    KatzeArray* array;
-    GtkWidget* scrolled;
-    GtkWidget* addon;
-    GList* children;
-    GtkWidget* page;
-
-    array = katze_object_get_object (app, "extensions");
-
-    midori_extension_load_from_folder (app, NULL, FALSE);
-    /* Reset frozen list: allow active extensions to be saved */
-    g_object_set_data (G_OBJECT (app), "extensions", NULL);
-
-    /* Hide if there are no extensions at all */
-    if (!katze_array_get_nth_item (array, 0))
-    {
-        g_object_unref (array);
-        return;
-    }
-    g_object_unref (array);
-
-    scrolled = gtk_scrolled_window_new (NULL, NULL);
-    /* For lack of a better way of keeping descriptions visible */
-    g_object_set (scrolled, "visible", TRUE, "hscrollbar-policy", GTK_POLICY_NEVER, NULL);
-    addon = g_object_new (MIDORI_TYPE_EXTENSIONS, "app", app, NULL);
-    children = gtk_container_get_children (GTK_CONTAINER (addon));
-    gtk_widget_reparent (g_list_nth_data (children, 0), scrolled);
-    g_list_free (children);
-    page = katze_preferences_add_category (preferences,
-                                           _("Extensions"), STOCK_EXTENSION);
-    gtk_box_pack_start (GTK_BOX (page), scrolled, TRUE, TRUE, 4);
+    /* Superseded by extension-manager */
 }
 

=== modified file 'midori/midori-settings.vala'
--- midori/midori-settings.vala	2013-11-24 21:50:38 +0000
+++ midori/midori-settings.vala	2015-06-22 22:20:28 +0000
@@ -65,6 +65,28 @@
         /* Since: 0.4.8 */
         public uint inactivity_reset { get; set; default = 0; }
 
+#if HAVE_PEAS
+        /* Since: 0.6.0 */
+        public string plugins { get; set; }
+
+        construct {
+            var engine = Peas.Engine.get_default ();
+            notify["plugins"].connect (() => {
+                if (strcmp (Environment.get_variable ("MIDORI_DEBUG"), "paths") == 0)
+                    stdout.printf ("Plugins: %s\n", plugins);
+                engine.loaded_plugins = plugins.split (",");
+            });
+            engine.notify["loaded-plugins"].connect (() => {
+                string plugins_ = string.joinv (",", engine.loaded_plugins);
+                if (plugins == plugins_)
+                    return;
+                if (strcmp (Environment.get_variable ("MIDORI_DEBUG"), "paths") == 0)
+                    stdout.printf ("Plugins: %s\n", plugins_);
+                plugins = plugins_;
+            });
+        }
+#endif
+
         string? default_theme_name_ = null;
         /* Since: 0.5.5 */
         public string? default_theme_name { get {

=== modified file 'midori/midori-stock.h'
--- midori/midori-stock.h	2013-04-22 23:01:10 +0000
+++ midori/midori-stock.h	2015-06-22 22:20:28 +0000
@@ -15,7 +15,7 @@
 /* Stock items */
 
 #define STOCK_BOOKMARKS          "user-bookmarks"
-#define STOCK_EXTENSION          "extension"
+#define MIDORI_STOCK_EXTENSION   "extension"
 #define STOCK_HISTORY            "document-open-recent"
 #define MIDORI_STOCK_WEB_BROWSER "web-browser"
 #define STOCK_NEWS_FEED          "internet-news-reader"

=== modified file 'midori/midori-tab.vala'
--- midori/midori-tab.vala	2015-04-19 14:06:12 +0000
+++ midori/midori-tab.vala	2015-06-22 22:20:28 +0000
@@ -42,6 +42,12 @@
         NETWORK
     }
 
+    public interface TabActivatable : GLib.Object {
+        public abstract Midori.Tab tab { owned get; set; }
+
+        public abstract void created (string uri);
+    }
+
     public class Tab : Gtk.VBox {
         public Tab related { get; set construct; }
         public WebKit.WebView web_view { get; private set; }
@@ -141,6 +147,18 @@
 #endif
             /* Load something to avoid a bug where WebKit might not set a main frame */
             web_view.load_uri ("");
+
+#if HAVE_PEAS
+            var extensions = new Peas.ExtensionSet (null,
+                typeof (TabActivatable), "tab", this);
+            extensions.extension_added.connect ((info, extension) => {
+                ((TabActivatable)extension).created (uri);
+            });
+            extensions.foreach ((@set, info, extension) => {
+                ((TabActivatable)extension).created (uri);
+            });
+            set_data<Peas.ExtensionSet> ("extensions", extensions);
+#endif
         }
 
         public void inject_stylesheet (string stylesheet) {

=== modified file 'midori/midori.vapi'
--- midori/midori.vapi	2015-05-24 00:19:21 +0000
+++ midori/midori.vapi	2015-06-22 22:20:28 +0000
@@ -8,6 +8,7 @@
     public const string VERSION_SUFFIX;
     [CCode (cheader_filename = "midori/midori-stock.h")]
     namespace Stock {
+        public const string EXTENSION;
         public const string WEB_BROWSER;
         public const string TRANSFER;
         public const string PLUGINS;
@@ -131,7 +132,7 @@
     [CCode (cheader_filename = "midori/midori-extension.h")]
     public class Extension : GLib.Object {
         [CCode (has_construct_function = false)]
-        public Extension ();
+        protected Extension ();
         public unowned Midori.App get_app ();
 
         public void install_boolean (string name, bool default_value);
@@ -168,6 +169,7 @@
         public signal void activate (Midori.App app);
         public bool is_prepared ();
         public bool is_active ();
+        public bool has_preferences ();
         public signal void deactivate ();
         public signal void open_preferences ();
 

=== modified file 'midori/webkit2gtk-web-extension-4.0.vapi'
--- midori/webkit2gtk-web-extension-4.0.vapi	2015-04-19 14:06:12 +0000
+++ midori/webkit2gtk-web-extension-4.0.vapi	2015-06-22 22:20:28 +0000
@@ -2686,7 +2686,7 @@
 	public class URIRequest : GLib.Object {
 		[CCode (has_construct_function = false)]
 		public URIRequest (string uri);
-		public Soup.MessageHeaders get_http_headers ();
+		public unowned Soup.MessageHeaders get_http_headers ();
 		public unowned string get_uri ();
 		public void set_uri (string uri);
 		public string uri { get; set construct; }

=== removed file 'panels/midori-extensions.c'
--- panels/midori-extensions.c	2013-06-21 23:18:01 +0000
+++ panels/midori-extensions.c	1970-01-01 00:00:00 +0000
@@ -1,544 +0,0 @@
-/*
- Copyright (C) 2008-2009 Christian Dywan <[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.
-*/
-
-#include "midori-extensions.h"
-
-#include "midori-app.h"
-#include "midori-extension.h"
-#include "midori-platform.h"
-#include "midori-core.h"
-
-#include <glib/gi18n.h>
-
-struct _MidoriExtensions
-{
-    GtkVBox parent_instance;
-
-    GtkWidget* toolbar;
-    GtkWidget* treeview;
-    MidoriApp* app;
-};
-
-struct _MidoriExtensionsClass
-{
-    GtkVBoxClass parent_class;
-};
-
-static void
-midori_extensions_viewable_iface_init (MidoriViewableIface* iface);
-
-G_DEFINE_TYPE_WITH_CODE (MidoriExtensions, midori_extensions, GTK_TYPE_VBOX,
-                         G_IMPLEMENT_INTERFACE (MIDORI_TYPE_VIEWABLE,
-                             midori_extensions_viewable_iface_init));
-
-enum
-{
-    PROP_0,
-
-    PROP_APP
-};
-
-static void
-midori_extensions_set_property (GObject*      object,
-                                guint         prop_id,
-                                const GValue* value,
-                                GParamSpec*   pspec);
-
-static void
-midori_extensions_get_property (GObject*    object,
-                                guint       prop_id,
-                                GValue*     value,
-                                GParamSpec* pspec);
-
-static void
-midori_extensions_finalize (GObject* object);
-
-static void
-midori_extensions_class_init (MidoriExtensionsClass* class)
-{
-    GObjectClass* gobject_class;
-    GParamFlags flags;
-
-    gobject_class = G_OBJECT_CLASS (class);
-    gobject_class->set_property = midori_extensions_set_property;
-    gobject_class->get_property = midori_extensions_get_property;
-    gobject_class->finalize = midori_extensions_finalize;
-
-    flags = G_PARAM_READWRITE;
-
-    g_object_class_install_property (gobject_class,
-                                     PROP_APP,
-                                     g_param_spec_object (
-                                     "app",
-                                     "App",
-                                     "The app",
-                                     MIDORI_TYPE_APP,
-                                     flags));
-}
-
-static const gchar*
-midori_extensions_get_label (MidoriViewable* viewable)
-{
-    return _("Extensions");
-}
-
-static const gchar*
-midori_extensions_get_stock_id (MidoriViewable* viewable)
-{
-    return STOCK_EXTENSION;
-}
-
-static GtkWidget*
-midori_extensions_get_toolbar (MidoriViewable* extensions)
-{
-    if (!MIDORI_EXTENSIONS (extensions)->toolbar)
-    {
-        GtkWidget* toolbar;
-
-        toolbar = gtk_toolbar_new ();
-        MIDORI_EXTENSIONS (extensions)->toolbar = toolbar;
-    }
-
-    return MIDORI_EXTENSIONS (extensions)->toolbar;
-}
-
-static void
-midori_extensions_viewable_iface_init (MidoriViewableIface* iface)
-{
-    iface->get_stock_id = midori_extensions_get_stock_id;
-    iface->get_label = midori_extensions_get_label;
-    iface->get_toolbar = midori_extensions_get_toolbar;
-}
-
-static void
-midori_extensions_extension_activate_cb (MidoriExtension*  extension,
-                                         MidoriApp*        app,
-                                         MidoriExtensions* extensions)
-{
-    gtk_widget_queue_draw (GTK_WIDGET (extensions->treeview));
-}
-
-static void
-midori_extensions_extension_deactivate_cb (MidoriExtension*  extension,
-                                           MidoriExtensions* extensions)
-{
-    gtk_widget_queue_draw (GTK_WIDGET (extensions->treeview));
-}
-
-static void
-midori_extensions_add_item_cb (KatzeArray*       array,
-                               MidoriExtension*  extension,
-                               MidoriExtensions* extensions)
-{
-    GtkTreeIter iter;
-    GtkTreeModel* model;
-
-    model = gtk_tree_view_get_model (GTK_TREE_VIEW (extensions->treeview));
-    gtk_list_store_append (GTK_LIST_STORE (model), &iter);
-    gtk_list_store_set (GTK_LIST_STORE (model), &iter, 0, extension, -1);
-    g_signal_connect (extension, "activate",
-        G_CALLBACK (midori_extensions_extension_activate_cb), extensions);
-    g_signal_connect (extension, "deactivate",
-        G_CALLBACK (midori_extensions_extension_deactivate_cb), extensions);
-}
-
-static void
-midori_extensions_set_property (GObject*      object,
-                                guint         prop_id,
-                                const GValue* value,
-                                GParamSpec*   pspec)
-{
-    MidoriExtensions* extensions = MIDORI_EXTENSIONS (object);
-
-    switch (prop_id)
-    {
-    case PROP_APP:
-    {
-        KatzeArray* array;
-        MidoriExtension* extension;
-
-        /* FIXME: Handle NULL and subsequent assignments */
-        extensions->app = g_value_get_object (value);
-        array = katze_object_get_object (extensions->app, "extensions");
-        g_signal_connect (array, "add-item",
-            G_CALLBACK (midori_extensions_add_item_cb), extensions);
-
-        KATZE_ARRAY_FOREACH_ITEM (extension, array)
-            midori_extensions_add_item_cb (array, extension, extensions);
-        g_object_unref (array);
-    }
-        break;
-    default:
-        G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
-        break;
-    }
-}
-
-static void
-midori_extensions_get_property (GObject*    object,
-                                guint       prop_id,
-                                GValue*     value,
-                                GParamSpec* pspec)
-{
-    MidoriExtensions* extensions = MIDORI_EXTENSIONS (object);
-
-    switch (prop_id)
-    {
-    case PROP_APP:
-        g_value_set_object (value, extensions->app);
-        break;
-    default:
-        G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
-        break;
-    }
-}
-
-static void
-midori_extensions_treeview_render_tick_cb (GtkTreeViewColumn* column,
-                                           GtkCellRenderer*   renderer,
-                                           GtkTreeModel*      model,
-                                           GtkTreeIter*       iter,
-                                           GtkWidget*         treeview)
-{
-    MidoriExtension* extension;
-
-    gtk_tree_model_get (model, iter, 0, &extension, -1);
-
-    g_object_set (renderer,
-        "activatable", midori_extension_is_prepared (extension),
-        "active", midori_extension_is_active (extension) || g_object_get_data (G_OBJECT (extension), "static"),
-        "xpad", 4,
-        NULL);
-
-    g_object_unref (extension);
-}
-
-static void
-midori_extensions_treeview_render_icon_cb (GtkTreeViewColumn* column,
-                                           GtkCellRenderer*   renderer,
-                                           GtkTreeModel*      model,
-                                           GtkTreeIter*       iter,
-                                           GtkWidget*         treeview)
-{
-    MidoriExtension* extension;
-    gchar* stock_id;
-    gtk_tree_model_get (model, iter, 0, &extension, -1);
-
-    stock_id = katze_object_get_object (extension, "stock-id");
-    g_object_set (renderer, "stock-id", stock_id ? stock_id : STOCK_EXTENSION,
-                            "stock-size", GTK_ICON_SIZE_BUTTON,
-                            "sensitive", midori_extension_is_prepared (extension),
-                            "xpad", 4, NULL);
-    g_free (stock_id);
-    g_object_unref (extension);
-}
-
-static void
-midori_extensions_treeview_render_preferences_cb (GtkTreeViewColumn* column,
-                                                  GtkCellRenderer*   renderer,
-                                                  GtkTreeModel*      model,
-                                                  GtkTreeIter*       iter,
-                                                  GtkWidget*         treeview)
-{
-    MidoriExtension* extension;
-    gtk_tree_model_get (model, iter, 0, &extension, -1);
-
-    g_object_set (renderer, "stock-id", GTK_STOCK_PREFERENCES,
-                            "stock-size", GTK_ICON_SIZE_BUTTON,
-                            "visible", midori_extension_has_preferences (extension),
-                            "sensitive", midori_extension_is_active (extension),
-                            "xpad", 4, NULL);
-    g_object_unref (extension);
-}
-
-static void
-midori_extensions_treeview_render_text_cb (GtkTreeViewColumn* column,
-                                           GtkCellRenderer*   renderer,
-                                           GtkTreeModel*      model,
-                                           GtkTreeIter*       iter,
-                                           GtkWidget*         treeview)
-{
-    MidoriExtension* extension;
-    gchar* name;
-    gchar* version;
-    gchar* desc;
-    gchar* text;
-
-    gtk_tree_model_get (model, iter, 0, &extension, -1);
-
-    name = katze_object_get_string (extension, "name");
-    version = katze_object_get_string (extension, "version");
-    desc = katze_object_get_string (extension, "description");
-    if (katze_object_get_boolean (extension, "use-markup"))
-        text = g_strdup_printf ("<b>%s</b> %s\n%s",
-            name, version && *version ? version : "", desc);
-    else
-        text = g_markup_printf_escaped ("<b>%s</b> %s\n%s",
-            name, version && *version ? version : "", desc);
-    g_free (name);
-    g_free (version);
-    g_free (desc);
-
-    g_object_set (renderer,
-        "markup", text,
-        "ellipsize", PANGO_ELLIPSIZE_END,
-        "sensitive", midori_extension_is_prepared (extension),
-        NULL);
-
-    g_free (text);
-    g_object_unref (extension);
-}
-
-static void
-midori_extensions_treeview_row_activated_cb (GtkTreeView*       treeview,
-                                             GtkTreePath*       path,
-                                             GtkTreeViewColumn* column,
-                                             MidoriExtensions*  extensions)
-{
-    GtkTreeModel* model;
-    GtkTreeIter iter;
-
-    model = gtk_tree_view_get_model (treeview);
-    if (gtk_tree_model_get_iter (model, &iter, path))
-    {
-        MidoriExtension* extension;
-        KatzeArray* array = katze_object_get_object (extensions->app, "extensions");
-
-        gtk_tree_model_get (model, &iter, 0, &extension, -1);
-        if (midori_extension_is_active (extension))
-            midori_extension_deactivate (extension);
-        else if (midori_extension_is_prepared (extension))
-            g_signal_emit_by_name (extension, "activate", extensions->app);
-        /* Make it easy for listeners to see that extensions changed */
-        katze_array_update (array);
-
-        g_object_unref (array);
-        g_object_unref (extension);
-    }
-}
-
-static void
-midori_extensions_cell_renderer_toggled_cb (GtkCellRendererToggle* renderer,
-                                            const gchar*           path,
-                                            MidoriExtensions*      extensions)
-{
-    GtkTreeModel* model;
-    GtkTreeIter iter;
-
-    model = gtk_tree_view_get_model (GTK_TREE_VIEW (extensions->treeview));
-    if (gtk_tree_model_get_iter_from_string (model, &iter, path))
-    {
-        MidoriExtension* extension;
-        KatzeArray* array = katze_object_get_object (extensions->app, "extensions");
-
-        gtk_tree_model_get (model, &iter, 0, &extension, -1);
-        if (midori_extension_is_active (extension))
-            midori_extension_deactivate (extension);
-        else if (midori_extension_is_prepared (extension))
-            g_signal_emit_by_name (extension, "activate", extensions->app);
-        /* Make it easy for listeners to see that extensions changed */
-        katze_array_update (array);
-
-        g_object_unref (array);
-        g_object_unref (extension);
-    }
-}
-
-static gint
-midori_extensions_tree_sort_func (GtkTreeModel* model,
-                                  GtkTreeIter*  a,
-                                  GtkTreeIter*  b,
-                                  gpointer      data)
-{
-    MidoriExtension* e1, *e2;
-    gchar* name1, *name2;
-    gint result = 0;
-
-    gtk_tree_model_get (model, a, 0, &e1, -1);
-    gtk_tree_model_get (model, b, 0, &e2, -1);
-
-    name1 = katze_object_get_string (e1, "name");
-    name2 = katze_object_get_string (e2, "name");
-
-    g_object_unref (e1);
-    g_object_unref (e2);
-
-    result = g_strcmp0 (name1, name2);
-
-    g_free (name1);
-    g_free (name2);
-
-    return result;
-}
-
-static void
-midori_extensions_treeview_column_preference_clicked_cb (GtkWidget*   widget,
-                                                         GtkTreeView* treeview,
-                                                         GtkTreePath* path)
-{
-    GtkTreeModel* model;
-    GtkTreeIter iter;
-
-    model = gtk_tree_view_get_model (treeview);
-    if (gtk_tree_model_get_iter (model, &iter, path))
-    {
-        MidoriExtension* extension;
-
-        gtk_tree_model_get (model, &iter, 0, &extension, -1);
-        if (midori_extension_is_active (extension))
-            g_signal_emit_by_name (extension, "open-preferences");
-        g_object_unref (extension);
-    }
-
-}
-
-static gboolean
-midori_extensions_treeview_button_pressed_cb (GtkWidget*      view,
-                                              GdkEventButton* bevent,
-                                              gpointer        data)
-{
-    gboolean ret = FALSE;
-    GtkTreePath* path;
-    GtkTreeViewColumn* column;
-    guint signal_id;
-
-    if (gtk_tree_view_get_path_at_pos (GTK_TREE_VIEW (view),
-                bevent->x, bevent->y, &path, &column, NULL, NULL))
-    {
-        if (path != NULL)
-        {
-            if (MIDORI_IS_EXTENSIONS_COLUMN (column))
-            {
-                signal_id = g_signal_lookup ("row-clicked", G_OBJECT_TYPE (column));
-
-                if (signal_id && g_signal_has_handler_pending (column, signal_id, 0, FALSE)) {
-                    g_signal_emit (column, signal_id, 0, GTK_TREE_VIEW (view), path);
-                    ret = TRUE;
-                }
-            }
-            gtk_tree_path_free (path);
-        }
-    }
-    return ret;
-}
-
-static gboolean
-extensions_column_search_equal_func (GtkTreeModel* model,
-                                     gint          column,
-                                     const gchar*  key,
-                                     GtkTreeIter*  iter,
-                                     gpointer      search_data)
-{
-    MidoriExtension* extension;
-    gchar* name;
-    gchar* lower;
-    gboolean match;
-
-    gtk_tree_model_get (model, iter, 0, &extension, -1);
-    name = katze_object_get_string (extension, "name");
-    lower = g_utf8_strdown (name, -1);
-    match = !strstr (lower, key);
-
-    g_free (lower);
-    g_free (name);
-
-    return match;
-}
-
-static void
-midori_extensions_init (MidoriExtensions* extensions)
-{
-    /* Create the treeview */
-    GtkTreeViewColumn* column;
-    GtkCellRenderer* renderer_icon;
-    GtkCellRenderer* renderer_text;
-    GtkCellRenderer* renderer_toggle;
-    GtkCellRenderer* renderer_preferences;
-    GtkListStore* liststore = gtk_list_store_new (1, G_TYPE_OBJECT);
-    extensions->treeview = gtk_tree_view_new_with_model (GTK_TREE_MODEL (liststore));
-    g_object_connect (extensions->treeview,
-        "signal::button-press-event",
-        midori_extensions_treeview_button_pressed_cb, NULL,
-        NULL);
-    gtk_tree_sortable_set_sort_column_id (GTK_TREE_SORTABLE (liststore),
-        0, GTK_SORT_ASCENDING);
-    gtk_tree_sortable_set_sort_func (GTK_TREE_SORTABLE (liststore),
-        0, midori_extensions_tree_sort_func, NULL, NULL);
-    gtk_tree_view_set_headers_visible (GTK_TREE_VIEW (extensions->treeview), FALSE);
-    column = gtk_tree_view_column_new ();
-    renderer_toggle = gtk_cell_renderer_toggle_new ();
-    gtk_tree_view_column_pack_start (column, renderer_toggle, FALSE);
-    gtk_tree_view_column_set_cell_data_func (column, renderer_toggle,
-        (GtkTreeCellDataFunc)midori_extensions_treeview_render_tick_cb,
-        extensions->treeview, NULL);
-    g_signal_connect (renderer_toggle, "toggled",
-        G_CALLBACK (midori_extensions_cell_renderer_toggled_cb), extensions);
-    gtk_tree_view_append_column (GTK_TREE_VIEW (extensions->treeview), column);
-    column = gtk_tree_view_column_new ();
-    renderer_icon = gtk_cell_renderer_pixbuf_new ();
-    gtk_tree_view_column_pack_start (column, renderer_icon, FALSE);
-    gtk_tree_view_column_set_cell_data_func (column, renderer_icon,
-        (GtkTreeCellDataFunc)midori_extensions_treeview_render_icon_cb,
-        extensions->treeview, NULL);
-    gtk_tree_view_append_column (GTK_TREE_VIEW (extensions->treeview), column);
-    column = gtk_tree_view_column_new ();
-    gtk_tree_view_column_set_expand (column, TRUE);
-    renderer_text = gtk_cell_renderer_text_new ();
-    gtk_tree_view_column_pack_start (column, renderer_text, TRUE);
-    gtk_tree_view_column_set_cell_data_func (column, renderer_text,
-        (GtkTreeCellDataFunc)midori_extensions_treeview_render_text_cb,
-        extensions->treeview, NULL);
-    gtk_tree_view_append_column (GTK_TREE_VIEW (extensions->treeview), column);
-    column = GTK_TREE_VIEW_COLUMN (midori_extensions_column_new ());
-    g_signal_connect (column,
-        "row-clicked",
-        G_CALLBACK (midori_extensions_treeview_column_preference_clicked_cb),
-        NULL);
-    renderer_preferences = gtk_cell_renderer_pixbuf_new ();
-    gtk_tree_view_column_pack_start (column, renderer_preferences, FALSE);
-    gtk_tree_view_column_set_sizing (column, GTK_TREE_VIEW_COLUMN_FIXED);
-    gtk_tree_view_column_set_fixed_width (column, 30);
-    gtk_tree_view_column_set_cell_data_func (column, renderer_preferences,
-        (GtkTreeCellDataFunc)midori_extensions_treeview_render_preferences_cb,
-        extensions->treeview, NULL);
-    gtk_tree_view_append_column (GTK_TREE_VIEW (extensions->treeview), column);
-    g_object_unref (liststore);
-    g_object_connect (extensions->treeview,
-        "signal::row-activated",
-        midori_extensions_treeview_row_activated_cb, extensions,
-        NULL);
-    gtk_tree_view_set_search_column (GTK_TREE_VIEW (extensions->treeview), 0);
-    gtk_tree_view_set_search_equal_func (GTK_TREE_VIEW (extensions->treeview),
-                                         extensions_column_search_equal_func, NULL, NULL);
-    gtk_widget_show (extensions->treeview);
-    gtk_box_pack_start (GTK_BOX (extensions), extensions->treeview, TRUE, TRUE, 0);
-}
-
-static void
-midori_extensions_finalize (GObject* object)
-{
-    MidoriExtensions* extensions = MIDORI_EXTENSIONS (object);
-    KatzeArray* array = katze_object_get_object (extensions->app, "extensions");
-    MidoriExtension* extension;
-
-    KATZE_ARRAY_FOREACH_ITEM (extension, array)
-    {
-        g_signal_handlers_disconnect_by_func (extension,
-            midori_extensions_extension_activate_cb, extensions);
-        g_signal_handlers_disconnect_by_func (extension,
-            midori_extensions_extension_deactivate_cb, extensions);
-    }
-    g_signal_handlers_disconnect_by_func (array,
-            midori_extensions_add_item_cb, extensions);
-
-    g_object_unref (array);
-}
-

=== removed file 'panels/midori-extensions.h'
--- panels/midori-extensions.h	2008-12-04 00:44:33 +0000
+++ panels/midori-extensions.h	1970-01-01 00:00:00 +0000
@@ -1,45 +0,0 @@
-/*
- Copyright (C) 2008 Christian Dywan <[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.
-*/
-
-#ifndef __MIDORI_EXTENSIONS_H__
-#define __MIDORI_EXTENSIONS_H__
-
-#include <gtk/gtk.h>
-
-#include <katze/katze.h>
-
-G_BEGIN_DECLS
-
-#define MIDORI_TYPE_EXTENSIONS \
-    (midori_extensions_get_type ())
-#define MIDORI_EXTENSIONS(obj) \
-    (G_TYPE_CHECK_INSTANCE_CAST ((obj), MIDORI_TYPE_EXTENSIONS, MidoriExtensions))
-#define MIDORI_EXTENSIONS_CLASS(klass) \
-    (G_TYPE_CHECK_CLASS_CAST ((klass), MIDORI_TYPE_EXTENSIONS, MidoriExtensionsClass))
-#define MIDORI_IS_EXTENSIONS(obj) \
-    (G_TYPE_CHECK_INSTANCE_TYPE ((obj), MIDORI_TYPE_EXTENSIONS))
-#define MIDORI_IS_EXTENSIONS_CLASS(klass) \
-    (G_TYPE_CHECK_CLASS_TYPE ((klass), MIDORI_TYPE_EXTENSIONS))
-#define MIDORI_EXTENSIONS_GET_CLASS(obj) \
-    (G_TYPE_INSTANCE_GET_CLASS ((obj), MIDORI_TYPE_EXTENSIONS, MidoriExtensionsClass))
-
-typedef struct _MidoriExtensions                MidoriExtensions;
-typedef struct _MidoriExtensionsClass           MidoriExtensionsClass;
-
-GType
-midori_extensions_get_type               (void);
-
-GtkWidget*
-midori_extensions_new                    (void);
-
-G_END_DECLS
-
-#endif /* __MIDORI_EXTENSIONS_H__ */

=== modified file 'po/POTFILES.in'
--- po/POTFILES.in	2015-05-24 00:19:21 +0000
+++ po/POTFILES.in	2015-06-22 22:20:28 +0000
@@ -27,7 +27,7 @@
 midori/sokoke.c
 toolbars/midori-findbar.c
 panels/midori-bookmarks.c
-panels/midori-extensions.c
+extensions/extensions.vala
 panels/midori-history.c
 katze/katze-http-auth.c
 katze/katze-utils.c
@@ -65,9 +65,12 @@
 extensions/status-clock.c
 extensions/statusbar-features.c
 extensions/tab-panel.c
-extensions/tabs-minimized.c
+extensions/tabs-minimized.vala
 extensions/tabs2one.c
 extensions/toolbar-editor.c
+extensions/hsts.web.vala
+extensions/web-extension.web.vala
+ipc/ipc-tab.vala
 katze/katze-cellrenderercomboboxtext.c
 katze/midori-hsts.vala
 katze/katze-separatoraction.vala