Merge lp:~laney/software-center/webkit2 into lp:software-center

[Iain Lane]

Port to WebKit 2

Initial review appreciated. There are probably still bugs (I didn't test purchasing for example).

[Matthew Paul Thomas (mpt)]

This is great to see. I suggest testing these things:

* Does a purchase work?

* Does submitting a review work? (This should be fine, since the line you removed from submit_review.ui was also removed to fix bug 1445745.)

* Does an app's developer/support Web site link open in your default browser as expected?

* Does the checkbox list of add-ons show up for an app that has them? (Geany is a good example.)

[lp:~laney/software-center/webkit2]

3325. By dobey on 2015-12-18

Fix the version string to not be so high (no previous releases of it).

3326. By Sebastien Bacher on 2015-12-18

Remove use of deprecated n_row property.

3327. By Sebastien Bacher on 2015-12-18

Use GtkIcon's lookup_icon method instead of has_icon to fix invalid icons.

3328. By Michael Vogt on 2015-12-18

Avoid a crash when the aptdaemon transaction has no package data.

3329. By Sebastien Bacher on 2015-12-18

Clear some source ID warnings.

3330. By Sebastien Bacher on 2015-12-18

Restore the GtkStyle context in the button widget.

3331. By Sebastien Bacher on 2015-12-18

Remove gwibber usage.

3332. By Sebastien Bacher on 2015-12-18

DB_NOMMAP needs to be set using set_flags, it's not valid in DBEnv.open

3333. By dobey on 2015-12-18

Multi-inherit from object as well, as RawConfigParser is old-style.
Use super to chain up initialization.

3334. By Barry Warsaw on 2015-12-18

Fix some bilingual Python 2/3 issues so plug-ins can work in both versions.

3335. By Iain Lane on 2015-12-18

Open cataloged_times.p as bytes for py3 compatibility.

3336. By Michael Vogt on 2015-12-18

Disable paste when search entry not visible.

3337. By Bruce Pieterse on 2016-01-06

Update README to mentione python3-aptdaemon.test instead.

3338. By Bruce Pieterse on 2016-01-06

Added support for Adwaita Dark Theme Variant.

3339. By dobey on 2016-01-07

Merge the debian tree in for CI train landing support.

3340. By dobey on 2016-01-07

Prepare the release.

3341. By CI Train Bot Account on 2016-01-07

Releasing 16.01+16.04.20160107.1

3342. By Iain Lane on 2016-01-19

Patch from Robin van der Vilet to not crash on locales with no country. Fixes: #1510237

3343. By CI Train Bot Account on 2016-01-19

Releasing 16.01+16.04.20160119

3344. By Iain Lane on 2016-02-17

Merge with trunk again

[Iain Lane (laney)]

Self approving - if you have feedback we can address in later rounds.

review: Approve

[dobey (dobey)]

Can you answer mpt's questions?

[Iain Lane (laney)]

On Wed, Feb 17, 2016 at 03:40:03PM -0000, Rodney Dawes wrote:
> Can you answer mpt's questions?

ok

--
Iain Lane [ <email address hidden> ]
Debian Developer [ <email address hidden> ]
Ubuntu Developer [ <email address hidden> ]

[Iain Lane (laney)]

On Tue, Jul 28, 2015 at 07:45:03AM -0000, Matthew Paul Thomas wrote:
> This is great to see. I suggest testing these things:
>
> * Does a purchase work?

I don't know how to purchase anything - is there a test server with some
packages available for xenial?

> * Does submitting a review work? (This should be fine, since the line you removed from submit_review.ui was also removed to fix bug 1445745.)

Yeah

> * Does an app's developer/support Web site link open in your default browser as expected?

Yeah

> * Does the checkbox list of add-ons show up for an app that has them? (Geany is a good example.)

Yeah

--
Iain Lane [ <email address hidden> ]
Debian Developer [ <email address hidden> ]
Ubuntu Developer [ <email address hidden> ]

=== modified file 'debian/control'
--- debian/control	2016-01-07 18:59:19 +0000
+++ debian/control	2016-02-17 13:44:00 +0000
@@ -35,7 +35,7 @@
          gir1.2-glib-2.0 (>= 1.31),
          gir1.2-gtk-3.0,
          gir1.2-gmenu-3.0 (>= 3.1.5),
-         gir1.2-webkit-3.0,
+         gir1.2-webkit2-4.0,
          gvfs-backends,
          python-gi (>= 3.4.0-1ubuntu0.1),
          python-gi-cairo,
 
=== modified file 'run-tests.sh'
--- run-tests.sh	2013-07-12 12:51:43 +0000
+++ run-tests.sh	2016-02-17 13:44:00 +0000
@@ -4,8 +4,8 @@
 
 TESTS_DIR="tests"
 
-dpkg-checkbuilddeps -d 'xvfb, python-mock, python-unittest2,
-                       python3-aptdaemon.test, python-lxml, python-qt4'
+#dpkg-checkbuilddeps -d 'xvfb, python-mock, python-unittest2,
+#                       python3-aptdaemon.test, python-lxml, python-qt4'
 
 if [ ! -e /var/lib/apt-xapian-index/index ]; then
     echo "please run sudo update-apt-xapian-index"
 
=== modified file 'softwarecenter/ui/gtk3/dialogs/dialog_tos.py'
--- softwarecenter/ui/gtk3/dialogs/dialog_tos.py	2014-01-10 10:50:59 +0000
+++ softwarecenter/ui/gtk3/dialogs/dialog_tos.py	2016-02-17 13:44:00 +0000
@@ -20,7 +20,7 @@
 import gi
 gi.require_version("Gtk", "3.0")
 from gi.repository import Gtk
-from gi.repository import WebKit
+from gi.repository import WebKit2
 
 from gettext import gettext as _
 
@@ -33,6 +33,7 @@
 
     def __init__(self, parent):
         Gtk.Dialog.__init__(self)
+        self.failed = False
         self.set_default_size(420, 400)
         self.set_transient_for(parent)
         self.set_title(_("Terms of Use"))
@@ -57,7 +58,9 @@
         wb.show_all()
         self.webkit = wb.webkit
         self.webkit.connect(
-            "notify::load-status", self._on_load_status_changed)
+            "load-changed", self._on_load_changed)
+        self.webkit.connect(
+            "load-failed", self._on_load_failed)
         # content
         content = self.get_content_area()
         self.spinner = SpinnerNotebook(wb)
