WebKit 2 - Looking Forward: Alexis Menard
Transcription Whisper (large-v3), avec identification des locuteurs. À recouper avec la source d'origine.
Analyse automatique
Générée par IA — peut contenir des erreurs. Méthodologie
Chapitres
Répartition du ton (temps de parole politique)
Propositif 100 %
Questions et réponses
Taux de réponse directe : 88 % (directe = 1, partielle = 0,5, éludée = 0)
- 38:28OuverteRéponse directe
Will WebKit 1 be discontinued at some point in the future?
- 39:25OuverteRéponse partielle
I was wondering about the low-level details of the implementation.
- 41:12OuverteRéponse directe
I would like to know if you have multiple instances of Qt WebKit 2.
- 42:04OuverteRéponse directe
Is it correct that there's only one WebKit engine shared between WebKit 1 and WebKit 2?
Temps de parole
- Présentateur86 %
- ?11 %
≈ 85,5 interruptions / 10 min (chevauchements et interjections détectés).
Modèle mistral-small-latest · prompt v1 · les citations sont vérifiées mot pour mot dans le transcript ; le taux de réponse directe est calculé à partir des verdicts question par question. Aucun label idéologique n'est produit.
Bonjour,
merci pour être ici. Je sais que les présentations sont très, très nice. WebKit 2 n
'est
pas assez, donc c'est bien pour vous de venir ici. Donc aujourd'hui, il va être WebKit 2, en regardant. Donc l'agenda sera juste une introduction. Je vais parler rapidement sur WebKit 1. WebKit 1 est ce que vous trouverez sur Qt.
Et,
de course, je vais parler de WebKit 2, exactement ce que c
'est. About
me, so there was a mistake on the paper. My name is Alex Esmenard, I'm not Pierre Rossi. Yes, you heard well, I'm French, sorry for the accent, that's just the way it is.
I'm
the Qt WebKit team lead in INDT, so I'm taking care of like eight, seven-person team in INDT. We're working full-time on Qt WebKit.
I
used to be an Oslo troll, I was working for Nokia, Qt Development Framework. I worked in many parts in Qt, QMR, Graphics View, last year I did a
Q
Graphics View In-Depth talk,
so I
know my way in Qt.
I'm
an open source advocate, so like I'm
a
fan and I support a lot of open source projects. I think it's very good. I'm now an occasional KDE developer.
I
used to be very active, but since 2006, so I started KDE as a student project. And then after I mainly work on Plasma, then I launched a
mobile
project for
Plasma,
so it was like running KDE on small form factor like phones. Then now it's renamed and called Plasma Active and people are working full steam on it, so it's very good to see that
people
took over me.
And
now I'm just like using it and fixing it when it bothers me. That's all.
Working
for Andy is very fun because I left Oslo and by snow, the darkness, and my friend, party friends, and the awesome Norwegian food, which is sausages based, so-called Pulse, to Brazil, which is slightly different, which is beach, sun, caipirinhas, and my wife and my daughter. So it was very nice.
It
was a nice move. It was a smart move. Seriously speaking, let's go back to the presentation. So WebKit 1, KDE WebKit. So what is it? Quickly, I'm not going to go to details. There was a presentation yesterday about it. WebKit is an open source web content engine. Basically, you get HTML5
and
you, it handles it for you, basically. Very simple. So it's the most popular mobile engine. You find it on iOS, on Android, on Ream, on Symbian, on many phones. It is driving the open web on the desktop. WebKit's community is very active on W3C as like a thing for the standard to shape.
And
on the desktop, you find it on Safari, on Mac, on Windows, and in Chrome, Chromium. It's the same. Reconc and KDE or even Conqueror with
different
K parts. And then there are many cute apps that are using it. I'm not sure Google Earth is still using it, but they used to do it. And then Second Life also is using it.
The
basic architecture of WebKit, of course, I'm not going to go to details again, but like just so that you get basic ID so that we can compare to WebKit 2 afterwards. WebKit is like a
big
piece and it has like two main pieces inside. is like you have WebCore. So WebCore is everything you need to parse an HTML5,
understand
it,
and
render it. It also manages the CSS for you and all this related stuff like SVG and so on. And also you find the so-called HTML5 APIs
like to
make the HTML5 less, to follow and make the HTML5 stuff work, basically.
And
then you get another small, more smaller pieces, which is the JavaScript engine.
One
sit on the WebKit.org repository, which is JavaScript Core. JavaScript Core is the one that is developed mostly by Apple and is the one that's cheap with Safari and iOS, like Safari Mobile, so iOS. And otherwise, you get a bunch of glue codes so that you can hook up another script engine, which is the V8 one, which doesn't sit on WebKit.org project. It's another open source project and run by Google. And it's another JavaScript engine,
V8.
People say that V8 runs faster on some benchmark. I'm not gonna go into details, but basically you can hook up a JavaScript engine. The different one is JavaScript Core, but you can hook up V8. That's what Chrome is doing. Chrome is not using JavaScript Core. Chromium also.
And
then underneath this building, big blue box, we got something called the WebKit parse. And
you
have to see WebKit as like a huge
thing
that basically will understand HTML on that, but doesn't have like low-level functionality.
For
instance, WebKit will not put pixels on your screen. It will tell you, okay, I need to draw a rectangle.
And
then this is when the parse come into action. It's like they will say, okay, me, I know my part Qt. I know how to render a rectangle on the screen.
So
you basically plug your parts to the WebKit.
Big
box. And you plug your network stack. You plug your rendering stack. You plug everything. And so there are many parts.
I
just put the main ones. So Safari, also called Apple one. This is the one that's running on Mac and Windows. And
so
the API is mostly based on Cocoa, Objective-C. And there's the Google port or Chrome port,
which
is the one that you find on Google Chrome or Chromium. And also since they are working hard to unify also the Android ports into the same one. I think it's almost done. They removed the Android, like the last pieces of Android ports in WebKit. So I believe that now they fully use
the
Google port. Well, we don't know, but I believe.
There
is also our friend from GDK that have a part of WebKit that you find on Epiphany, I think, is the name of their brother. So and then the Qt port, which is us. And you have also the EFL ports, mostly pushed by Samsung. This is the one that they use on their mobile phone, I guess. We don't know exactly. And then you have also more tiny ports, like Windows C ports and so on, that's just more me now.
We
call major ports the one that are build bots running. Build bots like that's every single commit is builded and then tested. And like the one that you see here have like bots. It's like Qt has like a bots running 24 hours that check every commit, that check every test and see if there are regressions. WebKit is a very, very high-quality project because, of course, if you break something, you're going to break a lot of user web browsers, right? It's like if you break WebKit, you break all iPhones, you break all Safari browsers, all Google Chrome browsers, and all Nokia browsers. So it's like you better find the problems before they arrive on the end user's
hand. So
there's like we got like
a
huge number of layout tests that
check
website, check use cases, check APIs, check HTML use case, check CSS and so on, check handling. And
major
ports have those bots running. So GTK has one, Qt has one, Chrome has multiple, Safari has multiple. Actually, Qt has multiple. So we have like on Windows, Mac, Linux.
So
yeah, this is this. This is very basic. I'm not going to go into detail.
That's
all. This is WebKit 1 today. You find in Qt 4.7 or 4.8 through all those well-known classes, QWebView, QGraphicsWebView, QWebPage, QWebFrame. I mean, I'm not going to go into details. You
go
to the documentation of Qt, you'll find it.
So
now what is WebKit 2? So why are we looking
like
we make another version?
It's
not. WebKit 2 is not the next version of WebKit. The name is slightly confusing, especially that Qt WebKit is called Qt WebKit 2.0 or 2.1 or 2.2. Unfortunately for Qt WebKit, we came up with the name of 2.0 and so on before they announced WebKit 2. So anyways, too late. How old is this well-known like this? We cannot change, right? So it's like,
it's
not the next version. It's not. WebKit 2 actually sits on the same repository of WebKit. It's just a separate directory, right? So it's not the next version.
So
if you go back again to the basic architecture of WebKit today, so
this
is
the
purple box is your application running. So it's using Qt WebView or Qgraphics WebView.
It's
one process is your application process. And from your application, you call the API of Qt WebKit. And Qt WebKit API actually talk to WebCore, which I was explaining contain all the pieces and bits to units to run the HTML. And WebCore also
deal
with the JavaScript engine if you have a script on your web page, right? The API boundary is basically on top of QWebKit, right? This is where you call your API. This is where you call QWebFrame. This is where you call QWebPage, where you call QWebView, right?
So
this is today. One process.
It
works like this. Straightforward.
So
why WebKit 2 and what it is? So it's a new API layer. It's just an additional API that sits next to WebKit 1. It is not a compatible API, right? It's like
for
now, it's not a one-on-one API. What you do with WebKit 1, you cannot yet do with WebKit 2.
We're
still working on it. WebKit 2 is designed for a split process model. It means that you have multiple processes.
It's
a different API for the original WebKit 1. Just because it's a split process model doesn't mean that you can have the exact same API. It will not be the case.
And
as I said, it sits on the same request story. So you don't see it as a new version. It's just another additional API. It gives more choice to the user, basically. Why WebKit 2?
So
the main goals of WebKit 2 is
to
make the UI more responsive.
What
we don't want is letting your application event loop deal with patching the HTML from the network, getting all the signals when the bytes arrive,
and
then passing the HTML,
rendering
it, constructing all the objects, evaluating JavaScript and so on. This
makes
your application event loop busy. And we actually want to free it from that so that it's always free for managing user interaction. Read, first use case, scrolling.
You
basically want a smooth scrolling all the time, right? But if, for instance, you are trying to load like a huge image or rendering a huge image, then your event loop is going to be super busy, and your app's super busy, and the CPU's super busy
dealing
with that image, and then the scrolling is going to be slow.
And
so that, and of course, it's like on desktop, it doesn't show that much. But it's like on mobile phone like this, that's a huge issue.
If
you have multiple process,
it
improves the stability because
if
the web process, like the process, the separate process where you deal with the web, crashes,
then
it doesn't bring the UI with it.
You
can still restart the process, right? So today, if something happened bad in Qwebkit and it crashes, your application goes with it. There's nothing you can do.
So let's
say plugins like Flash,
which
are not very high-quality plugins, then you, if they crashes, then the entire Qwebkit goes down and then your application crashes, right? Which is very bad.
So
Apple,
for
instance, on the 5.0 Safari, they put the plugin separate process, right? So that if they crash, then just the plugin crash, right? We didn't do that in WebKit.
And
actually, after this, like, Apple thought about, like, yeah, let's actually make the entire web wandering into a separate process rather than just the plugin.
And so
today, for instance, if you could use Qwebkit and then use WebKit 2, then if it crashes, then it doesn't bring the UI with it, which is very, very good. It improves also a bit the security because
if
you've run an exploit for the web browser you're using based on Qwebkit or based on any WebKit port,
then
you will only access to the web process context, right? It's a separate process. So in theory, like, for instance, on Mac OS Lion, you can sandbox the web process. Like, sandbox the separate process. And then you can say, okay, well, this web process, this process will only have access to
what
the sandbox provide, which means that if you write any exploit with it, like, it was going to
limitate
the damage you could do because it's running in the sandbox, right? So this only for now, I'm aware, it's only existing in Mac OS Lion because they implemented the sandboxing at the kernel level so you can actually create processes that are sandboxed. Linux doesn't have this feature as well as Windows, but
maybe
it will come so we can actually do it. So here's the basic architecture of WebKit today. So
as
you can see, there are two processes. There is one that we call web process. This is the one that we take care of rendering, parsing, fetching the HTML and so on, making the website look something.
And
there's the UI process, which is the one your application is running on. Then you're going to have an API that you deal with it. And then seamlessly, it's going to be translucent for you.
It
will manage the process to create the process for you to run down and communicate with it. And actually afterwards, you can see it on your application, right? So the API boundary is still on the UI process. On your application, you deal with this new API.
And
then on the back, there will be a communication between the two process to first run it, then start fetching the... So if you say, I want to go to google.com, then the UI process will send a message to the web process. We're then going to start fetching google.com or start resolving the URL and then getting the HTML code for it.
And
the actual old web core and JavaScript engine and so on sit on this other process, right? This is the one that will render, that will fetch, that will parse, that will resolve the style, that will do everything in time. And then you've got a communication between both.
I
have
another
explanation afterwards.
So
the main difference is two processes, right? One where your application sit, the UI process, and the other that is taking care of rendering the web content or parsing it and fetching it and so on. But for you, the API boundary is still the same. You don't have to care about the IPC. You don't have to care about the other process. You
don't even
know if
that
it exists. For you, it's totally transparent
in
the API. Okay.
For
the curious,
Chromium
also have some kind of like multiple,
like
every single tab of the Chromium or Google Chrome runs into a separate process, right?
And for
them, it's different. They don't use WebKit 2 or at least for now, they don't. I'm not sure they will ever, but perhaps.
They
have something they call host process,
which
is where the application is, like Google Chrome,
right?
And then the application is responsible of creating the processes, right? So every single tab is responsible for creating the process that will actually run down the page.
And
then they have an API which is called what? Like the application has a render process.
And
then they just load the API inside, like the WebKit API inside. So the API boundary is not on the UI process. It's actually on the render process or some kind of web process, right?
So
as
you
can see, it's very different. WebKit 2, that's transparent for the application. On Chromium, they manage themselves the thread. So Google Chrome manage themselves the processes.
So it's
just a different approach. They actually came up with the approach before WebKit 2.
So
that's the main difference between Chromium and Google Chrome and WebKit 2.
So there
are two key subsystems that support the process division in WebKit 2. There is something they call core IPC.
So
it's an abstraction for general message passing between processes, right? It's so that the processes can communicate together.
See
it like a bit of a very, very simplified version of Dbus, basically, on Linux. They made their own because, for instance, it's...
I
mean, Apple came up with WebKit 2 project, right? So it's like, it's not the Qt team that came up with it.
It's
Apple, right? So Apple has this tendency of rewriting everything. So it's like,
in
theory, they could have used another IPC system, right? But, like, they've worked their own. It's very simple.
And
then there is...
Of
course, what I'm talking here is very oversimplified. But so that for you, it's an introduction, right? I'm not going to the core details, basically. But it's like, there is also a drawing area, which is an abstraction for cross-process drawing. So it's
like... So
that the web process can render into a shared places that the UI process can read to actually show it on the screen, right? So it's like, it's like some kind of shared memory that you can... One render, and when they finish, then the other reads to show it on the UI process, right? So show it on your application.
There
are multiple drawing strategies. Of course, this most simple one is a shared memory bitmap, right? You just write it when it's finished, and you just show it.
I'm
not going to talk about more complicating stuff like accelerated compositing when you accelerate animations on, but, like, this is the most basic architecture, right? I'm drawing into this shared place, and then I show it on the other process when I'm done.
So
I made a very, very simple example on how this happened. So for instance, in your application, if you ask, okay, could you please load google.com, then it's going to talk to the WebKit 2 layer
that
will then send a message to the IPC bus that will say, okay, I'd like to load this URL. Then the IPC will then forward it to the web process. The web process will get the message and say, ah, I need to load, and we'll start fetching the... like reserving the UI, then getting the HTML file, and then start rendering.
And
then the rendering stuff will basically render into this drawing area. It's
the
same. It's very over... It's very simplified,
right? But...
So you get an idea.
And
then when it's finished, then it will send back a message to say, oh, I'm finished loading. Then it goes through the IPC. The IPC gets to the WebKit layer on the UI process, and then you finally get the signal on your application, right? Everything is asynchronous, right? Of course, loading a URL is by default asynchronous, right? But like every API that will be with WebKit 2 is asynchronous, of course, because we have to send it to the IPC, and then we have to wait the answer off the web process, right?
And
then when it's done or undoing, then
the
UI process knows that it can
read
from the drawing area, and then you will start painting it, right?
And
in that case,
Qt
is going to do the painting for you, right? So, Qpator, right? So Qt WebKit 2 requirements are Qt 5 within graph.
Why
Qt 5? Because since it's a huge rewrite, I mean, we cannot just port QwebView to this. It's just a rewrite of the API. We said, well, you know, it's like,
there
will be no Qt 4 X release, you know? What's the point trying to develop for it? Let's just go to Qt 5 since we're going to break everything anyway. It's like the API needs to be changed. It's a new API, asynchronous, and so on. And also the fact that there was SynGraph, which is very good because
we
wanted to use like on mobile phones, so we used like this like tile backing store, you know, when you have tiles so that the scrolling is faster on mobile phones. And then SynGraph would match really nicely for us,
so
we can have tiles on those SynGraph and so
on.
And so that was one good
something
that was pushing us to move to Qt 5. And also, of course, that
OpenGL
is mandatory because SynGraph, right? So it's like, it can be software emulated or hardware, but like we use OpenGL because OpenGL is very nice for us for everything that is related to, you know, CSS animation and, you know, stuff like WebGL.
We
need OpenGL. So it's like,
it's
easier for us, you know, to have one supported code path, which is the OpenGL one that we know that's going to perform very well because it match really well.
The
problem we have today with Qt WebKit 1 API is like this millions of combination you have with accelerated compositing. If you use a graphics view, if you use a QWadget or if you use a graphics view with a GL viewport and stuff like that, then for us it was just hell because we have like millions of combinations possible and then
you
always have
cases
where Qt WebKit was underperforming, like WebGL process. Or CSS animations, stuff like that. Now that we have one supported code path which is going to be OpenGL, then
we
know that this one was going to, or will work hard to make that one work fast.
That's
what I said. We'll make it easier for us to support WebKit pictures like WebGL and so on. If we make the OpenGL mandatory, then it's over for us. We know that WebGL is going to, we can work and make it work fast because there is no other combination to support like software or other stuff.
The
API today, which of course is subject to change, of course, because we are still working hard on it. But we decided to split the API into two use cases,
the
desktop one
and
the touch one. Why? Because, for instance, on the Qdesk, like we found out that, for instance, having one view is like, makes code very complicated, especially when you need to handle the touch stuff. And QGraphics WebView is like, touch handling is a mess, especially when you're just in the case of, I'm a desktop, I just use the mouse, I just don't care of, you know, managing touch events, right?
So
it's like,
in
order to simplify everything, we decided to split up. And also, many APIs, you know, it doesn't make sense in a touch view, right? Why you need all the links on a touch screen, right? Like, you don't have all the events on a touch screen. So it's like, simplifying the, like we have a common, like on the implementation, we have like a common part, basically. But like, the API itself is much more simpler in the touch web view than the desktop web view, just because some feature doesn't apply on the touch wall.
So
we decided to split up for code simplicity and for also not bloating the API on,
on
feature that doesn't make sense in some of the walls.
The
API is focused on QML. So we want to have QML elements. So you will do like, import Qt Web Kits, and then you get a QML element up and ready for,
for using
it in your app.
But
don't worry, C++ API is still here. I mean, the QML element is using the C++ API. We just have a plug-in for it. It's just like,
by
API focused to QML, I meant that
it's
going to be an API property base, right? Because QML. QML is just about properties, right? So of course, you know, like, you will have like a bunch of properties that, you know, in C++ you could just have solved them with Enum. But Enum is not very usable in QML, or it doesn't really make sense. So for instance,
we
have like, the API will look nice for QML, but it will be usable in C++, but it will not be the main candidates for API decision. Like, we're not going to say, ah, we are not putting, we are not, we, for instance, we say, we're going to put properties rather than Enum because we want to focus for QML. So in C++, it's going to look more verbose, but it's still going to work, right? It's just that we are not going to put Enum for it,
as
the example I was explaining. But the API is there. Symbols are exported.
H
file are there. Documentation will be here. So you can still use it in C++. It doesn't make
sense.
And the QML elements,
you
use them. So
make
no mistake, there will be C++ API. Just that the API is going to look nice for QML rather than C++. So a tiny example, for instance, where you can create this desktop preview in QML.
You
can fill it with, like, the Encore. It has all the Encore property stuff like in QML. And you've got a bunch of signal, you know, also slots, and so that you can connect them
in
QML when
the
loading starts, when the load succeeds, when the load fails. You've got parameters with the signal, you know, so you can get the error code and do something in your application.
And
for instance, you get on link over. This is for the desktop use case, right? It doesn't make sense on the touch screen, right? So this API doesn't exist on the touch web view, for instance, right? And in other part of the code, for instance, you can use it, webview.load, and then you just give the URL and
it
starts loading for you.
So
very convenient to use, very, very fast.
But
WebKit
2 has,
like, huge challenges.
Of
course, I was explaining, it's asynchronous.
That
makes API design really, really tough to make, as like. And some of the APIs are very, very complicated, two parts. Namely, QWebElements, Everlet JavaScript, and Add to JavaScript window objects. So those are, like, for those people that make hybrid applications.
Why?
Because
those
guys, they rely a lot on WebCore internal. So you remember WebCore is, like, all these, like, tools that you need to run under the HTML page and so on.
And
these APIs, they sit on the UI process, right?
But
the WebCore is not anymore on the same process, right? It's on the other one. So it's, like, start to be really, really bad. And so,
yeah,
so they rely on WebCore internal. So, of course, it's on the other process, which means that you cannot use them directly. So it has to go through IPC.
And then, Everlet
JavaScript is, like, synchronous, right? So, like, you call something and then you get a written value.
It's
like, we cannot have synchronous calls from the UI process, right? It's going to block the web process while doing stuff. It's just wrong, right? We don't want synchronous API. Now, of course, we have to solve it. And we know that, you know, hybrids applications and hybrids features of QWebKit is one of the strong point of WebKit.
So
now, we're still looking at how we could solve those hybrid use cases.
And we
don't have yet the big picture, but
we're
going to change the way
your
application is talking to WebKit. Like, QWebElement, the way it exists today, it's not going to be the same way for WebKit 2 just because it's asynchronous.
And it
may not, you know, it's like WebKit 2 is a huge work for us. It may not be yet already that in 5.0 you have, like, already a one-to-one mapping for hybrid functionalities.
But
it will come with, like, 5.1 or 5.2, right? It's like,
5
.0 is not the last version of Qt 5, right? So it's like,
we'll
still work on it. But basically, it will change the way you talk. It's like,
it's
going to be more like JSWorker if you know what it is. Like, JSWorker is like when you thread, like, you can make
JavaScript
execution on separate threads, right? So it's like, you can say, okay, this piece of code of JavaScript is very heavy. I'm going to just throw it on a separate thread. This is HTML5 feature, right?
And
then
this,
this, how this API works is like, is messages and callback, right? You communicate to this thread by messages and then you get callbacks when, for instance, the thread is done.
And
I think it's going to be the same way. You're going to say, okay, I'd like to send this message with this JavaScript code. And then it's going to go to the web process. And then when the web process finishes with it, then you're going to get a callback.
So
it's going to be, rather than being a synchronous method like evaluate JS, it's going to be like, I send this and I'm going to callback. And for instance, there was like a lot of use cases that are like, you know, custom network access manager.
Of
course, you know, as I said, the API manage for you the web process, right? You don't know that it exists. Like, you just call WebKit APIs and then, you know, it's created the web process for you, make the communication between.
So,
but the actual network access manager set on the other process, right? And many applications,
they
have their own network access manager. And it was one of the strengths of the use case. Same. We have to be,
we
have to make that possible. How? I see two options. Either we make a plug-in on the web process side, so that when the web process is created, it will look for a plug-in that contains a network access manager that you can specify.
Or we
make the web process like a tiny library that's so that you create the web, like, so that we know that and then you create the web process. So, like,
the
main function is you that you create, so you create the web process with a tiny API and then you attach your network manager on it and then we use that one for creating the web process.
There's
also, you know,
in
WebKit 1, you could call render, you know, and then you could render a part of the web page and then put that into a Pixmap or show it somewhere.
That
was a good use case of there, but, like, you made circuit.
You
wanted to make an app and then you show a piece of the website in your app or any website. Same, you know, how, the UI process doesn't know anything but the web process, right? Like, except talking to it. So, how you can, like, how we could
ask
you to render synchronously and then get that to a Pixmap is going to be very complicated.
So,
same, I think we are going to have a dedicated
elements
or class for doing that, right? So, for instance, a dedicated, like, I don't
know,
WebSliceElements, QMLElements, where you specify the WebView you're using and then you specify a selector, you know, like a GS, GQuery selector. You say,
oh,
I'd like
this
element ID, you know, full bar, and then he's going to render only that one for you. But it's not going to be, like, you call render and so on.
And
it's, like, it's going to be dedicated APIs for it because we just can't do those anymore. It was just the process splitting. I just have a little demo. So, by the
way... So,
I think I'm...
It's
fine. I'm going to hold it. So, this little demo, by the way, so this presentation was, like, HTML5 based
and
it's
running
on the web browser that is
made
in QML, QML2.
So,
running in Qt5 and this presentation was run out using WebKit2.
So, as
you can see here, I go, there's a web browser. So, it's...
You
have full screen mode.
You
can leave the full screen mode.
And
then,
you
can open new tab.
And
then, you can go to AV images
website.
I'm not on the network.
That's
where
I'm... Hopefully,
it's going to work. There's a network,
so...
Well, I have no network. But, anyway. So, as, like... Unfortunately, I cannot show you, but it's a bit bad.
But,
yeah. So, it's like... It's a web browser, like, basic bookmark support. So, you see, you can start doing stuff without the API we are developing.
And so,
you can, of course, you know, reload the presentation like this. And then...
So,
I'm going to go to the end.
And you
can move the tabs around.
So... Whoops. So,
a bit like Chrome, basically. And... So, yeah. It's like... The cool part of it is, like, if you go to this, for instance, up. And then, you do PS, aux.
And
then, you
grab... Grab
for... Cut. You see that there is this cut web. I'm going to increase the font.
You
increase it.
With
one hand, it's going to be tough. So, as you can see, there is this cut web process right running. As well as, if I grab for my application, which is called Snowshoe. It's an open source project, by the way. So, you see, there is my UI, Snowshoe. And then, there is this web process. That is the web process I was talking about. Now, here, it is the web process right running. And then, let's say, I emulate a crash.
So, I'm
going to kill the web process, right?
So,
let's say I was using a
Flash
plugin,
and
it crashes.
So,
I kill. Boom.
My
UI is still here. Right?
The
web process crashed, but my UI is still here.
And
I just do a reload,
and
it's going to reload it.
Right? So,
that's cool, right? So, whatever happened on the web process,
it
brings, it doesn't bring down your UI. You just reload it, and then,
you're
good to go.
So,
it makes more robust application.
So, of
course, we want your feedback, especially for the hybrid use case,
as
we are discussing the APIs on the mailing list, and discussing,
you
know, different approaches we can have.
We
already have quite a lot of feedback from Richard Moore, which is not here. It's too bad. And so, of course, we'd like you to, you know, participate with us, and try the new APIs, and say that,
tells
us if you can solve your hybrid use case or not. And we are usually on IRC, either WebKit or Qt WebKit. Otherwise, you can find on list.webkit.org, there is a Qt mailing list, and you can register
to
it, and, you know, tell us about your hybrid use case that you,
that
may not work with WebKit, too.
But
keep in mind that
we
are still working on, you know,
the
basic functional idea right now. So, it's like,
we
may not have all the hybrid features back for 4.0,
but they
will come at some point. We know that it's a very important use case of Qt WebKit.
But
we just want the stuff up and running first, like, you know, just run on web pages.
So,
that's all.
Thank
you for your attention.
If
you have any questions,
go
for it.
I
have to wait the microphone.
Are
there any questions?
Yeah.
Oh, okay. Yes. Thank you. Will WebKit 1 be discontinued at some point in the future?
Like,
it's
just like QWidgets. It's going to ship with 5.0. As I was explaining, it's a separate API.
It's
going to be there in 5.0.
We're
just not going to work
anymore
on it, at least the Nokia employees.
It
works, right? It's tested. We have bots running
with
it every day. So, if we break something, we are going to know about it. So, it's not going to get worse. But it's not going to receive any new improvement, at least from Nokia, because we don't think it's the future. We think we should focus on that one.
And
get the hybrid use case back in shape.
Get
everything up and running. And then, so that people can switch to that one. Because we think it's better. You see, right?
Like... It's
good.
Hi. Thanks for the presentation. I was wondering about the low-level details of the implementation. I mean, especially when we're talking about Q platform abstraction, QPA.
How
is this surface going to be rendered? I mean, the QPA offers the acceleration,
but
then you have to map this area on the same memory? Like a map?
Oh, it's...
So... How
I can explain it easy?
It's
like...
We
just draw it. It's like...
See
it as a Qpix map, right? So, it doesn't matter which platform we're running.
We
just draw that surface, right? It's like if you call Qpainter, draw a Pix map.
So,
we're not going to have a... We're only going to have the raster painter,
right?
No. It's going to be... It's like... As I said, we're using Graph. It's going to be OpenGL.
Okay.
We'll run all this surface using OpenGL.
And
also, in the future, it's like going to be... All CSS animations, stuff like that, it's going to be OpenGL accelerated.
Ah!
The process is raster, right?
It's
like the process... The web process run with raster today, right? It's like today, it's still using
Qstyle,
Qpainter, and friends. Because we haven't yet get
other
alternatives. But, yeah, to actually render in the surface itself, it's the rest of the web process. But then to draw it on the UI, it's using Syngraph and OpenGL.
I
would like to know if you have multiple instances of Qt WebKit 2.
Is there then only one process in background or...? So today, the implementation has one web process.
So
if you have multiple pages, like in the web browser I was running, so like here,
I
have one web process for those two,
for
the three tabs.
Just
because WebKit 2 today, but it's almost there, doesn't support multiple web processes. One per page, basically. But it's on the pipe.
What
that means is like when you create your web view with your web page, it's going to load one process delegated for each one, right?
Today
is not the case.
Is
it possible to make a decision in
what you use?
We'll probably make a decision. You'll be able to decide.
Okay. Thank
you.
So
I'm wondering if it's, is it correct that there's only one WebKit
web
engine
and
that's shared between,
call
it WebKit 1 and WebKit 2? Yes. And so does that mean that as WebKit development continues with like HTML5.1 or whatever,
that
those will sort of implicitly come also to the WebKit 1 bindings?
Yes. Exactly. I mean,
it's like, it's like, you have to see that the WebKit layer, like the Qt WebKit layer is tiny. It's not that much code. We use the WebCore and the development of HTML features happen in WebCore. So even though we are not going to work on Qt WebKit 1, or at least no company are not going to do it, I think, we
are
not going to improve the API, right? We're not going to add API, but the features in the engine itself, you'll get them for free. I mean, if we support, I don't know,
new
input type in HTML, those will work for free on the WebKit 1 API,
right?
Because
there's
no, it's like, there's, they use WebCore, right? So it's like, those will work. So WebKit 1 will still evolve as WebCore is continuing evolving.
What
we're not, what's, what I think we should not focus on is adding more APIs in Q WebView and Q Desktop WebView and so on. But having
improvement
from the engine, you'll get them for free for sure.
And
thank you for assisting. And I hope you'll enjoy the conference.
Thank you.