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

351 lines
12 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
/*
* Copyright (c) 2020, Andreas Kling <kling@serenityos.org>
*
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>
#include <LibGfx/ImageDecoder.h>
#include <LibMarkdown/Document.h>
LibWeb: Set response header cookies on redirects Since we were previously relying on Document::set_cookie in order to set cookies received as a 'Set-Cookie' response header, we would ignore any response header cookies in redirect (status code 3xx) responses. While this behaviour is not strictly enforced in the specification, most major browsers do set cookies in redirect responses, and some sites (e.g. Cookie Clicker) rely on this behaviour. Since cookies are stored per-site and not per-document, this behaviour is achieved by simply decoupling the cookie set mechanism from it.
2022-02-12 16:02:56 +02:00
#include <LibWeb/Cookie/ParsedCookie.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: Rename HTMLDocumentParser => HTMLParser
2021-09-25 23:15:48 +02:00
#include <LibWeb/HTML/Parser/HTMLParser.h>
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
#include <LibWeb/ImageDecoding.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: Move the Page/Frame/EventHandler classes into Page/
2020-07-28 19:27:41 +02:00
#include <LibWeb/Page/Page.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 {
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;
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) {
Base+Browser: Add Browser icons Add some missing icons to the brower.
2022-01-03 22:20:01 -05:00
s_default_favicon_bitmap = Gfx::Bitmap::try_load_from_file("/res/icons/16x16/app-browser.png").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
}
FrameLoader::~FrameLoader()
{
}
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
static bool build_markdown_document(DOM::Document& document, const ByteBuffer& 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: Rename HTMLDocumentParser => HTMLParser
2021-09-25 23:15:48 +02:00
HTML::HTMLParser parser(document, markdown_document->render_to_html(), "utf-8");
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
parser.run(document.url());
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: 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
static bool build_text_document(DOM::Document& document, const ByteBuffer& 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 html_element = document.create_element("html");
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: 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 head_element = document.create_element("head");
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
html_element->append_child(head_element);
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_element = document.create_element("title");
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
head_element->append_child(title_element);
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: 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
title_element->append_child(title_text);
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 body_element = document.create_element("body");
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
html_element->append_child(body_element);
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 pre_element = document.create_element("pre");
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
body_element->append_child(pre_element);
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
pre_element->append_child(document.create_text_node(String::copy(data)));
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: 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
NonnullRefPtr decoder = image_decoder_client();
auto image = decoder->decode_image(data);
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: 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 html_element = document.create_element("html");
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: 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 head_element = document.create_element("head");
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
html_element->append_child(head_element);
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_element = document.create_element("title");
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
head_element->append_child(title_element);
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());
AK: Rename adopt() to adopt_ref() This makes it more symmetrical with adopt_own() (which is used to create a NonnullOwnPtr from the result of a naked new.)
2021-04-23 16:46:57 +02:00
auto title_text = adopt_ref(*new DOM::Text(document, String::formatted("{} [{}x{}]", basename, bitmap->width(), bitmap->height())));
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
title_element->append_child(title_text);
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 body_element = document.create_element("body");
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
html_element->append_child(body_element);
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 image_element = document.create_element("img");
image_element->set_attribute(HTML::AttributeNames::src, document.url().to_string());
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
body_element->append_child(image_element);
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: 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
static bool build_gemini_document(DOM::Document& document, const ByteBuffer& 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());
LibWeb: Add debug toggle for dumping gemini documents
2020-10-06 11:08:37 -04:00
String html_data = gemini_document->render_to_html();
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: Rename HTMLDocumentParser => HTMLParser
2021-09-25 23:15:48 +02:00
HTML::HTMLParser parser(document, html_data, "utf-8");
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
parser.run(document.url());
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: 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
bool FrameLoader::parse_document(DOM::Document& document, const ByteBuffer& 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
}
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 (mime_type.starts_with("image/"))
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;
}
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 (!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;
}
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: Also call page_did_start_loading() for FrameLoader::Type::Reload Surprisingly this is not used by the browser's page reload functionality but only JS's location.reload() - that's probably why this hasn't been noticed yet. Make sure we notify the page client about the load start in that case as well. :^)
2021-05-29 01:27:06 +01:00
if (type == Type::Navigation || type == Type::Reload) {
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: 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
page->client().page_did_start_loading(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: 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`
// FIXME: This should be case-insensitive.
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;
if (url.protocol() == "http" || url.protocol() == "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;
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_protocol(url.protocol());
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) {
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: Use the sandboxed image ImageDecoder when loading favicons
2021-11-20 11:25:46 +01:00
auto decoded_image = image_decoder_client().decode_image(data);
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) {
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 HTMLDocumentParser take an existing document We shouldn't really be creating the document objects inside the parser, since that makes it hard to hook up e.g JavaScript bindings early on.
2020-12-13 16:59:22 +01:00
auto document = DOM::Document::create(url);
LibWeb: Rename HTMLDocumentParser => HTMLParser
2021-09-25 23:15:48 +02:00
HTML::HTMLParser parser(document, html, "utf-8");
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
parser.run(url);
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(&parser.document());
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
}
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)
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
void FrameLoader::load_error_page(const AK::URL& failed_url, const String& 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
{
auto error_page_url = "file:///res/html/error.html";
ResourceLoader::the().load(
error_page_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, 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 };
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("failed_url", escape_html_entities(failed_url.to_string()));
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);
auto document = HTML::parse_html_document(generator.as_string_view(), failed_url, "utf-8");
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(document);
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: 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);
else
page->client().page_did_change_favicon(*s_default_favicon_bitmap);
}
}
LibWeb: Set response header cookies on redirects Since we were previously relying on Document::set_cookie in order to set cookies received as a 'Set-Cookie' response header, we would ignore any response header cookies in redirect (status code 3xx) responses. While this behaviour is not strictly enforced in the specification, most major browsers do set cookies in redirect responses, and some sites (e.g. Cookie Clicker) rely on this behaviour. Since cookies are stored per-site and not per-document, this behaviour is achieved by simply decoupling the cookie set mechanism from it.
2022-02-12 16:02:56 +02:00
void FrameLoader::store_response_cookies(AK::URL const& url, String const& cookies)
{
auto* page = browsing_context().page();
if (!page)
return;
auto set_cookie_json_value = MUST(JsonValue::from_string(cookies));
VERIFY(set_cookie_json_value.type() == JsonValue::Type::Array);
for (const auto& set_cookie_entry : set_cookie_json_value.as_array().values()) {
VERIFY(set_cookie_entry.type() == JsonValue::Type::String);
auto cookie = Cookie::parse_cookie(set_cookie_entry.as_string());
if (!cookie.has_value())
continue;
page->client().page_did_set_cookie(url, cookie.value(), Cookie::Source::Http); // FIXME: Determine cookie source correctly
}
}
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()
{
auto url = resource()->url();
LibWeb: Set response header cookies on redirects Since we were previously relying on Document::set_cookie in order to set cookies received as a 'Set-Cookie' response header, we would ignore any response header cookies in redirect (status code 3xx) responses. While this behaviour is not strictly enforced in the specification, most major browsers do set cookies in redirect responses, and some sites (e.g. Cookie Clicker) rely on this behaviour. Since cookies are stored per-site and not per-document, this behaviour is achieved by simply decoupling the cookie set mechanism from it.
2022-02-12 16:02:56 +02:00
if (auto set_cookie = resource()->response_headers().get("Set-Cookie"); set_cookie.has_value())
store_response_cookies(url, *set_cookie);
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++;
load(url.complete_url(location.value()), FrameLoader::Type::Navigation);
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: Fix redirects when a response has no data This makes redirects work when the HTTP server responds with just headers and no data.
2021-06-20 12:22:43 +01:00
if (!resource()->has_encoded_data()) {
load_error_page(url, "No data");
return;
}
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
auto document = DOM::Document::create();
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: 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
browsing_context().set_viewport_scroll_offset({ 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()
{
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