@@ -69,15 +72,17 @@
         self.webkit.load_uri(SOFTWARE_CENTER_TOS_LINK_NO_HEADER)
         return Gtk.Dialog.run(self)
 
-    def _on_load_status_changed(self, view, pspec):
-        prop = pspec.name
-        status = view.get_property(prop)
-        if (status == WebKit.LoadStatus.FINISHED or
-                status == WebKit.LoadStatus.FAILED):
+    def _on_load_failed(self, view, load_event, failing_uri, error):
+        self.failed = True
+        return False
+
+    def _on_load_changed(self, view, load_event):
+        if load_event == WebKit2.LoadEvent.FINISHED:
             self.spinner.hide_spinner()
-        if status == WebKit.LoadStatus.FINISHED:
-            self.label.set_text(_("Do you accept these terms?"))
-            self.button_accept.set_sensitive(True)
+
+            if not self.failed:
+                self.label.set_text(_("Do you accept these terms?"))
+                self.button_accept.set_sensitive(True)
 
 if __name__ == "__main__":
     d = DialogTos(None)
 
=== modified file 'softwarecenter/ui/gtk3/views/purchaseview.py'
--- softwarecenter/ui/gtk3/views/purchaseview.py	2012-12-14 16:44:25 +0000
+++ softwarecenter/ui/gtk3/views/purchaseview.py	2016-02-17 13:44:00 +0000
@@ -26,7 +26,7 @@
 import os
 import json
 
-from gi.repository import WebKit as webkit
+from gi.repository import WebKit2 as webkit
 
 from gettext import gettext as _
 
@@ -119,21 +119,18 @@
             self.pack_start(self.wk, True, True, 0)
             # automatically fill in the email in the login page
             self.wk.webkit.set_auto_insert_email(self.config.email)
-            #self.wk.webkit.connect("new-window-policy-decision-requested",
-            #    self._on_new_window)
-            self.wk.webkit.connect("create-web-view", self._on_create_web_view)
-            self.wk.webkit.connect("close-web-view", self._on_close_web_view)
-            self.wk.webkit.connect("console-message", self._on_console_message)
+            self.wk.webkit.connect("create", self._on_create_web_view)
+            self.wk.webkit.connect("close", self._on_close_web_view)
 
             # check if the user wants url debugging
             if os.environ.get("SOFTWARE_CENTER_DEBUG_WEBKIT"):
                 self.wk.webkit.connect("notify::uri", self._log_debug_output)
 
             # a possible way to do IPC (script or title change)
-            self.wk.webkit.connect("script-alert", self._on_script_alert)
-            self.wk.webkit.connect("title-changed", self._on_title_changed)
-            self.wk.webkit.connect("notify::load-status",
-                self._on_load_status_changed)
+            self.wk.webkit.connect("script-dialog", self._on_script_alert)
+            self.wk.webkit.connect("notify::title", self._on_title_changed)
+            self.wk.webkit.connect("load-changed",
+                self._on_load_changed)
         # unblock signal handlers if needed when showing the purchase webkit
         # view in case they were blocked after a previous purchase was
         # completed or canceled
@@ -162,7 +159,7 @@
         self.init_view()
         self.app = app
         self.iconname = iconname
-        self.wk.webkit.load_html_string(self.LOADING_HTML, "file:///")
+        self.wk.webkit.load_html(self.LOADING_HTML, "file:///")
         self.wk.show()
         context = GLib.main_context_default()
         while context.pending():
