WebKitGTK+ / Wayland Demo and Future Work

So first things first, check out the video below to see the demo, it showcases Web (Epiphany), the default browser of the GNOME platform, running on WebKit1 under Wayland (Weston) and illustrates:

  • Browsing of regular text/image based sites
  • Embedded HTML5 video playback (Youtube and native)
  • 2D and 3D CSS transforms
  • WebGL

If you are intrigued to know more about WebKit, Wayland and Web, keep reading. If you already know about this and are more interested in knowing what is still missing, go here.

So WebKit you say, what is that and why should I care?

There is a significant chance that when you are reading this you are using WebKit. WebKit is an open source web browser engine that powers a variety of software that we run on our desktops, phones and a myriad of other gadgets every day and with the popularity that HTML5 has achieved this will only get bigger and bigger in the future.

Igalia has always considered the web the platform of the future and with the passing of the years we have seen this become more and more real. In this process we are certain that WebKit has played a very significant role, providing an open framework where many companies and individuals have worked together for years, building something that is at the core of most HTML5 based solutions out there. These companies and individuals have done a remarkable work in pushing the technology forward and make all this possible, and at Igalia we are very proud to be a part of this too.

Ok, so WebKit is important… but what does that have to do with Wayland?

WebKit and HTML5 are not the only big things happening out there. Wayland will progressively replace X in the coming years, something outstanding when you consider the fact that X has been there for 3 decades! This replacement is not trivial though, X has established the basis for graphical user interfaces since… well since before I even knew computers existed! Much of the software we use every day is based on X directly or indirectly, so with the change, a lot of software that we love will need to undergo some changes and adaptations to work with Wayland.

Platforms like GNOME and KDE have plans to support Wayland. GNOME in particular plans to have complete Wayland support some time in 2014, but for that to happen efforts have already started at many levels. GTK+, the graphical toolkit of the GNOME platform, is already compatible with Wayland, which is a big part of what needs to be done to make GNOME itself run on Wayland. Still, there are plenty of X bits in many other parts of the platform that will need to be addressed. WebKitGTK+ is no exception to this.

The work to get WebKitGTK+ ported to Wayland was initiated by my colleague José Dapena and I have recently joined this effort. I started from Jose’s patches, checking the current state of things and trying to identify the missing bits. I hope the video at the top gives a good idea of where we are now and later in this post I will explain what is still missing. For now I have focused mostly on WebKit1, but I believe most of my findings are just as valid for WebKit2. Hopefully this will help us define specific tasks and make steady progress in the months to come.

And what did you do to get that demo exactly?

Since WebKitGTK+ is based on GTK+ and GTK3 already provides a Wayland backend, we need to make sure that we use GTK3 in WebKitGTK+ and Web, which we already do (except for the plugin process which still needs GTK2, more on this later), so thankfully a lot of the heavy lifting had already been taken care of.

The second thing we need to check  is the backing store backend we use. We need to replace the X11 implementation with something more agnostic. Good that we already have a Cairo implementation of the backing store available!

A few other minor fixes aside, these two items represent most of what I needed to get the demo running.

How far are you from full Wayland support then?

1. Accelerated compositing

Current implementation of accelerated compositing depends on XComposite and XDamage. We need to identify how to re-implement this functionality in Wayland (at least the bits that depend on X directly)  while we make sure that we keep the same performance advantage.

2. Fullscreen video playback

Fullscreen video playback with GStreamer is implemented using the video overlay interface which is platform agnostic. However, even if the interface is platform agnostic, it requires GSteamer to provide a platform-specific implementation. There is a Wayland sink in GStreamer, however this sink does not implement the video overlay interface and I still don’t know if this is to be addressed in GStreamer or when. If the waylandsink in GStreamer is extended to implement the video overlay interface then the good news is that the work on the WebKit end should be fairly straight forward.

3. Plugins

Various plugins won’t work in Wayland. The Flash plugin in particular is known to only work with GTK2 (this is the reason the Plugin process in WebKit2 requires GTK2 actually). Since GTK2 does not support Wayland the consequence is that we won’t be seeing the Flash plugin in Wayland for now. We contacted Adobe some time ago on this subject to see if they would be interested in porting their Flash plugin to GTK3, but apparently this is not a priority for them. Even more, this restricts all plugins to use GTK2 and hence, it will pretty much disable all plugins under Wayland (well, at least the ones that need to render). Another example of a plugin needing work is Java, which seems to have direct X dependencies in its code leading to a nice crash when you load a Java applet for example. I did not do a comprehensive analysis of all the plugins, but this is definitely a problematic area in the short term. Of course, this will probably change with time, when Wayland becomes mainstream plugin developers will have to port the plugins or lose user base and be replaced by other implementations. Some plugins may even become completely obsolete before Wayland becomes mainstream too, that could be the case of the Flash plugin maybe. Bottom line: plugins suck and if you are a web developer you probably want to avoid them if you have an alternative.

