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

426 lines
16 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>
#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: 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: 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: 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 {
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
static String 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;
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
void FrameLoader::set_default_favicon_path(String path)
{
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) {
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_bitmap = Gfx::Bitmap::try_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 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, markdown_document->render_to_html(), "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_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: Check for valid names in Document.createElement() & friends We now validate that the provided tag names are valid XML tag names, and otherwise throw an "invalid character" DOM exception. 2% progression on ACID3. :^)
2022-02-26 10:00:49 +01:00
auto html_element = document.create_element("html").release_value();
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.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: Check for valid names in Document.createElement() & friends We now validate that the provided tag names are valid XML tag names, and otherwise throw an "invalid character" DOM exception. 2% progression on ACID3. :^)
2022-02-26 10:00:49 +01:00
auto head_element = document.create_element("head").release_value();
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: Check for valid names in Document.createElement() & friends We now validate that the provided tag names are valid XML tag names, and otherwise throw an "invalid character" DOM exception. 2% progression on ACID3. :^)
2022-02-26 10:00:49 +01:00
auto title_element = document.create_element("title").release_value();
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: Check for valid names in Document.createElement() & friends We now validate that the provided tag names are valid XML tag names, and otherwise throw an "invalid character" DOM exception. 2% progression on ACID3. :^)
2022-02-26 10:00:49 +01:00
auto body_element = document.create_element("body").release_value();
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: Check for valid names in Document.createElement() & friends We now validate that the provided tag names are valid XML tag names, and otherwise throw an "invalid character" DOM exception. 2% progression on ACID3. :^)
2022-02-26 10:00:49 +01:00
auto pre_element = document.create_element("pre").release_value();
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+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: Check for valid names in Document.createElement() & friends We now validate that the provided tag names are valid XML tag names, and otherwise throw an "invalid character" DOM exception. 2% progression on ACID3. :^)
2022-02-26 10:00:49 +01:00
auto html_element = document.create_element("html").release_value();
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.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: Check for valid names in Document.createElement() & friends We now validate that the provided tag names are valid XML tag names, and otherwise throw an "invalid character" DOM exception. 2% progression on ACID3. :^)
2022-02-26 10:00:49 +01:00
auto head_element = document.create_element("head").release_value();
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: Check for valid names in Document.createElement() & friends We now validate that the provided tag names are valid XML tag names, and otherwise throw an "invalid character" DOM exception. 2% progression on ACID3. :^)
2022-02-26 10:00:49 +01:00
auto title_element = document.create_element("title").release_value();
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());
LibWeb+LibJS: Make the EventTarget hierarchy (incl. DOM) GC-allocated This is a monster patch that turns all EventTargets into GC-allocated PlatformObjects. Their C++ wrapper classes are removed, and the LibJS garbage collector is now responsible for their lifetimes. There's a fair amount of hacks and band-aids in this patch, and we'll have a lot of cleanup to do after this.
2022-08-28 13:42:07 +02:00
auto title_text = document.heap().allocate<DOM::Text>(document.realm(), document, String::formatted("{} [{}x{}]", basename, bitmap->width(), bitmap->height()));
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: Check for valid names in Document.createElement() & friends We now validate that the provided tag names are valid XML tag names, and otherwise throw an "invalid character" DOM exception. 2% progression on ACID3. :^)
2022-02-26 10:00:49 +01:00
auto body_element = document.create_element("body").release_value();
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: Check for valid names in Document.createElement() & friends We now validate that the provided tag names are valid XML tag names, and otherwise throw an "invalid character" DOM exception. 2% progression on ACID3. :^)
2022-02-26 10:00:49 +01:00
auto image_element = document.create_element("img").release_value();
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
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
}
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());
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: 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
{
XML::Parser parser(data, { .resolve_external_resource = resolve_xml_resource });
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;
}
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: 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()) {
if (&page->top_level_browsing_context() == &m_browsing_context)
page->client().page_did_start_loading(url);
}
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`
// 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;
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;
LibWeb: Load favicon.ico only for http/https URLs
2020-11-07 09:03:52 +00:00
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) {
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: 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
auto response = make<Fetch::Infrastructure::Response>();
response->url_list().append(url);
HTML::NavigationParams navigation_params {
.id = {},
.request = nullptr,
.response = move(response),
.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(),
};
auto document = DOM::Document::create_and_initialize(
DOM::Document::Type::HTML,
"text/html",
move(navigation_params));
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: Implement Document/BrowsingContext hookup according to spec We now implement the browsing context's "set active document" algorithm from the spec, as well as the "discard" algorithm for browsing contexts and documents.
2022-09-20 21:44:42 +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
}
LibWeb: Allow configuring the default error page path
2022-04-03 18:01:10 +02:00
static String s_error_page_url = "file:///res/html/error.html";
void FrameLoader::set_error_page_url(String error_page_url)
{
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)
Everywhere: Run clang-format
2022-04-01 20:58:27 +03:00
void FrameLoader::load_error_page(const AK::URL& failed_url, String 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
{
ResourceLoader::the().load(
LibWeb: Allow configuring the default error page path
2022-04-03 18:01:10 +02:00
s_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);
LibWeb: Use FrameLoader::load_html() when loading error pages Use our existing helper function for parsing a HTML string and opening it as the main content of the attached browsing context.
2022-04-06 14:47:06 +02:00
load_html(generator.as_string_view(), failed_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: 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);
Everywhere: Run clang-format
2022-04-01 20:58:27 +03:00
for (auto const& set_cookie_entry : set_cookie_json_value.as_array().values()) {
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
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: 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: 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
auto response = make<Fetch::Infrastructure::Response>();
response->url_list().append(url);
HTML::NavigationParams navigation_params {
.id = {},
.request = nullptr,
.response = move(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: Determine the origin when navigating across documents
2022-08-25 19:04:27 +01:00
.final_sandboxing_flag_set = move(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(),
};
auto document = DOM::Document::create_and_initialize(
DOM::Document::Type::HTML,
"text/html",
move(navigation_params));
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()
{
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