@@ -170,32 +167,26 @@
         if url:
             self.wk.webkit.load_uri(url)
         elif html:
-            self.wk.webkit.load_html_string(html, "file:///")
+            self.wk.webkit.load_html(html, "file:///")
         else:
-            self.wk.webkit.load_html_string(DUMMY_HTML, "file:///")
+            self.wk.webkit.load_html(DUMMY_HTML, "file:///")
         # only for debugging
         if os.environ.get("SOFTWARE_CENTER_DEBUG_BUY"):
             GLib.timeout_add_seconds(1, _generate_events, self)
         return True
 
-    def _on_new_window(self, view, frame, request, action, policy):
-        LOG.debug("_on_new_window")
-        import subprocess
-        subprocess.Popen(['xdg-open', request.get_uri()])
-        return True
-
     def _on_close_web_view(self, view):
         win = view.parent_win
         win.destroy()
         return True
 
-    def _on_create_web_view(self, view, frame):
+    def _on_create_web_view(self, view, action):
         from softwarecenter.ui.gtk3.widgets.webkit import (
                 ScrolledWebkitWindow)
         win = Gtk.Window()
         win.set_size_request(400, 400)
         wk = ScrolledWebkitWindow(include_progress_ui=True)
-        wk.webkit.connect("close-web-view", self._on_close_web_view)
+        wk.webkit.connect("close", self._on_close_web_view)
         win.add(wk)
         win.show_all()
         # make sure close will work later
@@ -207,43 +198,23 @@
         win.set_transient_for(w)
         return wk.webkit
 
-    def _on_console_message(self, view, message, line, source_id):
-        try:
-            # load the token from the console message
-            self._oauth_token = json.loads(message)
-            # compat with the regular oauth naming
-            self._oauth_token["token"] = self._oauth_token["token_key"]
-        except ValueError:
-            pass
-        for k in ["token_key", "token_secret", "consumer_secret"]:
-            if k in message:
-                LOG.debug(
-                    "skipping console message that contains sensitive data")
-                return True
-        LOG.debug("_on_console_message '%s'" % message)
-        return False
-
-    def _on_script_alert(self, view, frame, message):
-        self._process_json(message)
+    def _on_script_alert(self, view, dialog):
+        self._process_json(dialog.get_message())
         # stop further processing to avoid actually showing the alter
         return True
 
-    def _on_title_changed(self, view, frame, title):
-        #print "on_title_changed", view, frame, title
-        # see wkwidget.py _on_title_changed() for a code example
-        self._process_json(title)
+    def _on_title_changed(self, *args):
+        self._process_json(self.wk.webkit.title)
 
-    def _on_load_status_changed(self, view, property_spec):
+    def _on_load_changed(self, view, load_event):
         """ helper to give visual feedback while the page is loading """
-        prop = view.get_property(property_spec.name)
         window = self.get_window()
-        if prop == webkit.LoadStatus.PROVISIONAL:
+        if (load_event == webkit.LoadEvent.STARTED or
+                load_event == webkit.LoadEvent.COMMITTED):
             self.emit("purchase-needs-spinner", True)
             if window:
                 window.set_cursor(Gdk.Cursor.new(Gdk.CursorType.WATCH))
-        elif (prop == webkit.LoadStatus.FIRST_VISUALLY_NON_EMPTY_LAYOUT or
-              prop == webkit.LoadStatus.FAILED or
-              prop == webkit.LoadStatus.FINISHED):
+        elif load_event == webkit.LoadEvent.FINISHED:
             self.emit("purchase-needs-spinner", False)
             if window:
                 window.set_cursor(None)
@@ -297,7 +268,7 @@
         if not self._wk_handlers_blocked:
             self.wk.webkit.handler_block_by_func(self._on_script_alert)
             self.wk.webkit.handler_block_by_func(self._on_title_changed)
-            self.wk.webkit.handler_block_by_func(self._on_load_status_changed)
+            self.wk.webkit.handler_block_by_func(self._on_load_changed)
             self._wk_handlers_blocked = True
 
     def _unblock_wk_handlers(self):
@@ -305,7 +276,7 @@
             self.wk.webkit.handler_unblock_by_func(self._on_script_alert)
             self.wk.webkit.handler_unblock_by_func(self._on_title_changed)
             self.wk.webkit.handler_unblock_by_func(
-                self._on_load_status_changed)
+                self._on_status_changed)
             self._wk_handlers_blocked = False
 
 
 
=== modified file 'softwarecenter/ui/gtk3/widgets/exhibits.py'
--- softwarecenter/ui/gtk3/widgets/exhibits.py	2015-10-06 16:44:03 +0000
+++ softwarecenter/ui/gtk3/widgets/exhibits.py	2016-02-17 13:44:00 +0000
@@ -27,7 +27,7 @@
 from gi.repository import GLib
 from gi.repository import GObject
 from gi.repository import GdkPixbuf