4. WebKit2

WebKit2 brings a bigger challenge to the Wayland port due to the split process architecture that it introduces. In this context we need to make sure that all the rendering and painting that takes place in coordinated form between the UI process and the Web process use Wayland mechanisms for GPU acceleration efficiently. We still need to design a good solution for this before getting hands-on with fixing it and we will need to approach the Wayland community and discuss how WebKit2′s architecture fits in Wayland as it is today. Wayland has just integrated support for sub-surfaces and this is something that may come in handy in the context of this problem too.

5. Web (Epiphany)

Web is the default browser of the GNOME platform and a good test ground for WebKitGTK+ too. Making WebKitGTK+ Wayland compatible would not be good enough for GNOME if Web isn’t. Fortunately, WebKitGTK+ and GTK3 do most of the work for Web in this regard, although there seem to be some X interactions in Web itself they do not look difficult to replace or find a workaround for. I will use the video above to prove my point ;)

Conclusions

So that’s it, even if there are still some issues that need further work, WebKitGTK+ and Web can run in Wayland with few changes as they are today, including things like WebGL, CSS Transforms or embedded video playback. Next in the roadmap are accelerated compositing and WebKit2. We are planning to make progress in these areas in the coming months, so if you are as excited as we are for full Wayland support in WebKitGTK+ including WebKit2 and Accelerated Compositing, stay tuned!

11 comments

  1. Thomas Andersen

    Nice! Is this code committed so that we can expect a release with basic wayland support?

    When testing the wayland support in gnome I found these modules to be failing due to webkit1/2: empathy, epiphany, yelp, devhelp, evolution. I would love to have the relevant fixes available so that we can dive into any app-specific problems for those modules as well.

    • Thomas: we have not committed the patches yet but we are working on it, I hope we can get these initial paches committed shortly.

  2. Andrew Millington

    Awesome! I wonder if there is an improvement to the results in benchmarking.

    • Andrew: I did not run benchmarks yet. For the benchmarks to make sense I think I should be running my tests on a pure Wayland setup and here I was running Weston inside an X session, which I guess involves a performance penalty. In my setup performance was worse than in a pure X environment, which was particularly obvious when running WebGL. We plan to do tests on a pure Wayland setup in the near future though so I hope we can have more meaningful information about performance soon.

  3. Andrew Millington

    Is there any work in getting Lightspark/Gnash working under Wayland?

    • Andrew: I have not been following the projects closely so I don’t really know. I am not aware of any work in this direction. You should probably ask the developers directly.

  4. Any chance we will be seeing Epiphany under Wayland on the Raspberry Pi soon?

    • Max: Right now we need to find a solution for accelerated compositing and WebKit2 in Wayland. Once we have that figured out I guess you should be able to run Epihany on the Raspberry Pi too. Also, I have not tried it myself, but I suppose you may be able to run Epiphany now already if you configure it with WebKit1 and disable accelerated compositing.

  5. Regarding accelerated compositing and WebKit2 (bullets 1 and 4) and also taking a look at [1].

    You mention here that you will take a look at the subsurfaces work, yet in that (later) email you don’t mention it. Thing is, isn’t Wayland supposed to be the compositor King?

    Shouldn’t Webkit2 hand over all its layers as subsurfaces and let the compositor do the work, instead of having the WebProcess compose the layers? (thus, WebkitGTK+ can take advantage of the Raspberry Pi’s OpenGL-free composition backend with zero lines of code).

    Perhaps you investigated more about this and found out this is not how it’s supposed to work?

    – nachokb

    [1] http://lists.freedesktop.org/archives/wayland-devel/2013-July/010169.html

    • nachokb: the thing about subsurfaces is that I think it would need some native integration in the toolkit (GTK+ in this case) before you can them efectively.

      Other than that, to be honest I am not completely sure that we can just move all the composition to Weston, there is a large code base in WebKit to do this and I believe it is very likely that there are optimizations and corner cases that are quite specific to WebKit.

      That said, I have not discarded the idea, and if GTK+ lands native support for susbsurfaces at some point I think it is something worth exploring.