Stowage/ladybird
2
0
Fork 0
mirror of https://github.com/LadybirdBrowser/ladybird.git synced 2025-11-09 17:51:03 +00:00
Code Issues Projects Releases Packages Wiki Activity
ladybird/Userland/Libraries/LibWeb/Loader/FrameLoader.cpp

482 lines
19 KiB
C++
Raw Normal View History

LibWeb: Add a FrameLoader class and move PageView's loading logic there Each Frame now has a FrameLoader which will be responsible for handling loading inside that frame.
2020-06-06 13:02:44 +02:00
/*
LibWeb: Start implementing "create and initialize a Document" from HTML The way we've been creating DOM::Document has been pretty far from what the spec tells us to do, and this is a first big step towards getting us closer to spec. The new Document::create_and_initialize() is called by FrameLoader after loading a "text/html" resource. We create the JS Realm and the Window object when creating the Document (previously, we'd do it on first access to Document::interpreter().) The realm execution context is owned by the Environment Settings Object.
2022-08-04 21:30:33 +02:00
* Copyright (c) 2020-2022, Andreas Kling <kling@serenityos.org>
LibWeb: Add a FrameLoader class and move PageView's loading logic there Each Frame now has a FrameLoader which will be responsible for handling loading inside that frame.
2020-06-06 13:02:44 +02:00
*
Everything: Move to SPDX license identifiers in all files. SPDX License Identifiers are a more compact / standardized way of representing file license information. See: https://spdx.dev/resources/use/#identifiers This was done with the `ambr` search and replace tool. ambr --no-parent-ignore --key-from-file --rep-from-file key.txt rep.txt *
2021-04-22 01:24:48 -07:00
* SPDX-License-Identifier: BSD-2-Clause
LibWeb: Add a FrameLoader class and move PageView's loading logic there Each Frame now has a FrameLoader which will be responsible for handling loading inside that frame.
2020-06-06 13:02:44 +02:00
*/
Everywhere: Replace a bundle of dbg with dbgln. These changes are arbitrarily divided into multiple commits to make it easier to find potentially introduced bugs with git bisect.
2021-01-17 18:17:00 +01:00
#include <AK/Debug.h>
LibWeb+LibHTTP: Support multiple Set-Cookie response headers
2021-08-11 06:09:35 +08:00
#include <AK/JsonArray.h>
LibWeb: Add a FrameLoader class and move PageView's loading logic there Each Frame now has a FrameLoader which will be responsible for handling loading inside that frame.
2020-06-06 13:02:44 +02:00
#include <AK/LexicalPath.h>
LibWeb+Base: Use AK::SourceGenerator for error pages Instead of storing a format string in a file, let's be reasonable and use SourceGenerator's template functionality. :^)
2021-04-22 00:00:06 +02:00
#include <AK/SourceGenerator.h>
LibWeb: Add a FrameLoader class and move PageView's loading logic there Each Frame now has a FrameLoader which will be responsible for handling loading inside that frame.
2020-06-06 13:02:44 +02:00
#include <LibGemini/Document.h>
LibGfx: Move all image loaders and writers to a subdirectory
2023-03-21 14:58:06 -04:00
#include <LibGfx/ImageFormats/ImageDecoder.h>
LibWeb: Add a FrameLoader class and move PageView's loading logic there Each Frame now has a FrameLoader which will be responsible for handling loading inside that frame.
2020-06-06 13:02:44 +02:00
#include <LibMarkdown/Document.h>
LibWeb: Run XML parser input through encoding decoder Fixes the issue that XML parser fails when loader passes input that is prefixed with byte order mark. Also it generally makes sense to pass text source through encoding decoder before parsing. Probably we would even want to introduce method similar to `create_with_uncertain_encoding` in `HTMLParser` but for `XMLParser` to be make harder unconsciously pass non-UTF8 input to XML parser.
2023-03-26 02:51:55 +03:00
#include <LibTextCodec/Decoder.h>
LibWeb: Make Fetch::Infrastructure::{Request,Response,HeaderList} GC'd This is the way. On a more serious note, there's no reason to keep adding ref-counted classes to LibWeb now that the majority of classes is GC'd - it only adds the risk of discovering some cycle down the line, and forces us to use handles as we can't visit().
2022-10-30 01:52:07 +00:00
#include <LibWeb/Bindings/MainThreadVM.h>
LibWeb+Browser: Remove old HTML parser :^) The new parser is now used everywhere and it's working pretty well!
2020-06-25 23:50:35 +02:00
#include <LibWeb/DOM/Document.h>
LibWeb: Add a FrameLoader class and move PageView's loading logic there Each Frame now has a FrameLoader which will be responsible for handling loading inside that frame.
2020-06-06 13:02:44 +02:00
#include <LibWeb/DOM/ElementFactory.h>
#include <LibWeb/DOM/Text.h>
LibWeb: Move BrowsingContext into HTML/ Browsing contexts are defined by the HTML specification, so let's move them into the HTML directory. :^)
2021-11-18 15:01:28 +01:00
#include <LibWeb/HTML/BrowsingContext.h>
LibWeb: Dispatch DOM "load" event on <iframe> elements
2020-09-22 17:53:40 +02:00
#include <LibWeb/HTML/HTMLIFrameElement.h>
LibWeb: Start implementing "create and initialize a Document" from HTML The way we've been creating DOM::Document has been pretty far from what the spec tells us to do, and this is a first big step towards getting us closer to spec. The new Document::create_and_initialize() is called by FrameLoader after loading a "text/html" resource. We create the JS Realm and the Window object when creating the Document (previously, we'd do it on first access to Document::interpreter().) The realm execution context is owned by the Environment Settings Object.
2022-08-04 21:30:33 +02:00
#include <LibWeb/HTML/NavigationParams.h>
LibWeb: Run XML parser input through encoding decoder Fixes the issue that XML parser fails when loader passes input that is prefixed with byte order mark. Also it generally makes sense to pass text source through encoding decoder before parsing. Probably we would even want to introduce method similar to `create_with_uncertain_encoding` in `HTMLParser` but for `XMLParser` to be make harder unconsciously pass non-UTF8 input to XML parser.
2023-03-26 02:51:55 +03:00
#include <LibWeb/HTML/Parser/HTMLEncodingDetection.h>
LibWeb: Rename HTMLDocumentParser => HTMLParser
2021-09-25 23:15:48 +02:00
#include <LibWeb/HTML/Parser/HTMLParser.h>
LibWeb: Add a FrameLoader class and move PageView's loading logic there Each Frame now has a FrameLoader which will be responsible for handling loading inside that frame.
2020-06-06 13:02:44 +02:00
#include <LibWeb/Loader/FrameLoader.h>
#include <LibWeb/Loader/ResourceLoader.h>
LibWeb: Introduce CustomElementRegistry and creating custom elements The main missing feature here is form associated custom elements.
2023-03-29 23:46:18 +01:00
#include <LibWeb/Namespace.h>
LibWeb: Move the Page/Frame/EventHandler classes into Page/
2020-07-28 19:27:41 +02:00
#include <LibWeb/Page/Page.h>
LibWeb+LibWebView+WebContent: Add Web::Platform::ImageCodecPlugin This replaces the previous Web::ImageDecoding::Decoder interface. While we're doing this, also move the SerenityOS implementation of this interface from LibWebView to WebContent. That means we no longer have to link with LibImageDecoderClient in applications that use a web view.
2022-09-16 15:01:47 +02:00
#include <LibWeb/Platform/ImageCodecPlugin.h>
LibWeb: Load X(HT)ML documents and transform them into HTML DOM
2022-03-28 16:25:17 +04:30
#include <LibWeb/XML/XMLDocumentBuilder.h>
LibWeb: Add a FrameLoader class and move PageView's loading logic there Each Frame now has a FrameLoader which will be responsible for handling loading inside that frame.
2020-06-06 13:02:44 +02:00
namespace Web {
AK+Everywhere: Rename String to DeprecatedString We have a new, improved string type coming up in AK (OOM aware, no null state), and while it's going to use UTF-8, the name UTF8String is a mouthful - so let's free up the String name by renaming the existing class. Making the old one have an annoying name will hopefully also help with quick adoption :^)
2022-12-04 18:02:33 +00:00
static DeprecatedString s_default_favicon_path = "/res/icons/16x16/app-browser.png";
Browser+LibWeb: Make sure the default favicon is loaded Previously in Browser, when we navigate back from a page that has an icon to a page that does not have an icon, the icon does not update and the old icon is displayed because FrameLoader does not set the default favicon when the favicon cannot be loaded. This patch ensures that Browser receives a new icon bitmap every time a load takes place.
2021-08-07 04:28:22 +08:00
static RefPtr<Gfx::Bitmap> s_default_favicon_bitmap;
AK+Everywhere: Rename String to DeprecatedString We have a new, improved string type coming up in AK (OOM aware, no null state), and while it's going to use UTF-8, the name UTF8String is a mouthful - so let's free up the String name by renaming the existing class. Making the old one have an annoying name will hopefully also help with quick adoption :^)
2022-12-04 18:02:33 +00:00
void FrameLoader::set_default_favicon_path(DeprecatedString path)
LibWeb: Allow configuring the default favicon path This is useful when using LibWeb in environments that aren't Serenity
2022-04-03 16:36:28 +02:00
{
s_default_favicon_path = move(path);
}
LibWeb: Move BrowsingContext into HTML/ Browsing contexts are defined by the HTML specification, so let's move them into the HTML directory. :^)
2021-11-18 15:01:28 +01:00
FrameLoader::FrameLoader(HTML::BrowsingContext& browsing_context)
LibWeb: Rename Web::Frame to Web::BrowsingContext Our "frame" concept very closely matches what the web specs call a "browsing context", so let's rename it to that. :^) The "main frame" becomes the "top-level browsing context", and "sub-frames" are now "nested browsing contexts".
2021-05-30 12:36:53 +02:00
: m_browsing_context(browsing_context)
LibWeb: Add a FrameLoader class and move PageView's loading logic there Each Frame now has a FrameLoader which will be responsible for handling loading inside that frame.
2020-06-06 13:02:44 +02:00
{
Browser+LibWeb: Make sure the default favicon is loaded Previously in Browser, when we navigate back from a page that has an icon to a page that does not have an icon, the icon does not update and the old icon is displayed because FrameLoader does not set the default favicon when the favicon cannot be loaded. This patch ensures that Browser receives a new icon bitmap every time a load takes place.
2021-08-07 04:28:22 +08:00
if (!s_default_favicon_bitmap) {
LibGfx: Remove `try_` prefix from bitmap creation functions Those don't have any non-try counterpart, so we might as well just omit it.
2023-01-20 20:06:05 +01:00
s_default_favicon_bitmap = Gfx::Bitmap::load_from_file(s_default_favicon_path).release_value_but_fixme_should_propagate_errors();
Browser+LibWeb: Make sure the default favicon is loaded Previously in Browser, when we navigate back from a page that has an icon to a page that does not have an icon, the icon does not update and the old icon is displayed because FrameLoader does not set the default favicon when the favicon cannot be loaded. This patch ensures that Browser receives a new icon bitmap every time a load takes place.
2021-08-07 04:28:22 +08:00
VERIFY(s_default_favicon_bitmap);
}
LibWeb: Add a FrameLoader class and move PageView's loading logic there Each Frame now has a FrameLoader which will be responsible for handling loading inside that frame.
2020-06-06 13:02:44 +02:00
}
Libraries: Use default constructors/destructors in LibWeb https://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines#cother-other-default-operation-rules "The compiler is more likely to get the default semantics right and you cannot implement these functions better than the compiler."
2022-03-14 13:21:51 -06:00
FrameLoader::~FrameLoader() = default;
LibWeb: Add a FrameLoader class and move PageView's loading logic there Each Frame now has a FrameLoader which will be responsible for handling loading inside that frame.
2020-06-06 13:02:44 +02:00
Everywhere: Run clang-format
2022-04-01 20:58:27 +03:00
static bool build_markdown_document(DOM::Document& document, ByteBuffer const& data)
LibWeb: Add a FrameLoader class and move PageView's loading logic there Each Frame now has a FrameLoader which will be responsible for handling loading inside that frame.
2020-06-06 13:02:44 +02:00
{
auto markdown_document = Markdown::Document::parse(data);
if (!markdown_document)
LibWeb: Attach DOM::Document to its frame before parsing FrameLoader now begins by constructing a DOM::Document, and then builds a document tree inside it based on the MIME type. For text/html we pass control to the HTMLDocumentParser as before. This gives us access to things like window.alert() during parsing. Fixes #3973.
2020-12-13 17:38:03 +01:00
return false;
LibWeb: Add a FrameLoader class and move PageView's loading logic there Each Frame now has a FrameLoader which will be responsible for handling loading inside that frame.
2020-06-06 13:02:44 +02:00
LibWeb: Make Markdown images shrink-to-fit by default This inserts some CSS and JS to make images in Markdown documents which are wider than the viewport, become shrink-to-fit. Clicking on these toggles them between shrink-to-fit and full size. Anyone who displays Markdown documents using LibWeb gets this functionality for free! That's Browser, Help, and Welcome's README display.
2022-09-27 11:36:43 +01:00
auto extra_head_contents = R"~~~(
<style>
.zoomable {
cursor: zoom-in;
max-width: 100%;
}
.zoomable.zoomed-in {
cursor: zoom-out;
max-width: none;
}
</style>
<script>
function imageClickEventListener(event) {
let image = event.target;
if (image.classList.contains("zoomable")) {
image.classList.toggle("zoomed-in");
}
}
function processImages() {
let images = document.querySelectorAll("img");
let windowWidth = window.innerWidth;
images.forEach((image) => {
if (image.naturalWidth > windowWidth) {
image.classList.add("zoomable");
} else {
image.classList.remove("zoomable");
image.classList.remove("zoomed-in");
}
image.addEventListener("click", imageClickEventListener);
});
}
document.addEventListener("load", () => {
processImages();
});
window.addEventListener("resize", () => {
processImages();
});
</script>
)~~~"sv;
auto parser = HTML::HTMLParser::create(document, markdown_document->render_to_html(extra_head_contents), "utf-8");
LibWeb: Make document.write() work while document is parsing This necessitated making HTMLParser ref-counted, and having it register itself with Document when created. That makes it possible for scripts to add new input at the current parser insertion point. There is now a reference cycle between Document and HTMLParser. This cycle is explicitly broken by calling Document::detach_parser() at the end of HTMLParser::run(). This is a huge progression on ACID3, from 31% to 49%! :^)
2022-02-21 21:54:21 +01:00
parser->run(document.url());
LibWeb: Attach DOM::Document to its frame before parsing FrameLoader now begins by constructing a DOM::Document, and then builds a document tree inside it based on the MIME type. For text/html we pass control to the HTMLDocumentParser as before. This gives us access to things like window.alert() during parsing. Fixes #3973.
2020-12-13 17:38:03 +01:00
return true;
LibWeb: Add a FrameLoader class and move PageView's loading logic there Each Frame now has a FrameLoader which will be responsible for handling loading inside that frame.
2020-06-06 13:02:44 +02:00
}
Everywhere: Run clang-format
2022-04-01 20:58:27 +03:00
static bool build_text_document(DOM::Document& document, ByteBuffer const& data)
LibWeb: Add a FrameLoader class and move PageView's loading logic there Each Frame now has a FrameLoader which will be responsible for handling loading inside that frame.
2020-06-06 13:02:44 +02:00
{
LibWeb: Introduce CustomElementRegistry and creating custom elements The main missing feature here is form associated custom elements.
2023-03-29 23:46:18 +01:00
auto html_element = DOM::create_element(document, HTML::TagNames::html, Namespace::HTML).release_value_but_fixme_should_propagate_errors();
LibWeb: Handle currently ignored `WebIDL::ExceptionOr<T>`s
2022-10-30 17:50:04 +00:00
MUST(document.append_child(html_element));
LibWeb: Add a FrameLoader class and move PageView's loading logic there Each Frame now has a FrameLoader which will be responsible for handling loading inside that frame.
2020-06-06 13:02:44 +02:00
LibWeb: Introduce CustomElementRegistry and creating custom elements The main missing feature here is form associated custom elements.
2023-03-29 23:46:18 +01:00
auto head_element = DOM::create_element(document, HTML::TagNames::head, Namespace::HTML).release_value_but_fixme_should_propagate_errors();
LibWeb: Handle currently ignored `WebIDL::ExceptionOr<T>`s
2022-10-30 17:50:04 +00:00
MUST(html_element->append_child(head_element));
LibWeb: Introduce CustomElementRegistry and creating custom elements The main missing feature here is form associated custom elements.
2023-03-29 23:46:18 +01:00
auto title_element = DOM::create_element(document, HTML::TagNames::title, Namespace::HTML).release_value_but_fixme_should_propagate_errors();
LibWeb: Handle currently ignored `WebIDL::ExceptionOr<T>`s
2022-10-30 17:50:04 +00:00
MUST(head_element->append_child(title_element));
LibWeb: Add a FrameLoader class and move PageView's loading logic there Each Frame now has a FrameLoader which will be responsible for handling loading inside that frame.
2020-06-06 13:02:44 +02:00
LibWeb: Attach DOM::Document to its frame before parsing FrameLoader now begins by constructing a DOM::Document, and then builds a document tree inside it based on the MIME type. For text/html we pass control to the HTMLDocumentParser as before. This gives us access to things like window.alert() during parsing. Fixes #3973.
2020-12-13 17:38:03 +01:00
auto title_text = document.create_text_node(document.url().basename());
LibWeb: Handle currently ignored `WebIDL::ExceptionOr<T>`s
2022-10-30 17:50:04 +00:00
MUST(title_element->append_child(title_text));
LibWeb: Add a FrameLoader class and move PageView's loading logic there Each Frame now has a FrameLoader which will be responsible for handling loading inside that frame.
2020-06-06 13:02:44 +02:00
LibWeb: Introduce CustomElementRegistry and creating custom elements The main missing feature here is form associated custom elements.
2023-03-29 23:46:18 +01:00
auto body_element = DOM::create_element(document, HTML::TagNames::body, Namespace::HTML).release_value_but_fixme_should_propagate_errors();
LibWeb: Handle currently ignored `WebIDL::ExceptionOr<T>`s
2022-10-30 17:50:04 +00:00
MUST(html_element->append_child(body_element));
LibWeb: Add a FrameLoader class and move PageView's loading logic there Each Frame now has a FrameLoader which will be responsible for handling loading inside that frame.
2020-06-06 13:02:44 +02:00
LibWeb: Introduce CustomElementRegistry and creating custom elements The main missing feature here is form associated custom elements.
2023-03-29 23:46:18 +01:00
auto pre_element = DOM::create_element(document, HTML::TagNames::pre, Namespace::HTML).release_value_but_fixme_should_propagate_errors();
LibWeb: Handle currently ignored `WebIDL::ExceptionOr<T>`s
2022-10-30 17:50:04 +00:00
MUST(body_element->append_child(pre_element));
LibWeb: Add a FrameLoader class and move PageView's loading logic there Each Frame now has a FrameLoader which will be responsible for handling loading inside that frame.
2020-06-06 13:02:44 +02:00
AK+Everywhere: Rename String to DeprecatedString We have a new, improved string type coming up in AK (OOM aware, no null state), and while it's going to use UTF-8, the name UTF8String is a mouthful - so let's free up the String name by renaming the existing class. Making the old one have an annoying name will hopefully also help with quick adoption :^)
2022-12-04 18:02:33 +00:00
MUST(pre_element->append_child(document.create_text_node(DeprecatedString::copy(data))));
LibWeb: Attach DOM::Document to its frame before parsing FrameLoader now begins by constructing a DOM::Document, and then builds a document tree inside it based on the MIME type. For text/html we pass control to the HTMLDocumentParser as before. This gives us access to things like window.alert() during parsing. Fixes #3973.
2020-12-13 17:38:03 +01:00
return true;
LibWeb: Add a FrameLoader class and move PageView's loading logic there Each Frame now has a FrameLoader which will be responsible for handling loading inside that frame.
2020-06-06 13:02:44 +02:00
}
LibWeb: Use the sandboxed ImageDecoder when creating image documents An image document is the synthetic DOM::Document we create to wrap an image when you open the URL of an image directly in a web view. The path that creates these documents will now also call out to the separate ImageDecoder process for the actual decoding work.
2021-11-20 10:56:36 +01:00
static bool build_image_document(DOM::Document& document, ByteBuffer const& data)
LibWeb: Add a FrameLoader class and move PageView's loading logic there Each Frame now has a FrameLoader which will be responsible for handling loading inside that frame.
2020-06-06 13:02:44 +02:00
{
LibWeb+LibWebView+WebContent: Add Web::Platform::ImageCodecPlugin This replaces the previous Web::ImageDecoding::Decoder interface. While we're doing this, also move the SerenityOS implementation of this interface from LibWebView to WebContent. That means we no longer have to link with LibImageDecoderClient in applications that use a web view.
2022-09-16 15:01:47 +02:00
auto image = Platform::ImageCodecPlugin::the().decode_image(data);
LibWeb: Use the sandboxed ImageDecoder when creating image documents An image document is the synthetic DOM::Document we create to wrap an image when you open the URL of an image directly in a web view. The path that creates these documents will now also call out to the separate ImageDecoder process for the actual decoding work.
2021-11-20 10:56:36 +01:00
if (!image.has_value() || image->frames.is_empty())
LibGfx: Improve ImageDecoder construction Previously, ImageDecoder::create() would return a NonnullRefPtr and could not "fail", although the returned decoder may be "invalid" which you then had to check anyway. The new interface looks like this: static RefPtr<Gfx::ImageDecoder> try_create(ReadonlyBytes); This simplifies ImageDecoder since it no longer has to worry about its validity. Client code gets slightly clearer as well.
2021-07-27 01:12:53 +02:00
return false;
LibWeb: Use the sandboxed ImageDecoder when creating image documents An image document is the synthetic DOM::Document we create to wrap an image when you open the URL of an image directly in a web view. The path that creates these documents will now also call out to the separate ImageDecoder process for the actual decoding work.
2021-11-20 10:56:36 +01:00
auto const& frame = image->frames[0];
auto const& bitmap = frame.bitmap;
LibWeb: Attach DOM::Document to its frame before parsing FrameLoader now begins by constructing a DOM::Document, and then builds a document tree inside it based on the MIME type. For text/html we pass control to the HTMLDocumentParser as before. This gives us access to things like window.alert() during parsing. Fixes #3973.
2020-12-13 17:38:03 +01:00
if (!bitmap)
return false;
LibWeb: Add a FrameLoader class and move PageView's loading logic there Each Frame now has a FrameLoader which will be responsible for handling loading inside that frame.
2020-06-06 13:02:44 +02:00
LibWeb: Introduce CustomElementRegistry and creating custom elements The main missing feature here is form associated custom elements.
2023-03-29 23:46:18 +01:00
auto html_element = DOM::create_element(document, HTML::TagNames::html, Namespace::HTML).release_value_but_fixme_should_propagate_errors();
LibWeb: Handle currently ignored `WebIDL::ExceptionOr<T>`s
2022-10-30 17:50:04 +00:00
MUST(document.append_child(html_element));
LibWeb: Add a FrameLoader class and move PageView's loading logic there Each Frame now has a FrameLoader which will be responsible for handling loading inside that frame.
2020-06-06 13:02:44 +02:00
LibWeb: Introduce CustomElementRegistry and creating custom elements The main missing feature here is form associated custom elements.
2023-03-29 23:46:18 +01:00
auto head_element = DOM::create_element(document, HTML::TagNames::head, Namespace::HTML).release_value_but_fixme_should_propagate_errors();
LibWeb: Handle currently ignored `WebIDL::ExceptionOr<T>`s
2022-10-30 17:50:04 +00:00
MUST(html_element->append_child(head_element));
LibWeb: Introduce CustomElementRegistry and creating custom elements The main missing feature here is form associated custom elements.
2023-03-29 23:46:18 +01:00
auto title_element = DOM::create_element(document, HTML::TagNames::title, Namespace::HTML).release_value_but_fixme_should_propagate_errors();
LibWeb: Handle currently ignored `WebIDL::ExceptionOr<T>`s
2022-10-30 17:50:04 +00:00
MUST(head_element->append_child(title_element));
LibWeb: Add a FrameLoader class and move PageView's loading logic there Each Frame now has a FrameLoader which will be responsible for handling loading inside that frame.
2020-06-06 13:02:44 +02:00
AK+Everywhere: Add and use static APIs for LexicalPath The LexicalPath instance methods dirname(), basename(), title() and extension() will be changed to return StringView const& in a further commit. Due to this, users creating temporary LexicalPath objects just to call one of those getters will recieve a StringView const& pointing to a possible freed buffer. To avoid this, static methods for those APIs have been added, which will return a String by value to avoid those problems. All cases where temporary LexicalPath objects have been used as described above haven been changed to use the static APIs.
2021-06-29 16:46:16 +02:00
auto basename = LexicalPath::basename(document.url().path());
LibJS+Everywhere: Propagate Cell::initialize errors from Heap::allocate Callers that are already in a fallible context will now TRY to allocate cells. Callers in infallible contexts get a FIXME.
2023-01-28 13:39:44 -05:00
auto title_text = document.heap().allocate<DOM::Text>(document.realm(), document, DeprecatedString::formatted("{} [{}x{}]", basename, bitmap->width(), bitmap->height())).release_allocated_value_but_fixme_should_propagate_errors();
LibWeb: Handle currently ignored `WebIDL::ExceptionOr<T>`s
2022-10-30 17:50:04 +00:00
MUST(title_element->append_child(*title_text));
LibWeb: Add a FrameLoader class and move PageView's loading logic there Each Frame now has a FrameLoader which will be responsible for handling loading inside that frame.
2020-06-06 13:02:44 +02:00
LibWeb: Introduce CustomElementRegistry and creating custom elements The main missing feature here is form associated custom elements.
2023-03-29 23:46:18 +01:00
auto body_element = DOM::create_element(document, HTML::TagNames::body, Namespace::HTML).release_value_but_fixme_should_propagate_errors();
LibWeb: Handle currently ignored `WebIDL::ExceptionOr<T>`s
2022-10-30 17:50:04 +00:00
MUST(html_element->append_child(body_element));
LibWeb: Add a FrameLoader class and move PageView's loading logic there Each Frame now has a FrameLoader which will be responsible for handling loading inside that frame.
2020-06-06 13:02:44 +02:00
LibWeb: Introduce CustomElementRegistry and creating custom elements The main missing feature here is form associated custom elements.
2023-03-29 23:46:18 +01:00
auto image_element = DOM::create_element(document, HTML::TagNames::img, Namespace::HTML).release_value_but_fixme_should_propagate_errors();
Everywhere: Rename to_{string => deprecated_string}() where applicable This will make it easier to support both string types at the same time while we convert code, and tracking down remaining uses. One big exception is Value::to_string() in LibJS, where the name is dictated by the ToString AO.
2022-12-06 01:12:49 +00:00
MUST(image_element->set_attribute(HTML::AttributeNames::src, document.url().to_deprecated_string()));
LibWeb: Handle currently ignored `WebIDL::ExceptionOr<T>`s
2022-10-30 17:50:04 +00:00
MUST(body_element->append_child(image_element));
LibWeb: Add a FrameLoader class and move PageView's loading logic there Each Frame now has a FrameLoader which will be responsible for handling loading inside that frame.
2020-06-06 13:02:44 +02:00
LibWeb: Attach DOM::Document to its frame before parsing FrameLoader now begins by constructing a DOM::Document, and then builds a document tree inside it based on the MIME type. For text/html we pass control to the HTMLDocumentParser as before. This gives us access to things like window.alert() during parsing. Fixes #3973.
2020-12-13 17:38:03 +01:00
return true;
LibWeb: Add a FrameLoader class and move PageView's loading logic there Each Frame now has a FrameLoader which will be responsible for handling loading inside that frame.
2020-06-06 13:02:44 +02:00
}
Everywhere: Run clang-format
2022-04-01 20:58:27 +03:00
static bool build_gemini_document(DOM::Document& document, ByteBuffer const& data)
LibWeb: Add a FrameLoader class and move PageView's loading logic there Each Frame now has a FrameLoader which will be responsible for handling loading inside that frame.
2020-06-06 13:02:44 +02:00
{
LibWeb: Add debug toggle for dumping gemini documents
2020-10-06 11:08:37 -04:00
StringView gemini_data { data };
LibWeb: Attach DOM::Document to its frame before parsing FrameLoader now begins by constructing a DOM::Document, and then builds a document tree inside it based on the MIME type. For text/html we pass control to the HTMLDocumentParser as before. This gives us access to things like window.alert() during parsing. Fixes #3973.
2020-12-13 17:38:03 +01:00
auto gemini_document = Gemini::Document::parse(gemini_data, document.url());
AK+Everywhere: Rename String to DeprecatedString We have a new, improved string type coming up in AK (OOM aware, no null state), and while it's going to use UTF-8, the name UTF8String is a mouthful - so let's free up the String name by renaming the existing class. Making the old one have an annoying name will hopefully also help with quick adoption :^)
2022-12-04 18:02:33 +00:00
DeprecatedString html_data = gemini_document->render_to_html();
LibWeb: Add debug toggle for dumping gemini documents
2020-10-06 11:08:37 -04:00
Everywhere: Turn #if *_DEBUG into dbgln_if/if constexpr
2021-05-01 21:10:08 +02:00
dbgln_if(GEMINI_DEBUG, "Gemini data:\n\"\"\"{}\"\"\"", gemini_data);
dbgln_if(GEMINI_DEBUG, "Converted to HTML:\n\"\"\"{}\"\"\"", html_data);
LibWeb: Add a FrameLoader class and move PageView's loading logic there Each Frame now has a FrameLoader which will be responsible for handling loading inside that frame.
2020-06-06 13:02:44 +02:00
LibWeb: Make document.write() work while document is parsing This necessitated making HTMLParser ref-counted, and having it register itself with Document when created. That makes it possible for scripts to add new input at the current parser insertion point. There is now a reference cycle between Document and HTMLParser. This cycle is explicitly broken by calling Document::detach_parser() at the end of HTMLParser::run(). This is a huge progression on ACID3, from 31% to 49%! :^)
2022-02-21 21:54:21 +01:00
auto parser = HTML::HTMLParser::create(document, html_data, "utf-8");
parser->run(document.url());
LibWeb: Attach DOM::Document to its frame before parsing FrameLoader now begins by constructing a DOM::Document, and then builds a document tree inside it based on the MIME type. For text/html we pass control to the HTMLDocumentParser as before. This gives us access to things like window.alert() during parsing. Fixes #3973.
2020-12-13 17:38:03 +01:00
return true;
LibWeb: Add a FrameLoader class and move PageView's loading logic there Each Frame now has a FrameLoader which will be responsible for handling loading inside that frame.
2020-06-06 13:02:44 +02:00
}
Everywhere: Run clang-format
2022-04-01 20:58:27 +03:00
static bool build_xml_document(DOM::Document& document, ByteBuffer const& data)
LibWeb: Load X(HT)ML documents and transform them into HTML DOM
2022-03-28 16:25:17 +04:30
{
LibWeb: Run XML parser input through encoding decoder Fixes the issue that XML parser fails when loader passes input that is prefixed with byte order mark. Also it generally makes sense to pass text source through encoding decoder before parsing. Probably we would even want to introduce method similar to `create_with_uncertain_encoding` in `HTMLParser` but for `XMLParser` to be make harder unconsciously pass non-UTF8 input to XML parser.
2023-03-26 02:51:55 +03:00
auto encoding = HTML::run_encoding_sniffing_algorithm(document, data);
auto decoder = TextCodec::decoder_for(encoding);
VERIFY(decoder.has_value());
auto source = decoder->to_utf8(data).release_value_but_fixme_should_propagate_errors();
XML::Parser parser(source, { .resolve_external_resource = resolve_xml_resource });
LibWeb: Load X(HT)ML documents and transform them into HTML DOM
2022-03-28 16:25:17 +04:30
XMLDocumentBuilder builder { document };
auto result = parser.parse_with_listener(builder);
return !result.is_error() && !builder.has_error();
}
Everywhere: Run clang-format
2022-04-01 20:58:27 +03:00
bool FrameLoader::parse_document(DOM::Document& document, ByteBuffer const& data)
LibWeb: Add a FrameLoader class and move PageView's loading logic there Each Frame now has a FrameLoader which will be responsible for handling loading inside that frame.
2020-06-06 13:02:44 +02:00
{
LibWeb: Attach DOM::Document to its frame before parsing FrameLoader now begins by constructing a DOM::Document, and then builds a document tree inside it based on the MIME type. For text/html we pass control to the HTMLDocumentParser as before. This gives us access to things like window.alert() during parsing. Fixes #3973.
2020-12-13 17:38:03 +01:00
auto& mime_type = document.content_type();
LibWeb: make it possible to directly load .svg files Make LibWeb load svg files by guessing the svg mime type from the file extension and parsing it with the HTML parser.
2020-09-07 19:45:14 +02:00
if (mime_type == "text/html" || mime_type == "image/svg+xml") {
LibWeb: Rename HTMLDocumentParser => HTMLParser
2021-09-25 23:15:48 +02:00
auto parser = HTML::HTMLParser::create_with_uncertain_encoding(document, data);
LibWeb: Implement encoding sniffing algorithm This patch implements the HTML specification's "encoding sniffing algorithm", which is used when no encoding can be obtained from the Content-Type header (either because it doesn't contain a charset=...) value or the file has not been opened via HTTP (as with local files). It also modifies the creator of the HTMLDocumentParser to use the new HTMLDocumentParser::create_with_uncertain_encoding static method, which runs the encoding sniffing algorithm before instantiating the parser. This now allows us to load local HTML pages (or remote pages without a charset specified in the 'Content-Type' header) with a non-UTF-8 encoding such as 'windows-1252'. This would previously crash the browser. :^)
2021-05-12 10:47:12 +02:00
parser->run(document.url());
LibWeb: Attach DOM::Document to its frame before parsing FrameLoader now begins by constructing a DOM::Document, and then builds a document tree inside it based on the MIME type. For text/html we pass control to the HTMLDocumentParser as before. This gives us access to things like window.alert() during parsing. Fixes #3973.
2020-12-13 17:38:03 +01:00
return true;
LibWeb: make it possible to directly load .svg files Make LibWeb load svg files by guessing the svg mime type from the file extension and parsing it with the HTML parser.
2020-09-07 19:45:14 +02:00
}
Everywhere: Add sv suffix to strings relying on StringView(char const*) Each of these strings would previously rely on StringView's char const* constructor overload, which would call __builtin_strlen on the string. Since we now have operator ""sv, we can replace these with much simpler versions. This opens the door to being able to remove StringView(char const*). No functional changes.
2022-07-11 17:32:29 +00:00
if (mime_type.ends_with("+xml"sv) || mime_type.is_one_of("text/xml", "application/xml"))
LibWeb: Load X(HT)ML documents and transform them into HTML DOM
2022-03-28 16:25:17 +04:30
return build_xml_document(document, data);
Everywhere: Add sv suffix to strings relying on StringView(char const*) Each of these strings would previously rely on StringView's char const* constructor overload, which would call __builtin_strlen on the string. Since we now have operator ""sv, we can replace these with much simpler versions. This opens the door to being able to remove StringView(char const*). No functional changes.
2022-07-11 17:32:29 +00:00
if (mime_type.starts_with("image/"sv))
LibWeb: Attach DOM::Document to its frame before parsing FrameLoader now begins by constructing a DOM::Document, and then builds a document tree inside it based on the MIME type. For text/html we pass control to the HTMLDocumentParser as before. This gives us access to things like window.alert() during parsing. Fixes #3973.
2020-12-13 17:38:03 +01:00
return build_image_document(document, data);
LibWeb: Add support to view JSON. Extremely small change, all I did is check for application/json, mime type and parsed it as text.
2021-03-20 18:46:22 +04:00
if (mime_type == "text/plain" || mime_type == "application/json")
LibWeb: Attach DOM::Document to its frame before parsing FrameLoader now begins by constructing a DOM::Document, and then builds a document tree inside it based on the MIME type. For text/html we pass control to the HTMLDocumentParser as before. This gives us access to things like window.alert() during parsing. Fixes #3973.
2020-12-13 17:38:03 +01:00
return build_text_document(document, data);
if (mime_type == "text/markdown")
return build_markdown_document(document, data);
if (mime_type == "text/gemini")
return build_gemini_document(document, data);
return false;
LibWeb: Add a FrameLoader class and move PageView's loading logic there Each Frame now has a FrameLoader which will be responsible for handling loading inside that frame.
2020-06-06 13:02:44 +02:00
}
LibWeb: Start tracking elapsed time when a resource is loaded
2021-09-11 21:15:15 -07:00
bool FrameLoader::load(LoadRequest& request, Type type)
LibWeb: Add a FrameLoader class and move PageView's loading logic there Each Frame now has a FrameLoader which will be responsible for handling loading inside that frame.
2020-06-06 13:02:44 +02:00
{
ProtocolServer+LibWeb: Support more detailed HTTP requests This patch adds the ability for ProtocolServer clients to specify which HTTP method to use, and also to include an optional HTTP request body.
2020-09-28 11:55:26 +02:00
if (!request.is_valid()) {
load_error_page(request.url(), "Invalid request");
LibWeb: Add a FrameLoader class and move PageView's loading logic there Each Frame now has a FrameLoader which will be responsible for handling loading inside that frame.
2020-06-06 13:02:44 +02:00
return false;
}
LibJS+LibWeb: Wrap raw JS::Cell*/& fields in GCPtr/NonnullGCPtr
2023-02-26 16:09:02 -07:00
if (!m_browsing_context->is_frame_nesting_allowed(request.url())) {
LibWeb: Make frames nesting-aware and disallow deep nesting A Frame now knows about its nesting-level. The FrameLoader checks whether the recursion level of the current frame allows it to be displayed and if not doesn't even load the requested resource. The nesting-check is done on a per-URL-basis, so there can be many many nested Frames as long as they have different URLs. If there are however Frames with the same URL nested inside each other we only allow this to happen 3 times. This mitigates infinetely recursing <iframe>s in an HTML-document crashing the browser with an OOM.
2021-04-19 14:30:08 +02:00
dbgln("No further recursion is allowed for the frame, abort load!");
return false;
}
LibWeb: Don't treat erroring subresource loads as success If a subresource fails to load, we don't care that we got some custom 404 page. The subresource should still be considered failed. This is an ad-hoc solution that unbreaks Acid2. This code will eventually be replaced by fetch mechanisms.
2023-03-15 12:28:33 +01:00
request.set_main_resource(true);
ProtocolServer+LibWeb: Support more detailed HTTP requests This patch adds the ability for ProtocolServer clients to specify which HTTP method to use, and also to include an optional HTTP request body.
2020-09-28 11:55:26 +02:00
auto& url = request.url();
LibWeb+WebContent: Label redirects with new FrameLoader::Type::Redirect Previously we labeled redirects as normal FrameLoader::Type::Navigation, now we introduce a new FrameLoader::Type::Redirect and label redirects with it. This will allow us to handle redirects in the browser differently (such as for overwritting the latest history entry when a redirect happens) :^)
2022-11-10 00:29:35 +01:00
if (type == Type::Navigation || type == Type::Reload || type == Type::Redirect) {
LibWeb: Only notify PageClient about top-level browsing context loads We don't need to notify the web views that some deeply nested iframe has started loading a new URL (and we don't want it showing up in the browser location bar either!)
2022-09-25 12:28:40 +02:00
if (auto* page = browsing_context().page()) {
LibJS+LibWeb: Wrap raw JS::Cell*/& fields in GCPtr/NonnullGCPtr
2023-02-26 16:09:02 -07:00
if (&page->top_level_browsing_context() == m_browsing_context)
LibWeb+WebContent: Label redirects with new FrameLoader::Type::Redirect Previously we labeled redirects as normal FrameLoader::Type::Navigation, now we introduce a new FrameLoader::Type::Redirect and label redirects with it. This will allow us to handle redirects in the browser differently (such as for overwritting the latest history entry when a redirect happens) :^)
2022-11-10 00:29:35 +01:00
page->client().page_did_start_loading(url, type == Type::Redirect);
LibWeb: Only notify PageClient about top-level browsing context loads We don't need to notify the web views that some deeply nested iframe has started loading a new URL (and we don't want it showing up in the browser location bar either!)
2022-09-25 12:28:40 +02:00
}
LibWeb: Make Frame point weakly to Page This patch makes Page weakable and allows page-less frames to exist. Page is single-owner, and Frame is multiple-owner, so it's not sound for Frame to assume its containing Page will stick around for its own entire lifetime. Fixes #3976.
2020-11-12 18:23:05 +01:00
}
LibWeb: Add a FrameLoader class and move PageView's loading logic there Each Frame now has a FrameLoader which will be responsible for handling loading inside that frame.
2020-06-06 13:02:44 +02:00
LibWeb: Send appropriate Accept header for FrameLoader requests According to Fetch, we must send an Accept header with the value "text/html,application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8" for document, iframe and frame requests. https://fetch.spec.whatwg.org/#concept-fetch Required by uber.com.
2022-02-17 23:23:01 +00:00
// https://fetch.spec.whatwg.org/#concept-fetch
// Step 12: If request’s header list does not contain `Accept`, then:
// 1. Let value be `*/*`. (NOTE: Not necessary as we're about to override it)
// 2. A user agent should set value to the first matching statement, if any, switching on request’s destination:
// -> "document"
// -> "frame"
// -> "iframe"
// `text/html,application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8`
if (!request.headers().contains("Accept"))
request.set_header("Accept", "text/html,application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8");
LibWeb: Call page_did_start_loading() before load_resource() Otherwise we would sometimes (dependent on the load time, I believe) end up setting the document and eventually calling title change callbacks before communicating that the page started loading.
2021-05-29 01:17:36 +01:00
set_resource(ResourceLoader::the().load_resource(Resource::Type::Generic, request));
LibWeb: Load favicon.ico only for http/https URLs
2020-11-07 09:03:52 +00:00
if (type == Type::IFrame)
return true;
LibWeb: Show correct favicon when default favicon is loaded Block the replacement of the favicon by the default favicon loader when a favicon that is loaded through a link tag is already active. This way, the favicon in the link tags will be prioritized against the default favicons from `/favicon.ico` or the seranity default icon.
2022-04-03 19:56:15 +02:00
auto* document = browsing_context().active_document();
if (document && document->has_active_favicon())
return true;
AK+Everywhere: Replace "protocol" with "scheme" url helpers URL had properly named replacements for protocol(), set_protocol() and create_with_file_protocol() already. This patch removes these function and updates all call sites to use the functions named according to the specification. See https://url.spec.whatwg.org/#concept-url-scheme
2022-09-29 01:30:58 +02:00
if (url.scheme() == "http" || url.scheme() == "https") {
LibWeb: Add the Web::URL namespace and move URLEncoder to it This namespace will be used for all interfaces defined in the URL specification, like URL and URLSearchParams. This has the unfortunate side-effect of requiring us to use the fully qualified AK::URL name whenever we want to refer to the AK class, so this commit also fixes all such references.
2021-09-13 00:33:23 +03:00
AK::URL favicon_url;
AK+Everywhere: Replace "protocol" with "scheme" url helpers URL had properly named replacements for protocol(), set_protocol() and create_with_file_protocol() already. This patch removes these function and updates all call sites to use the functions named according to the specification. See https://url.spec.whatwg.org/#concept-url-scheme
2022-09-29 01:30:58 +02:00
favicon_url.set_scheme(url.scheme());
LibWeb: Add a FrameLoader class and move PageView's loading logic there Each Frame now has a FrameLoader which will be responsible for handling loading inside that frame.
2020-06-06 13:02:44 +02:00
favicon_url.set_host(url.host());
AK: Make URL::m_port an Optional<u16>, Expose raw port getter Our current way of signalling a missing port with m_port == 0 was lacking, as 0 is a valid port number in URLs.
2021-09-13 23:12:16 +03:00
favicon_url.set_port(url.port_or_default());
LibWeb: Remove usage of URL::set_path() in FrameLoader This replaces a call to URL::set_path() with URL::set_paths(), as set_path() will be deprecated and removed.
2021-05-27 21:27:51 +02:00
favicon_url.set_paths({ "favicon.ico" });
LibWeb: Add a FrameLoader class and move PageView's loading logic there Each Frame now has a FrameLoader which will be responsible for handling loading inside that frame.
2020-06-06 13:02:44 +02:00
ResourceLoader::the().load(
favicon_url,
LibWeb: Pass optional status code to ResourceLoader callbacks This is needed for XMLHttpRequest, and will certainly be useful for other things, too.
2021-04-03 15:11:36 +02:00
[this, favicon_url](auto data, auto&, auto) {
LibWeb: Show correct favicon when default favicon is loaded Block the replacement of the favicon by the default favicon loader when a favicon that is loaded through a link tag is already active. This way, the favicon in the link tags will be prioritized against the default favicons from `/favicon.ico` or the seranity default icon.
2022-04-03 19:56:15 +02:00
// Always fetch the current document
auto* document = this->browsing_context().active_document();
if (document && document->has_active_favicon())
return;
Browser+LibWeb: Silence some debug spams
2021-08-07 16:37:26 +08:00
dbgln_if(SPAM_DEBUG, "Favicon downloaded, {} bytes from {}", data.size(), favicon_url);
LibWeb: Skip decoding favicon.ico if downloaded data is empty Some sites don't have favicon.ico, so we may get 404 response. In such cases, ResourceLoader still calls success_callback. For favicon loading, we are not checking response headers or payload size. This will ultimately fail in Gfx::ImageDecoder::try_create(). So avoid unnecessary work by returning early, if data is empty.
2021-09-24 20:28:03 +05:30
if (data.is_empty())
return;
Browser+LibWeb: Make sure the default favicon is loaded Previously in Browser, when we navigate back from a page that has an icon to a page that does not have an icon, the icon does not update and the old icon is displayed because FrameLoader does not set the default favicon when the favicon cannot be loaded. This patch ensures that Browser receives a new icon bitmap every time a load takes place.
2021-08-07 04:28:22 +08:00
RefPtr<Gfx::Bitmap> favicon_bitmap;
LibWeb+LibWebView+WebContent: Add Web::Platform::ImageCodecPlugin This replaces the previous Web::ImageDecoding::Decoder interface. While we're doing this, also move the SerenityOS implementation of this interface from LibWebView to WebContent. That means we no longer have to link with LibImageDecoderClient in applications that use a web view.
2022-09-16 15:01:47 +02:00
auto decoded_image = Platform::ImageCodecPlugin::the().decode_image(data);
LibWeb: Use the sandboxed image ImageDecoder when loading favicons
2021-11-20 11:25:46 +01:00
if (!decoded_image.has_value() || decoded_image->frames.is_empty()) {
dbgln("Could not decode favicon {}", favicon_url);
Browser+LibWeb: Make sure the default favicon is loaded Previously in Browser, when we navigate back from a page that has an icon to a page that does not have an icon, the icon does not update and the old icon is displayed because FrameLoader does not set the default favicon when the favicon cannot be loaded. This patch ensures that Browser receives a new icon bitmap every time a load takes place.
2021-08-07 04:28:22 +08:00
} else {
LibWeb: Use the sandboxed image ImageDecoder when loading favicons
2021-11-20 11:25:46 +01:00
favicon_bitmap = decoded_image->frames[0].bitmap;
dbgln_if(IMAGE_DECODER_DEBUG, "Decoded favicon, {}", favicon_bitmap->size());
LibGfx: Improve ImageDecoder construction Previously, ImageDecoder::create() would return a NonnullRefPtr and could not "fail", although the returned decoder may be "invalid" which you then had to check anyway. The new interface looks like this: static RefPtr<Gfx::ImageDecoder> try_create(ReadonlyBytes); This simplifies ImageDecoder since it no longer has to worry about its validity. Client code gets slightly clearer as well.
2021-07-27 01:12:53 +02:00
}
Browser+LibWeb: Make sure the default favicon is loaded Previously in Browser, when we navigate back from a page that has an icon to a page that does not have an icon, the icon does not update and the old icon is displayed because FrameLoader does not set the default favicon when the favicon cannot be loaded. This patch ensures that Browser receives a new icon bitmap every time a load takes place.
2021-08-07 04:28:22 +08:00
load_favicon(favicon_bitmap);
},
[this](auto&, auto) {
LibWeb: Show correct favicon when default favicon is loaded Block the replacement of the favicon by the default favicon loader when a favicon that is loaded through a link tag is already active. This way, the favicon in the link tags will be prioritized against the default favicons from `/favicon.ico` or the seranity default icon.
2022-04-03 19:56:15 +02:00
// Always fetch the current document
auto* document = this->browsing_context().active_document();
if (document && document->has_active_favicon())
return;
Browser+LibWeb: Make sure the default favicon is loaded Previously in Browser, when we navigate back from a page that has an icon to a page that does not have an icon, the icon does not update and the old icon is displayed because FrameLoader does not set the default favicon when the favicon cannot be loaded. This patch ensures that Browser receives a new icon bitmap every time a load takes place.
2021-08-07 04:28:22 +08:00
load_favicon();
LibWeb: Add a FrameLoader class and move PageView's loading logic there Each Frame now has a FrameLoader which will be responsible for handling loading inside that frame.
2020-06-06 13:02:44 +02:00
});
Browser+LibWeb: Make sure the default favicon is loaded Previously in Browser, when we navigate back from a page that has an icon to a page that does not have an icon, the icon does not update and the old icon is displayed because FrameLoader does not set the default favicon when the favicon cannot be loaded. This patch ensures that Browser receives a new icon bitmap every time a load takes place.
2021-08-07 04:28:22 +08:00
} else {
load_favicon();
LibWeb: Add a FrameLoader class and move PageView's loading logic there Each Frame now has a FrameLoader which will be responsible for handling loading inside that frame.
2020-06-06 13:02:44 +02:00
}
return true;
}
LibWeb: Add the Web::URL namespace and move URLEncoder to it This namespace will be used for all interfaces defined in the URL specification, like URL and URLSearchParams. This has the unfortunate side-effect of requiring us to use the fully qualified AK::URL name whenever we want to refer to the AK class, so this commit also fixes all such references.
2021-09-13 00:33:23 +03:00
bool FrameLoader::load(const AK::URL& url, Type type)
ProtocolServer+LibWeb: Support more detailed HTTP requests This patch adds the ability for ProtocolServer clients to specify which HTTP method to use, and also to include an optional HTTP request body.
2020-09-28 11:55:26 +02:00
{
Browser+LibWeb: Silence some debug spams
2021-08-07 16:37:26 +08:00
dbgln_if(SPAM_DEBUG, "FrameLoader::load: {}", url);
ProtocolServer+LibWeb: Support more detailed HTTP requests This patch adds the ability for ProtocolServer clients to specify which HTTP method to use, and also to include an optional HTTP request body.
2020-09-28 11:55:26 +02:00
if (!url.is_valid()) {
load_error_page(url, "Invalid URL");
return false;
}
LibWeb: Rename Web::Frame to Web::BrowsingContext Our "frame" concept very closely matches what the web specs call a "browsing context", so let's rename it to that. :^) The "main frame" becomes the "top-level browsing context", and "sub-frames" are now "nested browsing contexts".
2021-05-30 12:36:53 +02:00
auto request = LoadRequest::create_for_url_on_page(url, browsing_context().page());
ProtocolServer+LibWeb: Support more detailed HTTP requests This patch adds the ability for ProtocolServer clients to specify which HTTP method to use, and also to include an optional HTTP request body.
2020-09-28 11:55:26 +02:00
return load(request, type);
}
Everywhere: Pass AK::StringView by value
2021-11-11 00:55:02 +01:00
void FrameLoader::load_html(StringView html, const AK::URL& url)
LibWeb: Add FrameLoader::load_html() This moves responsibility for parsing and loading the document from InProcessWebView to FrameLoader, so can be re-used easily.
2020-10-08 21:03:16 +01:00
{
LibWeb: Make Fetch::Infrastructure::{Request,Response,HeaderList} GC'd This is the way. On a more serious note, there's no reason to keep adding ref-counted classes to LibWeb now that the majority of classes is GC'd - it only adds the risk of discovering some cycle down the line, and forces us to use handles as we can't visit().
2022-10-30 01:52:07 +00:00
auto& vm = Bindings::main_thread_vm();
auto response = Fetch::Infrastructure::Response::create(vm);
LibWeb: Start implementing "create and initialize a Document" from HTML The way we've been creating DOM::Document has been pretty far from what the spec tells us to do, and this is a first big step towards getting us closer to spec. The new Document::create_and_initialize() is called by FrameLoader after loading a "text/html" resource. We create the JS Realm and the Window object when creating the Document (previously, we'd do it on first access to Document::interpreter().) The realm execution context is owned by the Environment Settings Object.
2022-08-04 21:30:33 +02:00
response->url_list().append(url);
HTML::NavigationParams navigation_params {
.id = {},
.request = nullptr,
LibWeb: Make Fetch::Infrastructure::{Request,Response,HeaderList} GC'd This is the way. On a more serious note, there's no reason to keep adding ref-counted classes to LibWeb now that the majority of classes is GC'd - it only adds the risk of discovering some cycle down the line, and forces us to use handles as we can't visit().
2022-10-30 01:52:07 +00:00
.response = response,
LibWeb: Start implementing "create and initialize a Document" from HTML The way we've been creating DOM::Document has been pretty far from what the spec tells us to do, and this is a first big step towards getting us closer to spec. The new Document::create_and_initialize() is called by FrameLoader after loading a "text/html" resource. We create the JS Realm and the Window object when creating the Document (previously, we'd do it on first access to Document::interpreter().) The realm execution context is owned by the Environment Settings Object.
2022-08-04 21:30:33 +02:00
.origin = HTML::Origin {},
.policy_container = HTML::PolicyContainer {},
.final_sandboxing_flag_set = HTML::SandboxingFlagSet {},
.cross_origin_opener_policy = HTML::CrossOriginOpenerPolicy {},
.coop_enforcement_result = HTML::CrossOriginOpenerPolicyEnforcementResult {},
.reserved_environment = {},
.browsing_context = browsing_context(),
};
LibWeb: Make factory methods of DOM::Document fallible
2023-02-14 21:49:02 +01:00
auto document = DOM::Document::create_and_initialize(DOM::Document::Type::HTML, "text/html", move(navigation_params)).release_value_but_fixme_should_propagate_errors();
LibWeb: Fix crash when loading a HTML string that contains an iframe The HTMLIFrameElement does not create the nested browsing context on insertion if the document does not have browsing context, which is not set unless it's the active document. Previously, in FrameLoader the document was not set as active until after parsing, which led to iframes without nested browsing contexts, and crashes. Fixes #14207
2022-10-02 17:55:31 +01:00
browsing_context().set_active_document(document);
LibWeb: Start implementing "create and initialize a Document" from HTML The way we've been creating DOM::Document has been pretty far from what the spec tells us to do, and this is a first big step towards getting us closer to spec. The new Document::create_and_initialize() is called by FrameLoader after loading a "text/html" resource. We create the JS Realm and the Window object when creating the Document (previously, we'd do it on first access to Document::interpreter().) The realm execution context is owned by the Environment Settings Object.
2022-08-04 21:30:33 +02:00
LibWeb: Make document.write() work while document is parsing This necessitated making HTMLParser ref-counted, and having it register itself with Document when created. That makes it possible for scripts to add new input at the current parser insertion point. There is now a reference cycle between Document and HTMLParser. This cycle is explicitly broken by calling Document::detach_parser() at the end of HTMLParser::run(). This is a huge progression on ACID3, from 31% to 49%! :^)
2022-02-21 21:54:21 +01:00
auto parser = HTML::HTMLParser::create(document, html, "utf-8");
parser->run(url);
LibWeb: Add FrameLoader::load_html() This moves responsibility for parsing and loading the document from InProcessWebView to FrameLoader, so can be re-used easily.
2020-10-08 21:03:16 +01:00
}
AK+Everywhere: Rename String to DeprecatedString We have a new, improved string type coming up in AK (OOM aware, no null state), and while it's going to use UTF-8, the name UTF8String is a mouthful - so let's free up the String name by renaming the existing class. Making the old one have an annoying name will hopefully also help with quick adoption :^)
2022-12-04 18:02:33 +00:00
static DeprecatedString s_error_page_url = "file:///res/html/error.html";
LibWeb: Allow configuring the default error page path
2022-04-03 18:01:10 +02:00
AK+Everywhere: Rename String to DeprecatedString We have a new, improved string type coming up in AK (OOM aware, no null state), and while it's going to use UTF-8, the name UTF8String is a mouthful - so let's free up the String name by renaming the existing class. Making the old one have an annoying name will hopefully also help with quick adoption :^)
2022-12-04 18:02:33 +00:00
void FrameLoader::set_error_page_url(DeprecatedString error_page_url)
LibWeb: Allow configuring the default error page path
2022-04-03 18:01:10 +02:00
{
s_error_page_url = error_page_url;
}
Everywhere: Fix incorrect uses of String::format and StringBuilder::appendf These changes are arbitrarily divided into multiple commits to make it easier to find potentially introduced bugs with git bisect.
2021-01-12 01:01:33 +11:00
// FIXME: Use an actual templating engine (our own one when it's built, preferably
// with a way to check these usages at compile time)
AK+Everywhere: Rename String to DeprecatedString We have a new, improved string type coming up in AK (OOM aware, no null state), and while it's going to use UTF-8, the name UTF8String is a mouthful - so let's free up the String name by renaming the existing class. Making the old one have an annoying name will hopefully also help with quick adoption :^)
2022-12-04 18:02:33 +00:00
void FrameLoader::load_error_page(const AK::URL& failed_url, DeprecatedString const& error)
LibWeb: Add a FrameLoader class and move PageView's loading logic there Each Frame now has a FrameLoader which will be responsible for handling loading inside that frame.
2020-06-06 13:02:44 +02:00
{
LibWeb: Fix `FrameLoader::load_error_page` We weren't properly creating a `LoadRequest` which resulted in `m_page` not having a value in certain situations inside `ResourceLoader::load(LoadRequest&)`
2023-01-19 01:44:37 +11:00
LoadRequest request = LoadRequest::create_for_url_on_page(s_error_page_url, browsing_context().page());
LibWeb: Add a FrameLoader class and move PageView's loading logic there Each Frame now has a FrameLoader which will be responsible for handling loading inside that frame.
2020-06-06 13:02:44 +02:00
ResourceLoader::the().load(
LibWeb: Fix `FrameLoader::load_error_page` We weren't properly creating a `LoadRequest` which resulted in `m_page` not having a value in certain situations inside `ResourceLoader::load(LoadRequest&)`
2023-01-19 01:44:37 +11:00
request,
LibWeb: Pass optional status code to ResourceLoader callbacks This is needed for XMLHttpRequest, and will certainly be useful for other things, too.
2021-04-03 15:11:36 +02:00
[this, failed_url, error](auto data, auto&, auto) {
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(!data.is_null());
LibWeb+Base: Use AK::SourceGenerator for error pages Instead of storing a format string in a file, let's be reasonable and use SourceGenerator's template functionality. :^)
2021-04-22 00:00:06 +02:00
StringBuilder builder;
SourceGenerator generator { builder };
Everywhere: Rename to_{string => deprecated_string}() where applicable This will make it easier to support both string types at the same time while we convert code, and tracking down remaining uses. One big exception is Value::to_string() in LibJS, where the name is dictated by the ToString AO.
2022-12-06 01:12:49 +00:00
generator.set("failed_url", escape_html_entities(failed_url.to_deprecated_string()));
LibWeb: Fix HTML injection on FrameLoader error page Small regression introduced by 3857148, we still have to escape HTML entities.
2021-04-22 10:17:00 +02:00
generator.set("error", escape_html_entities(error));
LibWeb+Base: Use AK::SourceGenerator for error pages Instead of storing a format string in a file, let's be reasonable and use SourceGenerator's template functionality. :^)
2021-04-22 00:00:06 +02:00
generator.append(data);
LibWeb: Fix error page icon outside of serenity
2023-01-19 01:44:25 +11:00
load_html(generator.as_string_view(), s_error_page_url);
LibWeb: Add a FrameLoader class and move PageView's loading logic there Each Frame now has a FrameLoader which will be responsible for handling loading inside that frame.
2020-06-06 13:02:44 +02:00
},
LibWeb: Pass optional status code to ResourceLoader callbacks This is needed for XMLHttpRequest, and will certainly be useful for other things, too.
2021-04-03 15:11:36 +02:00
[](auto& error, auto) {
Everywhere: Replace a bundle of dbg with dbgln. These changes are arbitrarily divided into multiple commits to make it easier to find potentially introduced bugs with git bisect.
2021-01-17 18:17:00 +01:00
dbgln("Failed to load error page: {}", error);
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_NOT_REACHED();
LibWeb: Add a FrameLoader class and move PageView's loading logic there Each Frame now has a FrameLoader which will be responsible for handling loading inside that frame.
2020-06-06 13:02:44 +02:00
});
}
Browser+LibWeb: Make sure the default favicon is loaded Previously in Browser, when we navigate back from a page that has an icon to a page that does not have an icon, the icon does not update and the old icon is displayed because FrameLoader does not set the default favicon when the favicon cannot be loaded. This patch ensures that Browser receives a new icon bitmap every time a load takes place.
2021-08-07 04:28:22 +08:00
void FrameLoader::load_favicon(RefPtr<Gfx::Bitmap> bitmap)
{
if (auto* page = browsing_context().page()) {
if (bitmap)
page->client().page_did_change_favicon(*bitmap);
LibWeb: Allow configuring the default favicon path This is useful when using LibWeb in environments that aren't Serenity
2022-04-03 16:36:28 +02:00
else if (s_default_favicon_bitmap)
Browser+LibWeb: Make sure the default favicon is loaded Previously in Browser, when we navigate back from a page that has an icon to a page that does not have an icon, the icon does not update and the old icon is displayed because FrameLoader does not set the default favicon when the favicon cannot be loaded. This patch ensures that Browser receives a new icon bitmap every time a load takes place.
2021-08-07 04:28:22 +08:00
page->client().page_did_change_favicon(*s_default_favicon_bitmap);
}
}
LibWeb: Turn FrameLoader into a ResourceClient We now use the new resource-based loader for the main resource in each Frame. This gives us access to caching and sharing. :^)
2020-06-06 13:38:08 +02:00
void FrameLoader::resource_did_load()
{
LibWeb: Bail FrameLoader's load callbacks if associated BC is discarded This prevents us setting up the document of a removed browsing context container (BCC, e.g. <iframe>), which will cause a crash if the document contains a script that inserts another BCC as this will use the stale browsing context it previously set up, even if it's reinserted. Required by Prebid.js, which does this by inserting an `<iframe>` into a `<div>` in the active document via innerHTML, then transfers it to the `<html>` element: https://github.com/prebid/Prebid.js/blob/7b7389c5abdd05626f71c3df606a93713d1b9f85/src/utils.js#L597 This is done in the spec by removing all tasks and aborting all fetches when a document is destroyed: https://html.spec.whatwg.org/multipage/document-lifecycle.html#destroy-a-document See the code comments for a simplified example.
2023-02-28 20:42:51 +00:00
// This prevents us setting up the document of a removed browsing context container (BCC, e.g. <iframe>), which will cause a crash
// if the document contains a script that inserts another BCC as this will use the stale browsing context it previously set up,
// even if it's reinserted.
// Example:
// index.html:
// ```
// <body><script>
// var i = document.createElement("iframe");
// i.src = "b.html";
// document.body.append(i);
// i.remove();
// </script>
// ```
// b.html:
// ```
// <body><script>
// var i = document.createElement("iframe");
// document.body.append(i);
// </script>
// ```
// Required by Prebid.js, which does this by inserting an <iframe> into a <div> in the active document via innerHTML,
// then transfers it to the <html> element:
// https://github.com/prebid/Prebid.js/blob/7b7389c5abdd05626f71c3df606a93713d1b9f85/src/utils.js#L597
// This is done in the spec by removing all tasks and aborting all fetches when a document is destroyed:
// https://html.spec.whatwg.org/multipage/document-lifecycle.html#destroy-a-document
if (browsing_context().has_been_discarded())
return;
LibWeb: Turn FrameLoader into a ResourceClient We now use the new resource-based loader for the main resource in each Frame. This gives us access to caching and sharing. :^)
2020-06-06 13:38:08 +02:00
auto url = resource()->url();
LibWeb: Ignore Location headers unless the response status code is 3xx As per RFC7231 the Location header field has different meanings for different response status codes: For 201 (Created) responses, the Location value refers to the primary resource created by the request. For 3xx (Redirection) responses, the Location value refers to the preferred target resource for automatically redirecting the request.
2022-02-12 15:42:48 +02:00
// For 3xx (Redirection) responses, the Location value refers to the preferred target resource for automatically redirecting the request.
auto status_code = resource()->status_code();
if (status_code.has_value() && *status_code >= 300 && *status_code <= 399) {
auto location = resource()->response_headers().get("Location");
if (location.has_value()) {
if (m_redirects_count > maximum_redirects_allowed) {
m_redirects_count = 0;
load_error_page(url, "Too many redirects");
return;
}
m_redirects_count++;
LibWeb+WebContent: Label redirects with new FrameLoader::Type::Redirect Previously we labeled redirects as normal FrameLoader::Type::Navigation, now we introduce a new FrameLoader::Type::Redirect and label redirects with it. This will allow us to handle redirects in the browser differently (such as for overwritting the latest history entry when a redirect happens) :^)
2022-11-10 00:29:35 +01:00
load(url.complete_url(location.value()), Type::Redirect);
LibWeb: Add a maximum redirects limit to FrameLoader This prevents the browser from crashing when trying to load an infinite redirects loop. The chosen limit is based on the fetch specification: "If request's redirect count is twenty, return a network error."
2021-05-11 22:22:56 +03:00
return;
}
LibWeb: Turn FrameLoader into a ResourceClient We now use the new resource-based loader for the main resource in each Frame. This gives us access to caching and sharing. :^)
2020-06-06 13:38:08 +02:00
}
LibWeb: Add a maximum redirects limit to FrameLoader This prevents the browser from crashing when trying to load an infinite redirects loop. The chosen limit is based on the fetch specification: "If request's redirect count is twenty, return a network error."
2021-05-11 22:22:56 +03:00
m_redirects_count = 0;
LibWeb: Turn FrameLoader into a ResourceClient We now use the new resource-based loader for the main resource in each Frame. This gives us access to caching and sharing. :^)
2020-06-06 13:38:08 +02:00
LibWeb: Change Resource's m_encoding to Optional<String> This modifies the Resource class to use Optional<String> for the encoding. If the encoding is unknown, the Optional will not have a value (instead of using the null state of the String class). It also implements a has_encoding() instance method and modifies the callers of Resource::encoding() to use the new API.
2021-05-12 10:21:00 +02:00
if (resource()->has_encoding()) {
Browser+LibWeb: Silence some debug spams
2021-08-07 16:37:26 +08:00
dbgln_if(RESOURCE_DEBUG, "This content has MIME type '{}', encoding '{}'", resource()->mime_type(), resource()->encoding().value());
LibWeb: Change Resource's m_encoding to Optional<String> This modifies the Resource class to use Optional<String> for the encoding. If the encoding is unknown, the Optional will not have a value (instead of using the null state of the String class). It also implements a has_encoding() instance method and modifies the callers of Resource::encoding() to use the new API.
2021-05-12 10:21:00 +02:00
} else {
Browser+LibWeb: Silence some debug spams
2021-08-07 16:37:26 +08:00
dbgln_if(RESOURCE_DEBUG, "This content has MIME type '{}', encoding unknown", resource()->mime_type());
LibWeb: Change Resource's m_encoding to Optional<String> This modifies the Resource class to use Optional<String> for the encoding. If the encoding is unknown, the Optional will not have a value (instead of using the null state of the String class). It also implements a has_encoding() instance method and modifies the callers of Resource::encoding() to use the new API.
2021-05-12 10:21:00 +02:00
}
LibWeb: Attach DOM::Document to its frame before parsing FrameLoader now begins by constructing a DOM::Document, and then builds a document tree inside it based on the MIME type. For text/html we pass control to the HTMLDocumentParser as before. This gives us access to things like window.alert() during parsing. Fixes #3973.
2020-12-13 17:38:03 +01:00
LibWeb: Determine the origin when navigating across documents
2022-08-25 19:04:27 +01:00
auto final_sandboxing_flag_set = HTML::SandboxingFlagSet {};
// (Part of https://html.spec.whatwg.org/#navigating-across-documents)
// 3. Let responseOrigin be the result of determining the origin given browsingContext, resource's url, finalSandboxFlags, and incumbentNavigationOrigin.
// FIXME: Pass incumbentNavigationOrigin
auto response_origin = HTML::determine_the_origin(browsing_context(), url, final_sandboxing_flag_set, {});
LibWeb: Make Fetch::Infrastructure::{Request,Response,HeaderList} GC'd This is the way. On a more serious note, there's no reason to keep adding ref-counted classes to LibWeb now that the majority of classes is GC'd - it only adds the risk of discovering some cycle down the line, and forces us to use handles as we can't visit().
2022-10-30 01:52:07 +00:00
auto& vm = Bindings::main_thread_vm();
auto response = Fetch::Infrastructure::Response::create(vm);
LibWeb: Start implementing "create and initialize a Document" from HTML The way we've been creating DOM::Document has been pretty far from what the spec tells us to do, and this is a first big step towards getting us closer to spec. The new Document::create_and_initialize() is called by FrameLoader after loading a "text/html" resource. We create the JS Realm and the Window object when creating the Document (previously, we'd do it on first access to Document::interpreter().) The realm execution context is owned by the Environment Settings Object.
2022-08-04 21:30:33 +02:00
response->url_list().append(url);
HTML::NavigationParams navigation_params {
.id = {},
.request = nullptr,
LibWeb: Make Fetch::Infrastructure::{Request,Response,HeaderList} GC'd This is the way. On a more serious note, there's no reason to keep adding ref-counted classes to LibWeb now that the majority of classes is GC'd - it only adds the risk of discovering some cycle down the line, and forces us to use handles as we can't visit().
2022-10-30 01:52:07 +00:00
.response = response,
LibWeb: Determine the origin when navigating across documents
2022-08-25 19:04:27 +01:00
.origin = move(response_origin),
LibWeb: Start implementing "create and initialize a Document" from HTML The way we've been creating DOM::Document has been pretty far from what the spec tells us to do, and this is a first big step towards getting us closer to spec. The new Document::create_and_initialize() is called by FrameLoader after loading a "text/html" resource. We create the JS Realm and the Window object when creating the Document (previously, we'd do it on first access to Document::interpreter().) The realm execution context is owned by the Environment Settings Object.
2022-08-04 21:30:33 +02:00
.policy_container = HTML::PolicyContainer {},
LibWeb: Make Fetch::Infrastructure::{Request,Response,HeaderList} GC'd This is the way. On a more serious note, there's no reason to keep adding ref-counted classes to LibWeb now that the majority of classes is GC'd - it only adds the risk of discovering some cycle down the line, and forces us to use handles as we can't visit().
2022-10-30 01:52:07 +00:00
.final_sandboxing_flag_set = final_sandboxing_flag_set,
LibWeb: Start implementing "create and initialize a Document" from HTML The way we've been creating DOM::Document has been pretty far from what the spec tells us to do, and this is a first big step towards getting us closer to spec. The new Document::create_and_initialize() is called by FrameLoader after loading a "text/html" resource. We create the JS Realm and the Window object when creating the Document (previously, we'd do it on first access to Document::interpreter().) The realm execution context is owned by the Environment Settings Object.
2022-08-04 21:30:33 +02:00
.cross_origin_opener_policy = HTML::CrossOriginOpenerPolicy {},
.coop_enforcement_result = HTML::CrossOriginOpenerPolicyEnforcementResult {},
.reserved_environment = {},
.browsing_context = browsing_context(),
};
LibWeb: Make factory methods of DOM::Document fallible
2023-02-14 21:49:02 +01:00
auto document = DOM::Document::create_and_initialize(DOM::Document::Type::HTML, "text/html", move(navigation_params)).release_value_but_fixme_should_propagate_errors();
LibWeb: Attach DOM::Document to its frame before parsing FrameLoader now begins by constructing a DOM::Document, and then builds a document tree inside it based on the MIME type. For text/html we pass control to the HTMLDocumentParser as before. This gives us access to things like window.alert() during parsing. Fixes #3973.
2020-12-13 17:38:03 +01:00
document->set_url(url);
LibWeb: Change Document's m_encoding to Optional<String> This modifies the Document class to use Optional<String> for the encoding. If the encoding is unknown, the Optional will not have a value. It also implements the has_encoding() and encoding_or_default() instance methods, the latter of which will return "UTF-8" as a fallback if no encoding is present. The usage of Optional<String> instead of the null string is part of an effort to explicitly indicate that a string could not have a value. This also modifies the former callers of encoding() to use encoding_or_default(). Furthermore, the encoding will now only be set if it is actually known, rather than just guessed by earlier code.
2021-05-12 10:32:41 +02:00
document->set_encoding(resource()->encoding());
LibWeb: Attach DOM::Document to its frame before parsing FrameLoader now begins by constructing a DOM::Document, and then builds a document tree inside it based on the MIME type. For text/html we pass control to the HTMLDocumentParser as before. This gives us access to things like window.alert() during parsing. Fixes #3973.
2020-12-13 17:38:03 +01:00
document->set_content_type(resource()->mime_type());
LibWeb: Show error page if we can't handle a frame's main resource If we can't figure out how to make a Document for the main resource in a Frame, just show an error page.
2020-06-06 14:06:37 +02:00
LibWeb: Rename BrowsingContext::document() => active_document() This better matches the spec nomenclature. Note that we don't yet *retrieve* the active document according to spec.
2021-09-09 13:14:32 +02:00
browsing_context().set_active_document(document);
LibWeb+WebContent: Setup the js console client earlier This allows us to print messages in inline scripts. Also add an example of this in the welcome page to test this.
2022-09-21 17:12:00 +02:00
if (auto* page = browsing_context().page())
page->client().page_did_create_main_document();
LibWeb: Attach DOM::Document to its frame before parsing FrameLoader now begins by constructing a DOM::Document, and then builds a document tree inside it based on the MIME type. For text/html we pass control to the HTMLDocumentParser as before. This gives us access to things like window.alert() during parsing. Fixes #3973.
2020-12-13 17:38:03 +01:00
if (!parse_document(*document, resource()->encoded_data())) {
LibWeb: Show error page if we can't handle a frame's main resource If we can't figure out how to make a Document for the main resource in a Frame, just show an error page.
2020-06-06 14:06:37 +02:00
load_error_page(url, "Failed to parse content.");
return;
}
LibWeb: Turn FrameLoader into a ResourceClient We now use the new resource-based loader for the main resource in each Frame. This gives us access to caching and sharing. :^)
2020-06-06 13:38:08 +02:00
if (!url.fragment().is_empty())
LibWeb: Rename Web::Frame to Web::BrowsingContext Our "frame" concept very closely matches what the web specs call a "browsing context", so let's rename it to that. :^) The "main frame" becomes the "top-level browsing context", and "sub-frames" are now "nested browsing contexts".
2021-05-30 12:36:53 +02:00
browsing_context().scroll_to_anchor(url.fragment());
LibWeb: Scroll viewport to (0, 0) after loading a new document This fixes a long-standing bug where the view wouldn't update when navigating to a new page after looking at the ACID2 test. This happened because ACID2 actually scrolls the viewport far down. We didn't reset the scroll position upon navigation, and so the new page thought that we were still scrolled very far down, and this broke the invalidation rect calculations.
2021-09-08 11:56:50 +02:00
else
LibWeb: Make BrowsingContext ask PageClient when it wants to be scrolled BrowsingContext shouldn't be scrolling itself, instead it has to update the layout (to ensure that we have current document metrics, and then ask the PageClient nicely to scroll it. This fixes an issue where BrowsingContext sometimes believed itself to be scrolled, but OOPWV had a different idea.
2022-04-06 15:32:38 +02:00
browsing_context().scroll_to({ 0, 0 });
LibWeb: Dispatch DOM "load" event on <iframe> elements
2020-09-22 17:53:40 +02:00
LibWeb: Rename Web::Frame to Web::BrowsingContext Our "frame" concept very closely matches what the web specs call a "browsing context", so let's rename it to that. :^) The "main frame" becomes the "top-level browsing context", and "sub-frames" are now "nested browsing contexts".
2021-05-30 12:36:53 +02:00
if (auto* page = browsing_context().page())
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
page->client().page_did_finish_loading(url);
LibWeb: Turn FrameLoader into a ResourceClient We now use the new resource-based loader for the main resource in each Frame. This gives us access to caching and sharing. :^)
2020-06-06 13:38:08 +02:00
}
void FrameLoader::resource_did_fail()
{
LibWeb: Bail FrameLoader's load callbacks if associated BC is discarded This prevents us setting up the document of a removed browsing context container (BCC, e.g. <iframe>), which will cause a crash if the document contains a script that inserts another BCC as this will use the stale browsing context it previously set up, even if it's reinserted. Required by Prebid.js, which does this by inserting an `<iframe>` into a `<div>` in the active document via innerHTML, then transfers it to the `<html>` element: https://github.com/prebid/Prebid.js/blob/7b7389c5abdd05626f71c3df606a93713d1b9f85/src/utils.js#L597 This is done in the spec by removing all tasks and aborting all fetches when a document is destroyed: https://html.spec.whatwg.org/multipage/document-lifecycle.html#destroy-a-document See the code comments for a simplified example.
2023-02-28 20:42:51 +00:00
// See comment in resource_did_load() about why this is done.
if (browsing_context().has_been_discarded())
return;
LibWeb: Turn FrameLoader into a ResourceClient We now use the new resource-based loader for the main resource in each Frame. This gives us access to caching and sharing. :^)
2020-06-06 13:38:08 +02:00
load_error_page(resource()->url(), resource()->error());
}
LibWeb: Add a FrameLoader class and move PageView's loading logic there Each Frame now has a FrameLoader which will be responsible for handling loading inside that frame.
2020-06-06 13:02:44 +02:00
}
Reference in a new issue Copy permalink