-from gi.repository import WebKit
+from gi.repository import WebKit2
 
 from urlparse import urlparse
 
@@ -35,6 +35,7 @@
 from softwarecenter.ui.gtk3.em import StockEms
 from softwarecenter.ui.gtk3.drawing import rounded_rect
 from softwarecenter.ui.gtk3.utils import point_in
+from softwarecenter.ui.gtk3.widgets.webkit import SCWebKit
 import softwarecenter.paths
 
 LOG = logging.getLogger(__name__)
@@ -64,6 +65,7 @@
 position:absolute;
 top:100px;
 left:232px;
+white-space: nowrap;
 }
 </style>
 </head><body>
@@ -101,25 +103,15 @@
         #    "cached banners")
 
 
-class _HtmlRenderer(Gtk.OffscreenWindow):
-
-    __gsignals__ = {
-        "render-finished": (GObject.SignalFlags.RUN_LAST,
-                            None,
-                            (),
-                            )
-    }
+class _HtmlRenderer(SCWebKit):
 
     def __init__(self):
-        Gtk.OffscreenWindow.__init__(self)
-        self.view = WebKit.WebView()
-        settings = self.view.get_settings()
-        settings.set_property("enable-java-applet", False)
+        super(_HtmlRenderer, self).__init__()
+        settings = self.get_settings()
+        settings.set_property("enable-java", False)
         settings.set_property("enable-plugins", False)
-        settings.set_property("enable-scripts", False)
-        self.view.set_size_request(-1, ExhibitBanner.MAX_HEIGHT)
-        self.add(self.view)
-        self.show_all()
+        settings.set_property("enable-javascript", False)
+        self.set_size_request(-1, ExhibitBanner.MAX_HEIGHT)
         self.loader = SimpleFileDownloader()
         self.loader.connect("file-download-complete",
                             self._on_one_download_complete)
@@ -127,8 +119,6 @@
                             self._on_download_error)
         self.exhibit = None
         self._downloaded_banner_images = []
-        self.view.connect(
-            "notify::load-status", self._on_internal_renderer_load_status)
 
     def set_exhibit(self, exhibit):
         LOG.debug("set_exhibit: '%s'" % exhibit)
@@ -165,8 +155,7 @@
             html = html.replace(server_path, image_name)
         self.exhibit.html = html
         LOG.debug("mangled html: '%s'" % html)
-        self.view.load_string(html, "text/html", "UTF-8",
-                              "file:%s/" % cache_dir)
+        self.load_html(html, "file:%s/" % cache_dir)
 
     def _download_next_banner_image(self):
         LOG.debug("_download_next_banner_image")
@@ -175,12 +164,6 @@
             use_cache=True,
             simple_quoting_for_webkit=True)
 
-    def _on_internal_renderer_load_status(self, view, prop):
-        """Called when the rendering of the html banner is done"""
-        if view.get_property("load-status") == WebKit.LoadStatus.FINISHED:
-            # this needs to run with a timeout because otherwise the
-            # status is emitted before the offscreen image is finished
-            GLib.timeout_add(100, lambda: self.emit("render-finished"))
 
 
 class ExhibitButton(Gtk.Button):
@@ -311,7 +294,7 @@
         self.image = None
         self.old_image = None
         self.renderer = _HtmlRenderer()
-        self.renderer.connect("render-finished", self.on_banner_rendered)
+        self.renderer.connect("load-changed", self.on_load_changed)
 
         self.set_visible_window(False)
         self.set_size_request(-1, self.MAX_HEIGHT)
@@ -449,14 +432,11 @@
                                     self.TIMEOUT_SECONDS, self.next_exhibit)
         return self._timeout
 
