mirrors/serenity
1
0
Fork 0
mirror of https://github.com/SerenityOS/serenity.git synced 2025-01-24 02:12:09 -05:00
Code Issues Projects Releases Packages Wiki Activity
serenity/Userland/Libraries/LibWeb/OutOfProcessWebView.cpp

404 lines
14 KiB
C++
Raw Normal View History

WebContent: Start work on browser process separation :^) The "WebContent" service provides a very restricted instance of LibWeb running as an unprivileged user account. This will be used to implement process separation in Browser, among other things. This first cut of the service only spawns a single WebContent process when someone connects to /tmp/portal/webcontent. We will soon switch this over to spawning a new process for each connection. Since this feature is very immature, we'll be bringing it up inside of Demos/WebView as a separate demo program. Eventually this will become a reusable widget that anyone can embed and easily get out-of-process web content in their GUI. This is pretty, pretty cool! :^)
2020-06-17 17:31:42 +02:00
/*
* Copyright (c) 2020, Andreas Kling <kling@serenityos.org>
* All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions are met:
*
* 1. Redistributions of source code must retain the above copyright notice, this
* list of conditions and the following disclaimer.
*
* 2. Redistributions in binary form must reproduce the above copyright notice,
* this list of conditions and the following disclaimer in the documentation
* and/or other materials provided with the distribution.
*
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
* DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
* FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
* DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
* SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
* CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
* OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
* OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/
LibWeb: Rename WebContentView => OutOfProcessWebView
2020-08-17 16:20:47 +02:00
#include "OutOfProcessWebView.h"
WebContent: Start work on browser process separation :^) The "WebContent" service provides a very restricted instance of LibWeb running as an unprivileged user account. This will be used to implement process separation in Browser, among other things. This first cut of the service only spawns a single WebContent process when someone connects to /tmp/portal/webcontent. We will soon switch this over to spawning a new process for each connection. Since this feature is very immature, we'll be bringing it up inside of Demos/WebView as a separate demo program. Eventually this will become a reusable widget that anyone can embed and easily get out-of-process web content in their GUI. This is pretty, pretty cool! :^)
2020-06-17 17:31:42 +02:00
#include "WebContentClient.h"
LibWeb: URL-encode/escape variables used in OOPWV's crash error page This fixes arbitrary HTML injections via the URL on OOPWV's crash error page - probably not a security issue, but annoying nonetheless.
2021-01-30 21:57:16 +01:00
#include <AK/String.h>
#include <AK/URLParser.h>
LibWeb+WebContent: Support displaying tooltips in OOPWV
2021-03-30 12:10:06 -04:00
#include <LibGUI/Application.h>
LibWeb+WebContent: Keep track of screen rect It is now possible to get the up-to-date screen rect from a Web::Page.
2021-04-04 00:12:37 +02:00
#include <LibGUI/Desktop.h>
LibWeb: Implement Window.prompt()
2021-02-20 12:05:18 +01:00
#include <LibGUI/InputBox.h>
LibWeb: Support window.alert() in multi-process context Alerts are now delegated to the embedding GUI process.
2020-09-12 11:56:13 +02:00
#include <LibGUI/MessageBox.h>
WebContent: Start work on browser process separation :^) The "WebContent" service provides a very restricted instance of LibWeb running as an unprivileged user account. This will be used to implement process separation in Browser, among other things. This first cut of the service only spawns a single WebContent process when someone connects to /tmp/portal/webcontent. We will soon switch this over to spawning a new process for each connection. Since this feature is very immature, we'll be bringing it up inside of Demos/WebView as a separate demo program. Eventually this will become a reusable widget that anyone can embed and easily get out-of-process web content in their GUI. This is pretty, pretty cool! :^)
2020-06-17 17:31:42 +02:00
#include <LibGUI/Painter.h>
WebContent: Basic scrolling support! :^) The WebContentView widget now inherits from GUI::ScrollableWidget and will pass its scroll offset over to the WebContent process as it's changing. This is not super efficient and can get a bit laggy, but it will do fine as an initial scrolling implementation. Just like the single-process Web::PageView widget, WebContentView also paints scrolled content by translating the Gfx::Painter.
2020-07-04 23:19:32 +02:00
#include <LibGUI/ScrollBar.h>
LibWeb: Make WebContentView show the hover hand over links :^)
2020-07-06 23:32:12 +02:00
#include <LibGUI/Window.h>
LibWeb: Fill OOPWV with the palette base color until we have pixels We were painting unfinished pixels while waiting for the WebContent process to render the page. This caused OOPWV to flicker black sometimes, which looked pretty bad. This way we still flicker, but at least we flicker with the correct palette color. :^)
2020-12-29 00:44:58 +01:00
#include <LibGfx/Palette.h>
WebContent: Start work on browser process separation :^) The "WebContent" service provides a very restricted instance of LibWeb running as an unprivileged user account. This will be used to implement process separation in Browser, among other things. This first cut of the service only spawns a single WebContent process when someone connects to /tmp/portal/webcontent. We will soon switch this over to spawning a new process for each connection. Since this feature is very immature, we'll be bringing it up inside of Demos/WebView as a separate demo program. Eventually this will become a reusable widget that anyone can embed and easily get out-of-process web content in their GUI. This is pretty, pretty cool! :^)
2020-06-17 17:31:42 +02:00
#include <LibGfx/SystemTheme.h>
LibWeb: Register the OutOfProcessWebView widget
2020-10-08 21:11:32 +01:00
REGISTER_WIDGET(Web, OutOfProcessWebView)
LibWeb: Move OutOfProcessWebView into the Web namespace
2020-08-24 15:33:18 +04:30
namespace Web {
LibWeb: Rename WebContentView => OutOfProcessWebView
2020-08-17 16:20:47 +02:00
OutOfProcessWebView::OutOfProcessWebView()
WebContent: Start work on browser process separation :^) The "WebContent" service provides a very restricted instance of LibWeb running as an unprivileged user account. This will be used to implement process separation in Browser, among other things. This first cut of the service only spawns a single WebContent process when someone connects to /tmp/portal/webcontent. We will soon switch this over to spawning a new process for each connection. Since this feature is very immature, we'll be bringing it up inside of Demos/WebView as a separate demo program. Eventually this will become a reusable widget that anyone can embed and easily get out-of-process web content in their GUI. This is pretty, pretty cool! :^)
2020-06-17 17:31:42 +02:00
{
LibWeb: Don't show unnecessary scrollbars in WebContentView This behaves a little weird right now, and will probably require more coordination between the widget and the WebContent process.
2020-07-06 22:02:38 +02:00
set_should_hide_unnecessary_scrollbars(true);
LibGUI: Add Widget focus policies Every widget now has a GUI::FocusPolicy that determines how it can receive focus: - NoFocus: The widget is not focusable (default) - TabFocus: The widget can be focused using the tab key. - ClickFocus: The widget can be focused by clicking on it. - StrongFocus: Both of the above. For widgets that have a focus proxy, getting/setting the focus policy will affect the proxy instead.
2020-10-30 10:58:27 +01:00
set_focus_policy(GUI::FocusPolicy::StrongFocus);
LibWeb: Handle WebContent process crashes gracefully :^) The OOPWV will now detect WebContent process crashes/disconnections and simply create a new WebContent process in its place. We also generate a little error page with a link to the crashing URL so you can reload and try again. This a huge step forward for OOPWV since it now has a feature that IPWV can never replicate. :^)
2021-01-30 18:20:40 +01:00
create_client();
WebContent: Start work on browser process separation :^) The "WebContent" service provides a very restricted instance of LibWeb running as an unprivileged user account. This will be used to implement process separation in Browser, among other things. This first cut of the service only spawns a single WebContent process when someone connects to /tmp/portal/webcontent. We will soon switch this over to spawning a new process for each connection. Since this feature is very immature, we'll be bringing it up inside of Demos/WebView as a separate demo program. Eventually this will become a reusable widget that anyone can embed and easily get out-of-process web content in their GUI. This is pretty, pretty cool! :^)
2020-06-17 17:31:42 +02:00
}
LibWeb: Rename WebContentView => OutOfProcessWebView
2020-08-17 16:20:47 +02:00
OutOfProcessWebView::~OutOfProcessWebView()
WebContent: Start work on browser process separation :^) The "WebContent" service provides a very restricted instance of LibWeb running as an unprivileged user account. This will be used to implement process separation in Browser, among other things. This first cut of the service only spawns a single WebContent process when someone connects to /tmp/portal/webcontent. We will soon switch this over to spawning a new process for each connection. Since this feature is very immature, we'll be bringing it up inside of Demos/WebView as a separate demo program. Eventually this will become a reusable widget that anyone can embed and easily get out-of-process web content in their GUI. This is pretty, pretty cool! :^)
2020-06-17 17:31:42 +02:00
{
}
LibWeb: Defer the handling of WebContent process crashes Handling crashes synchronously is finicky since we're modifying the m_client_state struct while in a callback lambda owned by it. Let's avoid all the footguns here by simply using deferred_invoke() and handling the crash on next event loop iteration instead.
2021-02-22 11:07:40 +01:00
void OutOfProcessWebView::handle_web_content_process_crash()
{
create_client();
Everywhere: Rename ASSERT => VERIFY (...and ASSERT_NOT_REACHED => VERIFY_NOT_REACHED) Since all of these checks are done in release builds as well, let's rename them to VERIFY to prevent confusion, as everyone is used to assertions being compiled out in release. We can introduce a new ASSERT macro that is specifically for debug checks, but I'm doing this wholesale conversion first since we've accumulated thousands of these already, and it's not immediately obvious which ones are suitable for ASSERT.
2021-02-23 20:42:32 +01:00
VERIFY(m_client_state.client);
LibWeb: Defer the handling of WebContent process crashes Handling crashes synchronously is finicky since we're modifying the m_client_state struct while in a callback lambda owned by it. Let's avoid all the footguns here by simply using deferred_invoke() and handling the crash on next event loop iteration instead.
2021-02-22 11:07:40 +01:00
// Don't keep a stale backup bitmap around.
m_backup_bitmap = nullptr;
handle_resize();
StringBuilder builder;
builder.append("<html><head><title>Crashed: ");
builder.append(escape_html_entities(m_url.to_string()));
builder.append("</title></head><body>");
builder.append("<h1>Web page crashed");
if (!m_url.host().is_empty()) {
builder.appendff(" on {}", escape_html_entities(m_url.host()));
}
builder.append("</h1>");
builder.appendff("The web page <a href=\"{}\">{}</a> has crashed.<br><br>You can reload the page to try again.", escape_html_entities(m_url.to_string_encoded()), escape_html_entities(m_url.to_string()));
builder.append("</body></html>");
load_html(builder.to_string(), m_url);
}
LibWeb: Handle WebContent process crashes gracefully :^) The OOPWV will now detect WebContent process crashes/disconnections and simply create a new WebContent process in its place. We also generate a little error page with a link to the crashing URL so you can reload and try again. This a huge step forward for OOPWV since it now has a feature that IPWV can never replicate. :^)
2021-01-30 18:20:40 +01:00
void OutOfProcessWebView::create_client()
{
m_client_state = {};
m_client_state.client = WebContentClient::construct(*this);
m_client_state.client->on_web_content_process_crash = [this] {
LibWeb: Defer the handling of WebContent process crashes Handling crashes synchronously is finicky since we're modifying the m_client_state struct while in a callback lambda owned by it. Let's avoid all the footguns here by simply using deferred_invoke() and handling the crash on next event loop iteration instead.
2021-02-22 11:07:40 +01:00
deferred_invoke([this] {
handle_web_content_process_crash();
});
LibWeb: Handle WebContent process crashes gracefully :^) The OOPWV will now detect WebContent process crashes/disconnections and simply create a new WebContent process in its place. We also generate a little error page with a link to the crashing URL so you can reload and try again. This a huge step forward for OOPWV since it now has a feature that IPWV can never replicate. :^)
2021-01-30 18:20:40 +01:00
};
client().post_message(Messages::WebContentServer::UpdateSystemTheme(Gfx::current_system_theme_buffer()));
LibWeb+WebContent: Keep track of screen rect It is now possible to get the up-to-date screen rect from a Web::Page.
2021-04-04 00:12:37 +02:00
client().post_message(Messages::WebContentServer::UpdateScreenRect(GUI::Desktop::the().rect()));
LibWeb: Handle WebContent process crashes gracefully :^) The OOPWV will now detect WebContent process crashes/disconnections and simply create a new WebContent process in its place. We also generate a little error page with a link to the crashing URL so you can reload and try again. This a huge step forward for OOPWV since it now has a feature that IPWV can never replicate. :^)
2021-01-30 18:20:40 +01:00
}
LibWeb: Rename WebContentView => OutOfProcessWebView
2020-08-17 16:20:47 +02:00
void OutOfProcessWebView::load(const URL& url)
WebContent: Start work on browser process separation :^) The "WebContent" service provides a very restricted instance of LibWeb running as an unprivileged user account. This will be used to implement process separation in Browser, among other things. This first cut of the service only spawns a single WebContent process when someone connects to /tmp/portal/webcontent. We will soon switch this over to spawning a new process for each connection. Since this feature is very immature, we'll be bringing it up inside of Demos/WebView as a separate demo program. Eventually this will become a reusable widget that anyone can embed and easily get out-of-process web content in their GUI. This is pretty, pretty cool! :^)
2020-06-17 17:31:42 +02:00
{
Browser+LibWeb: Pave the way for using WebContentView in Browser This commit sets everything up, but we still always instantiate a plain Web::PageView in Browser::Tab..
2020-07-06 21:46:37 +02:00
m_url = url;
WebContent: Start work on browser process separation :^) The "WebContent" service provides a very restricted instance of LibWeb running as an unprivileged user account. This will be used to implement process separation in Browser, among other things. This first cut of the service only spawns a single WebContent process when someone connects to /tmp/portal/webcontent. We will soon switch this over to spawning a new process for each connection. Since this feature is very immature, we'll be bringing it up inside of Demos/WebView as a separate demo program. Eventually this will become a reusable widget that anyone can embed and easily get out-of-process web content in their GUI. This is pretty, pretty cool! :^)
2020-06-17 17:31:42 +02:00
client().post_message(Messages::WebContentServer::LoadURL(url));
}
LibWeb: Add OutOfProcessWebView::load_html()
2020-10-08 21:11:01 +01:00
void OutOfProcessWebView::load_html(const StringView& html, const URL& url)
{
m_url = url;
client().post_message(Messages::WebContentServer::LoadHTML(html, url));
}
LibWeb: Add OutOfProcessWebView::load_empty_document() This is cheating a little bit as we don't set the document to a nullptr as in InProcessWebView, but the observable outcome is the same. :^)
2020-10-08 21:58:00 +01:00
void OutOfProcessWebView::load_empty_document()
{
m_url = {};
client().post_message(Messages::WebContentServer::LoadHTML("", {}));
}
LibWeb: Rename WebContentView => OutOfProcessWebView
2020-08-17 16:20:47 +02:00
void OutOfProcessWebView::paint_event(GUI::PaintEvent& event)
WebContent: Start work on browser process separation :^) The "WebContent" service provides a very restricted instance of LibWeb running as an unprivileged user account. This will be used to implement process separation in Browser, among other things. This first cut of the service only spawns a single WebContent process when someone connects to /tmp/portal/webcontent. We will soon switch this over to spawning a new process for each connection. Since this feature is very immature, we'll be bringing it up inside of Demos/WebView as a separate demo program. Eventually this will become a reusable widget that anyone can embed and easily get out-of-process web content in their GUI. This is pretty, pretty cool! :^)
2020-06-17 17:31:42 +02:00
{
WebContent: Use available size for bitmap (#2701) After adding the scrolling feature, content available space reduced and thus the bitmap size was always larger, than the inner size. This lead to the horizontal scrollbar always beeing engaged.
2020-07-05 12:45:56 +02:00
GUI::ScrollableWidget::paint_event(event);
WebContent: Give the WebContentView a proper GUI::Frame look :^)
2020-07-04 23:27:36 +02:00
LibWeb: Don't attempt to create new bitmap for zero-size OOPWV It's not possible to construct a Gfx::Bitmap with empty size. Let the client know the new viewport rect and return before even attempting to create new front and back bitmaps. Also consider that we might have to paint the widget but not have a front/back bitmap available (e.g. when only part of a scrollbar is visible, and the inner rect is empty).
2020-11-08 15:07:57 +00:00
// If the available size is empty, we don't have a front or back bitmap to draw.
if (available_size().is_empty())
return;
WebContent: Start work on browser process separation :^) The "WebContent" service provides a very restricted instance of LibWeb running as an unprivileged user account. This will be used to implement process separation in Browser, among other things. This first cut of the service only spawns a single WebContent process when someone connects to /tmp/portal/webcontent. We will soon switch this over to spawning a new process for each connection. Since this feature is very immature, we'll be bringing it up inside of Demos/WebView as a separate demo program. Eventually this will become a reusable widget that anyone can embed and easily get out-of-process web content in their GUI. This is pretty, pretty cool! :^)
2020-06-17 17:31:42 +02:00
GUI::Painter painter(*this);
painter.add_clip_rect(event.rect());
LibWeb: Fill OOPWV with the palette base color until we have pixels We were painting unfinished pixels while waiting for the WebContent process to render the page. This caused OOPWV to flicker black sometimes, which looked pretty bad. This way we still flicker, but at least we flicker with the correct palette color. :^)
2020-12-29 00:44:58 +01:00
LibWeb: Make OOPWV resizing flicker-free :^) When resizing, keep a copy of the last good bitmap we have, and keep using that until we receive a new one from the WebContent process.
2021-02-09 22:07:36 +01:00
if (auto* bitmap = m_client_state.has_usable_bitmap ? m_client_state.front_bitmap.ptr() : m_backup_bitmap.ptr()) {
painter.add_clip_rect(frame_inner_rect());
painter.translate(frame_thickness(), frame_thickness());
painter.blit({ 0, 0 }, *bitmap, bitmap->rect());
LibWeb: Fill OOPWV with the palette base color until we have pixels We were painting unfinished pixels while waiting for the WebContent process to render the page. This caused OOPWV to flicker black sometimes, which looked pretty bad. This way we still flicker, but at least we flicker with the correct palette color. :^)
2020-12-29 00:44:58 +01:00
return;
}
LibWeb: Make OOPWV resizing flicker-free :^) When resizing, keep a copy of the last good bitmap we have, and keep using that until we receive a new one from the WebContent process.
2021-02-09 22:07:36 +01:00
painter.fill_rect(frame_inner_rect(), palette().base());
WebContent: Start work on browser process separation :^) The "WebContent" service provides a very restricted instance of LibWeb running as an unprivileged user account. This will be used to implement process separation in Browser, among other things. This first cut of the service only spawns a single WebContent process when someone connects to /tmp/portal/webcontent. We will soon switch this over to spawning a new process for each connection. Since this feature is very immature, we'll be bringing it up inside of Demos/WebView as a separate demo program. Eventually this will become a reusable widget that anyone can embed and easily get out-of-process web content in their GUI. This is pretty, pretty cool! :^)
2020-06-17 17:31:42 +02:00
}
LibWeb: Rename WebContentView => OutOfProcessWebView
2020-08-17 16:20:47 +02:00
void OutOfProcessWebView::resize_event(GUI::ResizeEvent& event)
WebContent: Start work on browser process separation :^) The "WebContent" service provides a very restricted instance of LibWeb running as an unprivileged user account. This will be used to implement process separation in Browser, among other things. This first cut of the service only spawns a single WebContent process when someone connects to /tmp/portal/webcontent. We will soon switch this over to spawning a new process for each connection. Since this feature is very immature, we'll be bringing it up inside of Demos/WebView as a separate demo program. Eventually this will become a reusable widget that anyone can embed and easily get out-of-process web content in their GUI. This is pretty, pretty cool! :^)
2020-06-17 17:31:42 +02:00
{
WebContent: Use available size for bitmap (#2701) After adding the scrolling feature, content available space reduced and thus the bitmap size was always larger, than the inner size. This lead to the horizontal scrollbar always beeing engaged.
2020-07-05 12:45:56 +02:00
GUI::ScrollableWidget::resize_event(event);
LibWeb: Handle WebContent process crashes gracefully :^) The OOPWV will now detect WebContent process crashes/disconnections and simply create a new WebContent process in its place. We also generate a little error page with a link to the crashing URL so you can reload and try again. This a huge step forward for OOPWV since it now has a feature that IPWV can never replicate. :^)
2021-01-30 18:20:40 +01:00
handle_resize();
}
WebContent: Use available size for bitmap (#2701) After adding the scrolling feature, content available space reduced and thus the bitmap size was always larger, than the inner size. This lead to the horizontal scrollbar always beeing engaged.
2020-07-05 12:45:56 +02:00
LibWeb: Handle WebContent process crashes gracefully :^) The OOPWV will now detect WebContent process crashes/disconnections and simply create a new WebContent process in its place. We also generate a little error page with a link to the crashing URL so you can reload and try again. This a huge step forward for OOPWV since it now has a feature that IPWV can never replicate. :^)
2021-01-30 18:20:40 +01:00
void OutOfProcessWebView::handle_resize()
{
LibWeb: Don't attempt to create new bitmap for zero-size OOPWV It's not possible to construct a Gfx::Bitmap with empty size. Let the client know the new viewport rect and return before even attempting to create new front and back bitmaps. Also consider that we might have to paint the widget but not have a front/back bitmap available (e.g. when only part of a scrollbar is visible, and the inner rect is empty).
2020-11-08 15:07:57 +00:00
client().post_message(Messages::WebContentServer::SetViewportRect(Gfx::IntRect({ horizontal_scrollbar().value(), vertical_scrollbar().value() }, available_size())));
LibWeb: Make OOPWV resizing flicker-free :^) When resizing, keep a copy of the last good bitmap we have, and keep using that until we receive a new one from the WebContent process.
2021-02-09 22:07:36 +01:00
if (m_client_state.has_usable_bitmap) {
// NOTE: We keep the outgoing front bitmap as a backup so we have something to paint until we get a new one.
m_backup_bitmap = m_client_state.front_bitmap;
}
LibWeb: Handle WebContent process crashes gracefully :^) The OOPWV will now detect WebContent process crashes/disconnections and simply create a new WebContent process in its place. We also generate a little error page with a link to the crashing URL so you can reload and try again. This a huge step forward for OOPWV since it now has a feature that IPWV can never replicate. :^)
2021-01-30 18:20:40 +01:00
if (m_client_state.front_bitmap) {
m_client_state.front_bitmap = nullptr;
client().post_message(Messages::WebContentServer::RemoveBackingStore(m_client_state.front_bitmap_id));
LibWeb+WebContent: Use anonymous files for OOPWV backing stores To support this, the GUI process and the WebContent service will now coordinate their backing store bitmaps. Each backing store can be referred to by a serial ID, and we don't need to keep resending it as a file descriptor. We should probably do something similar in WindowServer. :^)
2021-01-16 23:15:32 +01:00
}
LibWeb: Handle WebContent process crashes gracefully :^) The OOPWV will now detect WebContent process crashes/disconnections and simply create a new WebContent process in its place. We also generate a little error page with a link to the crashing URL so you can reload and try again. This a huge step forward for OOPWV since it now has a feature that IPWV can never replicate. :^)
2021-01-30 18:20:40 +01:00
if (m_client_state.back_bitmap) {
m_client_state.back_bitmap = nullptr;
client().post_message(Messages::WebContentServer::RemoveBackingStore(m_client_state.back_bitmap_id));
LibWeb+WebContent: Use anonymous files for OOPWV backing stores To support this, the GUI process and the WebContent service will now coordinate their backing store bitmaps. Each backing store can be referred to by a serial ID, and we don't need to keep resending it as a file descriptor. We should probably do something similar in WindowServer. :^)
2021-01-16 23:15:32 +01:00
}
LibWeb: Handle WebContent process crashes gracefully :^) The OOPWV will now detect WebContent process crashes/disconnections and simply create a new WebContent process in its place. We also generate a little error page with a link to the crashing URL so you can reload and try again. This a huge step forward for OOPWV since it now has a feature that IPWV can never replicate. :^)
2021-01-30 18:20:40 +01:00
m_client_state.front_bitmap_id = -1;
m_client_state.back_bitmap_id = -1;
m_client_state.has_usable_bitmap = false;
LibWeb: Don't assume backing store allocation succeeds on OOPWV resize Backing store allocation can fail if the requested size is too small, or too large. We should not crash when this happens. Fixes #3986.
2020-11-08 14:53:36 +01:00
LibWeb: Don't attempt to create new bitmap for zero-size OOPWV It's not possible to construct a Gfx::Bitmap with empty size. Let the client know the new viewport rect and return before even attempting to create new front and back bitmaps. Also consider that we might have to paint the widget but not have a front/back bitmap available (e.g. when only part of a scrollbar is visible, and the inner rect is empty).
2020-11-08 15:07:57 +00:00
if (available_size().is_empty())
return;
LibGfx: Rename 32-bit BitmapFormats to BGRA8888 and BGRx888x The previous names (RGBA32 and RGB32) were misleading since that's not the actual byte order in memory. The new names reflect exactly how the color values get laid out in bitmap data.
2021-03-16 11:48:42 +01:00
if (auto new_bitmap = Gfx::Bitmap::create_shareable(Gfx::BitmapFormat::BGRx8888, available_size())) {
LibWeb: Handle WebContent process crashes gracefully :^) The OOPWV will now detect WebContent process crashes/disconnections and simply create a new WebContent process in its place. We also generate a little error page with a link to the crashing URL so you can reload and try again. This a huge step forward for OOPWV since it now has a feature that IPWV can never replicate. :^)
2021-01-30 18:20:40 +01:00
m_client_state.front_bitmap = move(new_bitmap);
m_client_state.front_bitmap_id = m_client_state.next_bitmap_id++;
client().post_message(Messages::WebContentServer::AddBackingStore(m_client_state.front_bitmap_id, m_client_state.front_bitmap->to_shareable_bitmap()));
LibWeb: Don't assume backing store allocation succeeds on OOPWV resize Backing store allocation can fail if the requested size is too small, or too large. We should not crash when this happens. Fixes #3986.
2020-11-08 14:53:36 +01:00
}
LibGfx: Rename 32-bit BitmapFormats to BGRA8888 and BGRx888x The previous names (RGBA32 and RGB32) were misleading since that's not the actual byte order in memory. The new names reflect exactly how the color values get laid out in bitmap data.
2021-03-16 11:48:42 +01:00
if (auto new_bitmap = Gfx::Bitmap::create_shareable(Gfx::BitmapFormat::BGRx8888, available_size())) {
LibWeb: Handle WebContent process crashes gracefully :^) The OOPWV will now detect WebContent process crashes/disconnections and simply create a new WebContent process in its place. We also generate a little error page with a link to the crashing URL so you can reload and try again. This a huge step forward for OOPWV since it now has a feature that IPWV can never replicate. :^)
2021-01-30 18:20:40 +01:00
m_client_state.back_bitmap = move(new_bitmap);
m_client_state.back_bitmap_id = m_client_state.next_bitmap_id++;
client().post_message(Messages::WebContentServer::AddBackingStore(m_client_state.back_bitmap_id, m_client_state.back_bitmap->to_shareable_bitmap()));
LibWeb: Don't assume backing store allocation succeeds on OOPWV resize Backing store allocation can fail if the requested size is too small, or too large. We should not crash when this happens. Fixes #3986.
2020-11-08 14:53:36 +01:00
}
WebContent: Add double buffering to the WebContentView This removes the remaining flicker in the WebContentView widget and makes it feel pretty good to use it. :^) The increase in memory use is something we'll have to address in the future with more sophisticated solutions like tiling, etc.
2020-07-05 16:31:50 +02:00
WebContent: Basic scrolling support! :^) The WebContentView widget now inherits from GUI::ScrollableWidget and will pass its scroll offset over to the WebContent process as it's changing. This is not super efficient and can get a bit laggy, but it will do fine as an initial scrolling implementation. Just like the single-process Web::PageView widget, WebContentView also paints scrolled content by translating the Gfx::Painter.
2020-07-04 23:19:32 +02:00
request_repaint();
WebContent: Start work on browser process separation :^) The "WebContent" service provides a very restricted instance of LibWeb running as an unprivileged user account. This will be used to implement process separation in Browser, among other things. This first cut of the service only spawns a single WebContent process when someone connects to /tmp/portal/webcontent. We will soon switch this over to spawning a new process for each connection. Since this feature is very immature, we'll be bringing it up inside of Demos/WebView as a separate demo program. Eventually this will become a reusable widget that anyone can embed and easily get out-of-process web content in their GUI. This is pretty, pretty cool! :^)
2020-06-17 17:31:42 +02:00
}
LibWeb: Rename WebContentView => OutOfProcessWebView
2020-08-17 16:20:47 +02:00
void OutOfProcessWebView::keydown_event(GUI::KeyEvent& event)
LibWeb: Send key events to the WebContent process This makes contenteditable work in multi-process mode. :^)
2020-08-03 19:58:59 +02:00
{
client().post_message(Messages::WebContentServer::KeyDown(event.key(), event.modifiers(), event.code_point()));
}
LibWeb: Rename WebContentView => OutOfProcessWebView
2020-08-17 16:20:47 +02:00
void OutOfProcessWebView::mousedown_event(GUI::MouseEvent& event)
WebContent: Pass mouse events through to the WebContent process Just send the incoming mouse events across to the other side and let LibWeb deal with them. :^)
2020-06-17 18:05:08 +02:00
{
WebContent: Translate mouse event coordinates into content space The WebContentView widget now passes content space coordinates along with the various mouse events. :^)
2020-07-04 23:23:36 +02:00
client().post_message(Messages::WebContentServer::MouseDown(to_content_position(event.position()), event.button(), event.buttons(), event.modifiers()));
WebContent: Pass mouse events through to the WebContent process Just send the incoming mouse events across to the other side and let LibWeb deal with them. :^)
2020-06-17 18:05:08 +02:00
}
LibWeb: Rename WebContentView => OutOfProcessWebView
2020-08-17 16:20:47 +02:00
void OutOfProcessWebView::mouseup_event(GUI::MouseEvent& event)
WebContent: Pass mouse events through to the WebContent process Just send the incoming mouse events across to the other side and let LibWeb deal with them. :^)
2020-06-17 18:05:08 +02:00
{
WebContent: Translate mouse event coordinates into content space The WebContentView widget now passes content space coordinates along with the various mouse events. :^)
2020-07-04 23:23:36 +02:00
client().post_message(Messages::WebContentServer::MouseUp(to_content_position(event.position()), event.button(), event.buttons(), event.modifiers()));
WebContent: Pass mouse events through to the WebContent process Just send the incoming mouse events across to the other side and let LibWeb deal with them. :^)
2020-06-17 18:05:08 +02:00
}
LibWeb: Rename WebContentView => OutOfProcessWebView
2020-08-17 16:20:47 +02:00
void OutOfProcessWebView::mousemove_event(GUI::MouseEvent& event)
WebContent: Pass mouse events through to the WebContent process Just send the incoming mouse events across to the other side and let LibWeb deal with them. :^)
2020-06-17 18:05:08 +02:00
{
WebContent: Translate mouse event coordinates into content space The WebContentView widget now passes content space coordinates along with the various mouse events. :^)
2020-07-04 23:23:36 +02:00
client().post_message(Messages::WebContentServer::MouseMove(to_content_position(event.position()), event.button(), event.buttons(), event.modifiers()));
WebContent: Pass mouse events through to the WebContent process Just send the incoming mouse events across to the other side and let LibWeb deal with them. :^)
2020-06-17 18:05:08 +02:00
}
LibWeb: Plumb wheel events from widget layer to EventHandler
2021-02-22 19:45:41 +01:00
void OutOfProcessWebView::mousewheel_event(GUI::MouseEvent& event)
{
client().post_message(Messages::WebContentServer::MouseWheel(to_content_position(event.position()), event.button(), event.buttons(), event.modifiers(), event.wheel_delta()));
}
LibWeb: Handle theme change event in OutOfProcessWebView
2020-10-08 22:13:54 +01:00
void OutOfProcessWebView::theme_change_event(GUI::ThemeChangeEvent& event)
{
GUI::ScrollableWidget::theme_change_event(event);
WindowServer+LibGUI: Pass the system theme using Core::AnonymousBuffer This was the last remaining user of shbufs in WindowServer, and so WindowServer no longer pledges "shared_buffer" :^)
2021-01-16 17:20:53 +01:00
client().post_message(Messages::WebContentServer::UpdateSystemTheme(Gfx::current_system_theme_buffer()));
LibWeb: Handle theme change event in OutOfProcessWebView
2020-10-08 22:13:54 +01:00
request_repaint();
}
LibWeb+WebContent: Keep track of screen rect It is now possible to get the up-to-date screen rect from a Web::Page.
2021-04-04 00:12:37 +02:00
void OutOfProcessWebView::screen_rect_change_event(GUI::ScreenRectChangeEvent& event)
{
client().post_message(Messages::WebContentServer::UpdateScreenRect(event.rect()));
}
LibWeb+WebContent: Use anonymous files for OOPWV backing stores To support this, the GUI process and the WebContent service will now coordinate their backing store bitmaps. Each backing store can be referred to by a serial ID, and we don't need to keep resending it as a file descriptor. We should probably do something similar in WindowServer. :^)
2021-01-16 23:15:32 +01:00
void OutOfProcessWebView::notify_server_did_paint(Badge<WebContentClient>, i32 bitmap_id)
WebContent: Start work on browser process separation :^) The "WebContent" service provides a very restricted instance of LibWeb running as an unprivileged user account. This will be used to implement process separation in Browser, among other things. This first cut of the service only spawns a single WebContent process when someone connects to /tmp/portal/webcontent. We will soon switch this over to spawning a new process for each connection. Since this feature is very immature, we'll be bringing it up inside of Demos/WebView as a separate demo program. Eventually this will become a reusable widget that anyone can embed and easily get out-of-process web content in their GUI. This is pretty, pretty cool! :^)
2020-06-17 17:31:42 +02:00
{
LibWeb: Handle WebContent process crashes gracefully :^) The OOPWV will now detect WebContent process crashes/disconnections and simply create a new WebContent process in its place. We also generate a little error page with a link to the crashing URL so you can reload and try again. This a huge step forward for OOPWV since it now has a feature that IPWV can never replicate. :^)
2021-01-30 18:20:40 +01:00
if (m_client_state.back_bitmap_id == bitmap_id) {
m_client_state.has_usable_bitmap = true;
swap(m_client_state.back_bitmap, m_client_state.front_bitmap);
swap(m_client_state.back_bitmap_id, m_client_state.front_bitmap_id);
LibWeb: Make OOPWV resizing flicker-free :^) When resizing, keep a copy of the last good bitmap we have, and keep using that until we receive a new one from the WebContent process.
2021-02-09 22:07:36 +01:00
// We don't need the backup bitmap anymore, so drop it.
m_backup_bitmap = nullptr;
WebContent: Start work on browser process separation :^) The "WebContent" service provides a very restricted instance of LibWeb running as an unprivileged user account. This will be used to implement process separation in Browser, among other things. This first cut of the service only spawns a single WebContent process when someone connects to /tmp/portal/webcontent. We will soon switch this over to spawning a new process for each connection. Since this feature is very immature, we'll be bringing it up inside of Demos/WebView as a separate demo program. Eventually this will become a reusable widget that anyone can embed and easily get out-of-process web content in their GUI. This is pretty, pretty cool! :^)
2020-06-17 17:31:42 +02:00
update();
WebContent: Add double buffering to the WebContentView This removes the remaining flicker in the WebContentView widget and makes it feel pretty good to use it. :^) The increase in memory use is something we'll have to address in the future with more sophisticated solutions like tiling, etc.
2020-07-05 16:31:50 +02:00
}
WebContent: Start work on browser process separation :^) The "WebContent" service provides a very restricted instance of LibWeb running as an unprivileged user account. This will be used to implement process separation in Browser, among other things. This first cut of the service only spawns a single WebContent process when someone connects to /tmp/portal/webcontent. We will soon switch this over to spawning a new process for each connection. Since this feature is very immature, we'll be bringing it up inside of Demos/WebView as a separate demo program. Eventually this will become a reusable widget that anyone can embed and easily get out-of-process web content in their GUI. This is pretty, pretty cool! :^)
2020-06-17 17:31:42 +02:00
}
LibWeb: Rename WebContentView => OutOfProcessWebView
2020-08-17 16:20:47 +02:00
void OutOfProcessWebView::notify_server_did_invalidate_content_rect(Badge<WebContentClient>, [[maybe_unused]] const Gfx::IntRect& content_rect)
WebContent: Allow the WebContent process to trigger repaints After layout, we may want to repaint the page, so we now listen for the PageClient::page_did_invalidate() notification and use it to drive a client-side repaint. Note that an invalidation request from LibWeb makes a full roundtrip to the WebContent client and back since the client drives painting.
2020-06-17 18:00:18 +02:00
{
WebContent: Notify client when web content selection changes The WebContentView widgets reacts to this by requesting a repaint.
2020-07-04 20:57:57 +02:00
request_repaint();
}
LibWeb: Rename WebContentView => OutOfProcessWebView
2020-08-17 16:20:47 +02:00
void OutOfProcessWebView::notify_server_did_change_selection(Badge<WebContentClient>)
WebContent: Notify client when web content selection changes The WebContentView widgets reacts to this by requesting a repaint.
2020-07-04 20:57:57 +02:00
{
request_repaint();
}
LibWeb: Support setting the cursor in OutOfProcessWebView
2021-02-27 21:12:12 +00:00
void OutOfProcessWebView::notify_server_did_request_cursor_change(Badge<WebContentClient>, Gfx::StandardCursor cursor)
{
set_override_cursor(cursor);
}
LibWeb: Rename WebContentView => OutOfProcessWebView
2020-08-17 16:20:47 +02:00
void OutOfProcessWebView::notify_server_did_layout(Badge<WebContentClient>, const Gfx::IntSize& content_size)
WebContent: Basic scrolling support! :^) The WebContentView widget now inherits from GUI::ScrollableWidget and will pass its scroll offset over to the WebContent process as it's changing. This is not super efficient and can get a bit laggy, but it will do fine as an initial scrolling implementation. Just like the single-process Web::PageView widget, WebContentView also paints scrolled content by translating the Gfx::Painter.
2020-07-04 23:19:32 +02:00
{
set_content_size(content_size);
}
LibWeb: Rename WebContentView => OutOfProcessWebView
2020-08-17 16:20:47 +02:00
void OutOfProcessWebView::notify_server_did_change_title(Badge<WebContentClient>, const String& title)
WebContent: Plumb title changes over to the WebContentView WebContentView now fires its on_title_change hook, like Web::PageView. We use this in the WebView test app to update the window title. :^)
2020-07-04 23:40:17 +02:00
{
if (on_title_change)
on_title_change(title);
}
LibWeb: Handle scrolling an OutOfProcessWebView When a mousewheel scroll event isn't handled by the web content itself (e.g. an overflowed box or similar), the event needs to get passed back up to the OutOfProcessWebView.
2021-03-02 08:39:07 +11:00
void OutOfProcessWebView::notify_server_did_request_scroll(Badge<WebContentClient>, int wheel_delta)
{
vertical_scrollbar().set_value(vertical_scrollbar().value() + wheel_delta * 20);
}
LibWeb: Rename WebContentView => OutOfProcessWebView
2020-08-17 16:20:47 +02:00
void OutOfProcessWebView::notify_server_did_request_scroll_into_view(Badge<WebContentClient>, const Gfx::IntRect& rect)
WebContent: Plumb scroll-into-view requests from server to client The WebContentView widget will now be able to react to scroll-into-view requests from the WebContent process.
2020-07-05 15:43:43 +02:00
{
scroll_into_view(rect, true, true);
}
LibWeb+WebContent: Support displaying tooltips in OOPWV
2021-03-30 12:10:06 -04:00
void OutOfProcessWebView::notify_server_did_enter_tooltip_area(Badge<WebContentClient>, const Gfx::IntPoint&, const String& title)
{
GUI::Application::the()->show_tooltip(title, nullptr);
}
void OutOfProcessWebView::notify_server_did_leave_tooltip_area(Badge<WebContentClient>)
{
GUI::Application::the()->hide_tooltip();
}
LibWeb: Rename WebContentView => OutOfProcessWebView
2020-08-17 16:20:47 +02:00
void OutOfProcessWebView::notify_server_did_hover_link(Badge<WebContentClient>, const URL& url)
WebContent: Plumb hovered links from WebContent process over to widget Also add a little GUI::StatusBar to the demo app so we can see the hovered link URL's live. :^)
2020-07-05 16:59:20 +02:00
{
if (on_link_hover)
on_link_hover(url);
}
LibWeb: Rename WebContentView => OutOfProcessWebView
2020-08-17 16:20:47 +02:00
void OutOfProcessWebView::notify_server_did_unhover_link(Badge<WebContentClient>)
WebContent: Plumb hovered links from WebContent process over to widget Also add a little GUI::StatusBar to the demo app so we can see the hovered link URL's live. :^)
2020-07-05 16:59:20 +02:00
{
LibWeb: Use widget override cursors
2020-09-11 14:28:05 +02:00
set_override_cursor(Gfx::StandardCursor::None);
WebContent: Plumb hovered links from WebContent process over to widget Also add a little GUI::StatusBar to the demo app so we can see the hovered link URL's live. :^)
2020-07-05 16:59:20 +02:00
if (on_link_hover)
on_link_hover({});
}
LibWeb: Rename WebContentView => OutOfProcessWebView
2020-08-17 16:20:47 +02:00
void OutOfProcessWebView::notify_server_did_click_link(Badge<WebContentClient>, const URL& url, const String& target, unsigned int modifiers)
WebContent: Plumb link clicks to the WebContentView :^) You can now react to links being clicked via the on_link_click hook.
2020-07-06 20:01:46 +02:00
{
if (on_link_click)
on_link_click(url, target, modifiers);
}
LibWeb: Rename WebContentView => OutOfProcessWebView
2020-08-17 16:20:47 +02:00
void OutOfProcessWebView::notify_server_did_middle_click_link(Badge<WebContentClient>, const URL& url, const String& target, unsigned int modifiers)
WebContent: Plumb link clicks to the WebContentView :^) You can now react to links being clicked via the on_link_click hook.
2020-07-06 20:01:46 +02:00
{
if (on_link_middle_click)
on_link_middle_click(url, target, modifiers);
}
LibWeb: Rename WebContentView => OutOfProcessWebView
2020-08-17 16:20:47 +02:00
void OutOfProcessWebView::notify_server_did_start_loading(Badge<WebContentClient>, const URL& url)
LibWeb: Make the WebContentView::on_load_start hook actually work :^)
2020-07-06 21:58:16 +02:00
{
if (on_load_start)
on_load_start(url);
}
LibWeb+WebContent: Add on_load_finish hook to web views This isn't entirely symmetrical with on_load_start as it will also fire on reloads and back/forward navigations. However, it's good enough for some basic use cases, and we can do more sophisticated notifications later on when we need them.
2020-12-08 21:44:42 +01:00
void OutOfProcessWebView::notify_server_did_finish_loading(Badge<WebContentClient>, const URL& url)
{
if (on_load_finish)
on_load_finish(url);
}
LibWeb: Rename WebContentView => OutOfProcessWebView
2020-08-17 16:20:47 +02:00
void OutOfProcessWebView::notify_server_did_request_context_menu(Badge<WebContentClient>, const Gfx::IntPoint& content_position)
LibWeb: Make context menus work in WebContentView As usual, this was just a matter of plumbing the PageClient calls from the WebContent side over to the WebContentView side. :^)
2020-07-07 12:24:29 +02:00
{
if (on_context_menu_request)
on_context_menu_request(screen_relative_rect().location().translated(to_widget_position(content_position)));
}
LibWeb: Rename WebContentView => OutOfProcessWebView
2020-08-17 16:20:47 +02:00
void OutOfProcessWebView::notify_server_did_request_link_context_menu(Badge<WebContentClient>, const Gfx::IntPoint& content_position, const URL& url, const String&, unsigned)
LibWeb: Make context menus work in WebContentView As usual, this was just a matter of plumbing the PageClient calls from the WebContent side over to the WebContentView side. :^)
2020-07-07 12:24:29 +02:00
{
if (on_link_context_menu_request)
on_link_context_menu_request(url, screen_relative_rect().location().translated(to_widget_position(content_position)));
}
LibWeb: Support window.alert() in multi-process context Alerts are now delegated to the embedding GUI process.
2020-09-12 11:56:13 +02:00
void OutOfProcessWebView::notify_server_did_request_alert(Badge<WebContentClient>, const String& message)
{
GUI::MessageBox::show(window(), message, "Alert", GUI::MessageBox::Type::Information);
}
LibWeb+WebContent: Support window.confirm() in OOPWV
2021-02-10 08:48:28 +01:00
bool OutOfProcessWebView::notify_server_did_request_confirm(Badge<WebContentClient>, const String& message)
{
auto confirm_result = GUI::MessageBox::show(window(), message, "Confirm", GUI::MessageBox::Type::Warning, GUI::MessageBox::InputType::OKCancel);
return confirm_result == GUI::Dialog::ExecResult::ExecOK;
}
LibWeb: Implement Window.prompt()
2021-02-20 12:05:18 +01:00
String OutOfProcessWebView::notify_server_did_request_prompt(Badge<WebContentClient>, const String& message, const String& default_)
{
String response { default_ };
if (GUI::InputBox::show(window(), response, message, "Prompt") == GUI::InputBox::ExecOK)
return response;
return {};
}
LibWeb: Added get source functionality and hook event
2021-02-23 06:17:23 -06:00
void OutOfProcessWebView::notify_server_did_get_source(const URL& url, const String& source)
{
if (on_get_source)
on_get_source(url, source);
}
LibWeb: Add in all of the plumbing required to use the JS console over IPC
2021-02-27 21:47:14 -06:00
void OutOfProcessWebView::notify_server_did_js_console_output(const String& method, const String& line)
{
if (on_js_console_output)
on_js_console_output(method, line);
}
LibWeb+WebContent: Support displaying favicons in OOPWV In single process mode, the browser will display a page's favicon in both the location bar and tab. This adds the same support for multi- process mode.
2021-03-26 10:41:25 -04:00
void OutOfProcessWebView::notify_server_did_change_favicon(const Gfx::Bitmap& favicon)
{
if (on_favicon_change)
on_favicon_change(favicon);
}
LibWeb: Rename WebContentView => OutOfProcessWebView
2020-08-17 16:20:47 +02:00
void OutOfProcessWebView::did_scroll()
WebContent: Basic scrolling support! :^) The WebContentView widget now inherits from GUI::ScrollableWidget and will pass its scroll offset over to the WebContent process as it's changing. This is not super efficient and can get a bit laggy, but it will do fine as an initial scrolling implementation. Just like the single-process Web::PageView widget, WebContentView also paints scrolled content by translating the Gfx::Painter.
2020-07-04 23:19:32 +02:00
{
WebContent: Use available size for bitmap (#2701) After adding the scrolling feature, content available space reduced and thus the bitmap size was always larger, than the inner size. This lead to the horizontal scrollbar always beeing engaged.
2020-07-05 12:45:56 +02:00
client().post_message(Messages::WebContentServer::SetViewportRect(visible_content_rect()));
WebContent: Basic scrolling support! :^) The WebContentView widget now inherits from GUI::ScrollableWidget and will pass its scroll offset over to the WebContent process as it's changing. This is not super efficient and can get a bit laggy, but it will do fine as an initial scrolling implementation. Just like the single-process Web::PageView widget, WebContentView also paints scrolled content by translating the Gfx::Painter.
2020-07-04 23:19:32 +02:00
request_repaint();
}
LibWeb: Rename WebContentView => OutOfProcessWebView
2020-08-17 16:20:47 +02:00
void OutOfProcessWebView::request_repaint()
WebContent: Notify client when web content selection changes The WebContentView widgets reacts to this by requesting a repaint.
2020-07-04 20:57:57 +02:00
{
LibWeb: Don't send OOPWV repaint requests for views without backing This fixes an assertion in TextEditor when changing the system theme, since that would trigger a repaint request for the HTML preview widget which may not have backing unless it's actually been used to perform HTML (or Markdown) preview yet.
2020-10-24 12:28:38 +02:00
// If this widget was instantiated but not yet added to a window,
// it won't have a back bitmap yet, so we can just skip repaint requests.
LibWeb: Handle WebContent process crashes gracefully :^) The OOPWV will now detect WebContent process crashes/disconnections and simply create a new WebContent process in its place. We also generate a little error page with a link to the crashing URL so you can reload and try again. This a huge step forward for OOPWV since it now has a feature that IPWV can never replicate. :^)
2021-01-30 18:20:40 +01:00
if (!m_client_state.back_bitmap)
LibWeb: Don't send OOPWV repaint requests for views without backing This fixes an assertion in TextEditor when changing the system theme, since that would trigger a repaint request for the HTML preview widget which may not have backing unless it's actually been used to perform HTML (or Markdown) preview yet.
2020-10-24 12:28:38 +02:00
return;
LibWeb: Handle WebContent process crashes gracefully :^) The OOPWV will now detect WebContent process crashes/disconnections and simply create a new WebContent process in its place. We also generate a little error page with a link to the crashing URL so you can reload and try again. This a huge step forward for OOPWV since it now has a feature that IPWV can never replicate. :^)
2021-01-30 18:20:40 +01:00
client().post_message(Messages::WebContentServer::Paint(m_client_state.back_bitmap->rect().translated(horizontal_scrollbar().value(), vertical_scrollbar().value()), m_client_state.back_bitmap_id));
WebContent: Allow the WebContent process to trigger repaints After layout, we may want to repaint the page, so we now listen for the PageClient::page_did_invalidate() notification and use it to drive a client-side repaint. Note that an invalidation request from LibWeb makes a full roundtrip to the WebContent client and back since the client drives painting.
2020-06-17 18:00:18 +02:00
}
LibWeb: Rename WebContentView => OutOfProcessWebView
2020-08-17 16:20:47 +02:00
WebContentClient& OutOfProcessWebView::client()
WebContent: Start work on browser process separation :^) The "WebContent" service provides a very restricted instance of LibWeb running as an unprivileged user account. This will be used to implement process separation in Browser, among other things. This first cut of the service only spawns a single WebContent process when someone connects to /tmp/portal/webcontent. We will soon switch this over to spawning a new process for each connection. Since this feature is very immature, we'll be bringing it up inside of Demos/WebView as a separate demo program. Eventually this will become a reusable widget that anyone can embed and easily get out-of-process web content in their GUI. This is pretty, pretty cool! :^)
2020-06-17 17:31:42 +02:00
{
Everywhere: Rename ASSERT => VERIFY (...and ASSERT_NOT_REACHED => VERIFY_NOT_REACHED) Since all of these checks are done in release builds as well, let's rename them to VERIFY to prevent confusion, as everyone is used to assertions being compiled out in release. We can introduce a new ASSERT macro that is specifically for debug checks, but I'm doing this wholesale conversion first since we've accumulated thousands of these already, and it's not immediately obvious which ones are suitable for ASSERT.
2021-02-23 20:42:32 +01:00
VERIFY(m_client_state.client);
LibWeb: Handle WebContent process crashes gracefully :^) The OOPWV will now detect WebContent process crashes/disconnections and simply create a new WebContent process in its place. We also generate a little error page with a link to the crashing URL so you can reload and try again. This a huge step forward for OOPWV since it now has a feature that IPWV can never replicate. :^)
2021-01-30 18:20:40 +01:00
return *m_client_state.client;
WebContent: Start work on browser process separation :^) The "WebContent" service provides a very restricted instance of LibWeb running as an unprivileged user account. This will be used to implement process separation in Browser, among other things. This first cut of the service only spawns a single WebContent process when someone connects to /tmp/portal/webcontent. We will soon switch this over to spawning a new process for each connection. Since this feature is very immature, we'll be bringing it up inside of Demos/WebView as a separate demo program. Eventually this will become a reusable widget that anyone can embed and easily get out-of-process web content in their GUI. This is pretty, pretty cool! :^)
2020-06-17 17:31:42 +02:00
}
LibWeb: Move OutOfProcessWebView into the Web namespace
2020-08-24 15:33:18 +04:30
Browser+LibWeb+WebContent: Make the "Debug" menu work in multi-process This patch adds an IPC call for debugging requests. It's stringly typed and very simple, and allows us to easily implement all the features in the Browser's Debug menu.
2021-01-31 09:06:25 +01:00
void OutOfProcessWebView::debug_request(const String& request, const String& argument)
{
client().post_message(Messages::WebContentServer::DebugRequest(request, argument));
}
LibWeb: Added get source functionality and hook event
2021-02-23 06:17:23 -06:00
void OutOfProcessWebView::get_source()
{
client().post_message(Messages::WebContentServer::GetSource());
}
LibWeb: Add in all of the plumbing required to use the JS console over IPC
2021-02-27 21:47:14 -06:00
void OutOfProcessWebView::js_console_initialize()
{
client().post_message(Messages::WebContentServer::JSConsoleInitialize());
}
void OutOfProcessWebView::js_console_input(const String& js_source)
{
client().post_message(Messages::WebContentServer::JSConsoleInput(js_source));
}
LibWeb: Move OutOfProcessWebView into the Web namespace
2020-08-24 15:33:18 +04:30
}
Reference in a new issue Copy permalink