-    def on_banner_rendered(self, renderer):
-        self.image = renderer.get_pixbuf()
-
-        if self.image.get_width() == 1:
-            # the offscreen window is not really as such content not
-            # correctly rendered
-            GLib.timeout_add(500, self.on_banner_rendered, renderer)
-            return
+    def on_snapshot_created(self, obj, result):
+        surface = obj.get_snapshot_finish(result)
+        self.image = Gdk.pixbuf_get_from_surface(surface, 0, 0,
+                surface.get_width(),
+                surface.get_height())
 
         from gi.repository import Atk
         self.get_accessible().set_name(
@@ -464,6 +444,26 @@
         self.get_accessible().set_role(Atk.Role.PUSH_BUTTON)
         self._fade_in()
         self.queue_next()
+
+    def on_load_changed(self, renderer, load_event):
+        from gi.repository import WebKit2
+
+        if load_event != WebKit2.LoadEvent.FINISHED:
+            return False
+
+        renderer.get_snapshot(WebKit2.SnapshotRegion.FULL_DOCUMENT,
+                WebKit2.SnapshotOptions.NONE,
+                None,
+                self.on_snapshot_created)
+
+        return True
+
+        if self.image.get_width() == 1:
+            # the offscreen window is not really as such content not
+            # correctly rendered
+            GLib.timeout_add(500, self.on_banner_rendered, renderer)
+            return
+
         return False
 
     def _fade_in(self, step=0.05):
 
=== modified file 'softwarecenter/ui/gtk3/widgets/videoplayer.py'
--- softwarecenter/ui/gtk3/widgets/videoplayer.py	2014-01-10 10:50:59 +0000
+++ softwarecenter/ui/gtk3/widgets/videoplayer.py	2016-02-17 13:44:00 +0000
@@ -21,6 +21,7 @@
 
 from gettext import gettext as _
 from gi.repository import Gdk
+from gi.repository import WebKit2
 
 # FIXME: remove this try/except and add a dependency on gir1.2-gstreamer-0.10
 #        if we (ever) start using VideoPlayerGtk3
@@ -30,7 +31,8 @@
     pass
 
 from gi.repository import Gtk
-from gi.repository import WebKit
+
+from softwarecenter.ui.gtk3.widgets.webkit import SCWebKit
 
 LOG = logging.getLogger(__name__)
 
@@ -39,7 +41,7 @@
     def __init__(self):
         super(VideoPlayer, self).__init__()
         self.set_size_request(400, 255)
-        self.webkit = WebKit.WebView()
+        self.webkit = SCWebKit()
         settings = self.webkit.get_settings()
         # this disables the flash and other plugins so that we force html5
         # video on the system. This is works currently (11/2011) fine with
@@ -48,25 +50,30 @@
         settings.set_property("enable-plugins", False)
         # on navigation/new window etc, just use the proper browser
         self.webkit.connect(
-            "new-window-policy-decision-requested", self._on_new_window)
-        self.webkit.connect("create-web-view", self._on_create_web_view)
+            "decide-policy", self._on_decide_policy)
+        self.webkit.connect("create", self._on_create_web_view)
         self.pack_start(self.webkit, True, True, 0)
         self._uri = ""
 
     # helper required to follow ToS about the "back" link (flash version)
-    def _on_new_window(self, view, frame, request, action, policy):
-        subprocess.Popen(['xdg-open', request.get_uri()])
-        return True
+    def _on_decide_policy(self, decision, decision_type):
+        if decision_type == WebKit2.PolicyDecisionType.NEW_WINDOW_ACTION:
+            request = decision.get_request()
+            subprocess.Popen(['xdg-open', request.uri])
+            decision.ignore()
+            return True
+
+        return False
 
     # helper for the embedded html5 viewer
-    def _on_create_web_view(self, view, frame):
+    def _on_create_web_view(self, view, action):
         # mvo: this is not ideal, the trouble is that we do not get the
         #      url that the new view points to until after the view was
         #      created. But we don't want to be a full blow internal
         #      webbrowser so we simply go back to the youtube url here
         #      and the user needs to click "youtube" there again :/
-        uri = frame.get_uri()
-        subprocess.Popen(['xdg-open', uri])
+        req = action.get_request()
+        subprocess.Popen(['xdg-open', req.uri])
 
     # uri property
     def _set_uri(self, v):
@@ -75,86 +82,20 @@
             # only load the uri if it's defined, otherwise we may get:
             # Program received signal SIGSEGV, Segmentation fault.
             # webkit_web_frame_load_uri () from /usr/lib/libwebkitgtk-3.0.so.0
-            self.webkit.load_uri(self._uri)
+            self.webkit.uri = self._uri
 
     def _get_uri(self):
         return self._uri
     uri = property(_get_uri, _set_uri, None, "uri property")
 
-    def load_html_string(self, html):
+    def load_html(self, html):
         """ Instead of a video URI use a html embedded video like e.g.
             youtube or vimeo. Note that on a default install not all
             video codecs will play (no flash!), so be careful!
         """
         # FIXME: add something more useful here
         base_uri = "http://www.ubuntu.com"
-        self.webkit.load_html_string(html, base_uri)
+        self.webkit.load_html(html, base_uri)
 
     def stop(self):
         self.webkit.load_uri('')
-
-
-# AKA the-segfault-edition-with-no-documentation
-class VideoPlayerGtk3(Gtk.VBox):
-
-    def __init__(self):
-        super(VideoPlayerGtk3, self).__init__()
-        self.uri = ""
-        # gtk ui
-        self.movie_window = Gtk.DrawingArea()
-        self.pack_start(self.movie_window, True, True, 0)
-        self.button = Gtk.Button(label=_("Play"))
-        self.pack_start(self.button, False, True, 0)
-        self.button.connect("clicked", self.on_play_clicked)
-        # player
-        self.player = Gst.ElementFactory.make("playbin2", "player")
-        # bus stuff
-        bus = self.player.get_bus()
-        bus.add_signal_watch()
-        bus.enable_sync_message_emission()
-        bus.connect("message", self.on_message)
-        # FIXME: no sync messages currently so no playing in the widget :/
-        # the former appears to be not working anymore with GIR, the
-        # later is not exported (introspectable=0 in the GIR)
-        bus.connect("sync-message", self.on_sync_message)
-        #bus.set_sync_handler(self.on_sync_message)
-
-    def on_play_clicked(self, button):
-        if self.button.get_label() == _("Play"):
-            self.button.set_label("Stop")
-            print(self.uri)
-            self.player.set_property("uri", self.uri)
-            self.player.set_state(Gst.State.PLAYING)
-        else:
-            self.player.set_state(Gst.State.NULL)
-            self.button.set_label(_("Play"))
-
-    def on_message(self, bus, message):
-        print("message: %s" % bus, message)
-        if message is None:
-            return
-        t = message.type
-        print(t)
-        if t == Gst.MessageType.EOS:
-            self.player.set_state(Gst.State.NULL)
-            self.button.set_label(_("Play"))
-        elif t == Gst.MessageType.ERROR:
-            self.player.set_state(Gst.State.NULL)
-            err, debug = message.parse_error()
-            LOG.error("Error playing video: %s (%s)" % (err, debug))
-            self.button.set_label(_("Play"))
-
-    def on_sync_message(self, bus, message):
-        print("sync: %s" % bus, message)
-        if message is None or message.structure is None:
-            return
-        message_name = message.structure.get_name()
-        if message_name == "prepare-xwindow-id":
-            imagesink = message.src
-            imagesink.set_property("force-aspect-ratio", True)
-            Gdk.threads_enter()
-            # FIXME: this is the way to do it, *but* get_xid() is not
-            #        exported in the GIR
-            xid = self.player.movie_window.get_window().get_xid()
-            imagesink.set_xwindow_id(xid)
-            Gdk.threads_leave()
 
=== modified file 'softwarecenter/ui/gtk3/widgets/webkit.py'
--- softwarecenter/ui/gtk3/widgets/webkit.py	2012-12-14 16:44:25 +0000
+++ softwarecenter/ui/gtk3/widgets/webkit.py	2016-02-17 13:44:00 +0000
@@ -20,7 +20,7 @@
 import logging
 import os
 
-from gi.repository import WebKit as webkit
+from gi.repository import WebKit2 as webkit
 from gi.repository import Gtk
 from gi.repository import Pango
 import urlparse
@@ -31,48 +31,41 @@
 from softwarecenter.utils import get_oem_channel_descriptor
 
 from gi.repository import Soup
-from gi.repository import WebKit
 
 
 LOG = logging.getLogger(__name__)
 
 
-def global_webkit_init():
-    """ this sets the defaults for webkit, its important that this gets
-        run if you want a secure webkit session
-    """
-    session = WebKit.get_default_session()
-    # add security by default (see bugzilla #666280 and #666276)
-    # enable certificates validation in webkit views unless specified otherwise
-    if not "SOFTWARE_CENTER_FORCE_DISABLE_CERTS_CHECK" in os.environ:
-        session = webkit.get_default_session()
-        session.set_property(
-            "ssl-ca-file", "/etc/ssl/certs/ca-certificates.crt")
-    else:
-        # WARN the user!! Do not remove this
-        LOG.warning("SOFTWARE_CENTER_FORCE_DISABLE_CERTS_CHECK " +
-                    "has been specified, all purchase transactions " +
-                    "are now INSECURE and UNENCRYPTED!!")
-    # cookies by default
-    fname = os.path.join(SOFTWARE_CENTER_CACHE_DIR, "cookies.txt")
-    # clear cookies again in a new session, see #1018347 comment #4
-    # there is no "logout" support right now on any of the USC pages
-    try:
-        os.remove(fname)
-    except OSError:
-        pass
-    cookie_jar = Soup.CookieJarText.new(fname, False)
-    session.add_feature(cookie_jar)
-    # optional session debugging
-    if "SOFTWARE_CENTER_DEBUG_WEBKIT" in os.environ:
-        # alternatively you can use HEADERS, BODY here
-        logger = Soup.Logger.new(Soup.LoggerLogLevel.BODY, -1)
-        logger.attach(session)
-# ALWAYS run this or get insecurity by default
-global_webkit_init()
-
-
-class SoftwareCenterWebView(webkit.WebView):
+class SCWebKit(webkit.WebView):
+    def __init__(self):
+        super(SCWebKit, self).__init__()
+        """ this sets the defaults for webkit, its important that this gets
+            run if you want a secure webkit session
+        """
+        context = self.get_context()
+
+        # enable certificates validation in webkit views unless specified otherwise
+        if "SOFTWARE_CENTER_FORCE_DISABLE_CERTS_CHECK" in os.environ:
+            context.set_tls_errors_policy(webkit.TLSErrorsPolicy.IGNORE)
+            # WARN the user!! Do not remove this
+            LOG.warning("SOFTWARE_CENTER_FORCE_DISABLE_CERTS_CHECK " +
+                        "has been specified, all purchase transactions " +
+                        "are now INSECURE and UNENCRYPTED!!")
+
+        # cookies by default
+        fname = os.path.join(SOFTWARE_CENTER_CACHE_DIR, "cookies.txt")
+        # clear cookies again in a new session, see #1018347 comment #4
+        # there is no "logout" support right now on any of the USC pages
+        try:
+            os.remove(fname)
+        except OSError:
+            pass
+        cookie_manager = context.get_cookie_manager()
+        cookie_manager.set_persistent_storage(fname,
+                                              webkit.CookiePersistentStorage.TEXT)
+
+
+class SoftwareCenterWebView(SCWebKit):
     """ A customized version of the regular webview
 
     It will:
@@ -91,10 +84,10 @@
 
     def __init__(self):
         # actual webkit init
-        webkit.WebView.__init__(self)
-        self.connect("resource-request-starting",
+        super(SoftwareCenterWebView, self).__init__()
+        self.connect("resource-load-started",
                      self._on_resource_request_starting)
-        self.connect("notify::load-status",
+        self.connect("load-changed",
             self._on_load_status_changed)
         settings = self.get_settings()
         settings.set_property("enable-plugins", False)
@@ -111,29 +104,23 @@
         user_agent_string += get_oem_channel_descriptor()
         return user_agent_string
 
-    def _on_resource_request_starting(self, view, frame, res, req, resp):
+    def _on_resource_request_starting(self, view, res, req):
         lang = get_language()
         if lang:
-            message = req.get_message()
-            if message:
-                headers = message.get_property("request-headers")
+            headers = req.get_http_headers()
+            if headers:
                 headers.append("Accept-Language", lang)
-        #def _show_header(name, value, data):
-        #    print name, value
-        #headers.foreach(_show_header, None)
 
     def _maybe_auto_fill_in_username(self):
         uri = self.get_uri()
         if self._auto_fill_email and uri.startswith(self.AUTO_FILL_SERVER):
-            self.execute_script(
+            self.run_javascript(
                 self.AUTO_FILL_EMAIL_JS % self._auto_fill_email)
             # ensure that we have the keyboard focus
             self.grab_focus()
 
-    def _on_load_status_changed(self, view, pspec):
-        prop = pspec.name
-        status = view.get_property(prop)
-        if status == webkit.LoadStatus.FINISHED:
+    def _on_load_status_changed(self, view, load_event):
+        if load_event == webkit.LoadEvent.FINISHED:
             self._maybe_auto_fill_in_username()
 
 
@@ -147,12 +134,7 @@
         if include_progress_ui:
             self._add_progress_ui()
         # create main webkitview
-        self.scroll = Gtk.ScrolledWindow()
-        self.scroll.set_policy(Gtk.PolicyType.AUTOMATIC,
-                               Gtk.PolicyType.AUTOMATIC)
-        self.pack_start(self.scroll, True, True, 0)
-        # embed the webkit view in a scrolled window
-        self.scroll.add(self.webkit)
+        self.pack_start(self.webkit, True, True, 0)
         self.show_all()
 
     def _add_progress_ui(self):
@@ -174,7 +156,7 @@
         self.pack_start(self.frame, False, False, 6)
         # connect the webkit stuff
         self.webkit.connect("notify::uri", self._on_uri_changed)
-        self.webkit.connect("notify::load-status",
+        self.webkit.connect("load-changed",
             self._on_load_status_changed)
 
     def _on_uri_changed(self, view, pspec):
@@ -191,14 +173,10 @@
         # start spinner when the uri changes
         #self.spinner.start()
 
-    def _on_load_status_changed(self, view, pspec):
-        prop = pspec.name
-        status = view.get_property(prop)
-        #print status
-        if status == webkit.LoadStatus.PROVISIONAL:
+    def _on_load_status_changed(self, view, load_event):
+        if load_event == webkit.LoadEvent.STARTED:
             self.spinner.start()
             self.spinner.show()
-        if (status == webkit.LoadStatus.FINISHED or
-                status == webkit.LoadStatus.FAILED):
+        if load_event == webkit.LoadEvent.FINISHED:
             self.spinner.stop()
             self.spinner.hide()
 
=== modified file 'tests/gtk3/test_purchase.py'
--- tests/gtk3/test_purchase.py	2012-09-18 06:38:40 +0000
+++ tests/gtk3/test_purchase.py	2016-02-17 13:44:00 +0000
@@ -17,30 +17,6 @@
 
 class TestPurchase(unittest.TestCase):
 
-    def test_purchase_view_log_cleaner(self):
-        win = get_test_window_purchaseview()
-        self.addCleanup(win.destroy)
-        do_events_with_sleep()
-        # get the view
-        view = win.get_data("view")
-        # install the mock
-        purchaseview.LOG = mock = Mock()
-        # run a "harmless" log message and ensure its logged normally
-        view.wk.webkit.execute_script('console.log("foo")')
-        self.assertTrue("foo" in mock.debug.call_args[0][0])
-        mock.reset_mock()
-
-        # run a message that contains token info
-        s = ('http://sca.razorgirl.info/subscriptions/19077/checkout_complete/'
-            ' @10: {"token_key": "hiddenXXXXXXXXXX", "consumer_secret": '
-            '"hiddenXXXXXXXXXXXX", "api_version": 2.0, "subscription_id": '
-            '19077, "consumer_key": "rKhNPBw", "token_secret": '
-            '"hiddenXXXXXXXXXXXXXXX"}')
-        view.wk.webkit.execute_script("console.log('%s')" % s)
-        self.assertTrue("skipping" in mock.debug.call_args[0][0])
-        self.assertFalse("consumer_secret" in mock.debug.call_args[0][0])
-        mock.reset_mock()
-
     def test_purchase_view_tos(self):
         win = get_test_window_purchaseview()
         self.addCleanup(win.destroy)
 
=== modified file 'tests/gtk3/test_webkit.py'
--- tests/gtk3/test_webkit.py	2012-11-28 15:43:49 +0000
+++ tests/gtk3/test_webkit.py	2016-02-17 13:44:00 +0000
@@ -3,7 +3,7 @@
 from gi.repository import (
     GLib,
     Soup,
-    WebKit,
+    WebKit2,
     )
 
 from mock import patch
@@ -19,19 +19,10 @@
 
 class TestWebkit(unittest.TestCase):
 
-    def test_have_cookie_jar(self):
-        # ensure we have a cookie jar available
-        session = WebKit.get_default_session()
-        cookie_jars = [feature 
-                for feature in  session.get_features(Soup.SessionFeature)
-                if isinstance(feature, Soup.CookieJar)]
-        self.assertEqual(len(cookie_jars), 1)
-    
     def test_user_agent_string(self):
         webview = SoftwareCenterWebView()
         settings = webview.get_settings()
-        self.assertTrue(
-            WEBKIT_USER_AGENT_SUFFIX in settings.get_property("user-agent"))
+        self.assertTrue(WEBKIT_USER_AGENT_SUFFIX in settings.get_user_agent())
 
     @patch("softwarecenter.ui.gtk3.widgets.webkit.get_oem_channel_descriptor")
     def test_user_agent_oem_channel_descriptor(self, mock_oem_channel):
@@ -39,19 +30,18 @@
         mock_oem_channel.return_value = canary
         webview = SoftwareCenterWebView()
         settings = webview.get_settings()
-        self.assertTrue(
-            canary in settings.get_property("user-agent"))
-        
+        self.assertTrue(canary in settings.get_user_agent())
+
     def test_auto_fill_in_email(self):
         def _load_status_changed(view, status):
-            if view.get_property("load-status") == WebKit.LoadStatus.FINISHED:
+            if status == WebKit2.LoadEvent.FINISHED:
                 loop.quit()
-        loop =  GLib.MainLoop(GLib.main_context_default())       
+        loop =  GLib.MainLoop(GLib.main_context_default())
         webview = SoftwareCenterWebView()
         email = "foo@bar"
         webview.set_auto_insert_email(email)
-        with patch.object(webview, "execute_script") as mock_execute_js:
-            webview.connect("notify::load-status", _load_status_changed)
+        with patch.object(webview, "run_javascript") as mock_execute_js:
+            webview.connect("load-changed", _load_status_changed)
             webview.load_uri("https://login.ubuntu.com")
             loop.run()
             mock_execute_js.assert_called()
 
=== modified file 'tests/gtk3/test_widgets.py'
--- tests/gtk3/test_widgets.py	2012-12-13 16:41:05 +0000
+++ tests/gtk3/test_widgets.py	2016-02-17 13:44:00 +0000
@@ -267,7 +267,7 @@
         self.vp.uri = expected_uri
 
         self.assertEqual(self.vp.uri, expected_uri)
-        self.assertEqual(self.vp.webkit.get_uri(), self.vp.uri)
+        self.assertEqual(self.vp.webkit.uri, self.vp.uri)
 
     def test_stop(self):
         self.vp.uri = 'http://foo.bar.baz'
 
=== modified file 'tests/gtk3/windows.py'
--- tests/gtk3/windows.py	2014-01-13 10:51:30 +0000
+++ tests/gtk3/windows.py	2016-02-17 13:44:00 +0000
@@ -1122,10 +1122,7 @@
     win = get_test_window(child=player, width=500, height=400)
 
     if video_url is None:
-        #player.uri = "http://upload.wikimedia.org/wikipedia/commons/9/9b/" \
-        #    "Pentagon_News_Sample.ogg"
-        #player.uri = "http://people.canonical.com/~mvo/totem.html"
-        player.load_html_string(html_vimeo)
+        player.load_html(html_vimeo)
     else:
         player.uri = video_url