mirror of
https://github.com/LadybirdBrowser/ladybird.git
synced 2026-04-20 02:40:27 +00:00
2e6e597c94
Filter out unsupported @font-face sources (e.g. .eot files, or sources with an explicit unsupported format() hint) when populating the FontFace's URL list, rather than fetching and attempting to decode them. This matches the behavior of Blink and WebKit, which both reject .eot URLs by filename when no format() hint is present, to avoid conflicts with old WinIE-style @font-face rules. Previously, we would fetch .eot files over the network, fail to decode them, and then reject the font load promise, leading to a flood of "NetworkError: Failed to load font" messages in the console.
762 lines
36 KiB
C++
762 lines
36 KiB
C++
/*
|
||
* Copyright (c) 2024, Andrew Kaster <akaster@serenityos.org>
|
||
* Copyright (c) 2025-2026, Sam Atkins <sam@ladybird.org>
|
||
*
|
||
* SPDX-License-Identifier: BSD-2-Clause
|
||
*/
|
||
|
||
#include <AK/ByteBuffer.h>
|
||
#include <LibCore/Promise.h>
|
||
#include <LibGC/Heap.h>
|
||
#include <LibGfx/Font/FontSupport.h>
|
||
#include <LibGfx/Font/Typeface.h>
|
||
#include <LibGfx/Font/WOFF/Loader.h>
|
||
#include <LibGfx/Font/WOFF2/Loader.h>
|
||
#include <LibJS/Runtime/ArrayBuffer.h>
|
||
#include <LibJS/Runtime/Realm.h>
|
||
#include <LibWeb/Bindings/FontFacePrototype.h>
|
||
#include <LibWeb/Bindings/Intrinsics.h>
|
||
#include <LibWeb/CSS/CSSFontFaceRule.h>
|
||
#include <LibWeb/CSS/Enums.h>
|
||
#include <LibWeb/CSS/FontComputer.h>
|
||
#include <LibWeb/CSS/FontFace.h>
|
||
#include <LibWeb/CSS/FontFaceSet.h>
|
||
#include <LibWeb/CSS/Parser/Parser.h>
|
||
#include <LibWeb/CSS/StyleValues/CustomIdentStyleValue.h>
|
||
#include <LibWeb/CSS/StyleValues/StringStyleValue.h>
|
||
#include <LibWeb/DOM/Document.h>
|
||
#include <LibWeb/HTML/Scripting/TemporaryExecutionContext.h>
|
||
#include <LibWeb/HTML/Window.h>
|
||
#include <LibWeb/Platform/EventLoopPlugin.h>
|
||
#include <LibWeb/WebIDL/AbstractOperations.h>
|
||
#include <LibWeb/WebIDL/Buffers.h>
|
||
#include <LibWeb/WebIDL/Promise.h>
|
||
|
||
namespace Web::CSS {
|
||
|
||
// In order to avoid conflicts with the old WinIE style of @font-face, if there is no format specified,
|
||
// we check to see if the URL ends with .eot. We will not try to load those.
|
||
// This matches the behavior of other engines (Blink, WebKit).
|
||
static bool is_unsupported_source(ParsedFontFace::Source const& source)
|
||
{
|
||
if (!source.local_or_url.has<URL>())
|
||
return false;
|
||
if (source.format.has_value())
|
||
return !font_format_is_supported(source.format.value());
|
||
return source.local_or_url.get<URL>().url().ends_with_bytes(".eot"sv);
|
||
}
|
||
|
||
static NonnullRefPtr<Core::Promise<NonnullRefPtr<Gfx::Typeface const>>> load_vector_font(JS::Realm& realm, ByteBuffer const& data)
|
||
{
|
||
auto promise = Core::Promise<NonnullRefPtr<Gfx::Typeface const>>::construct();
|
||
|
||
// FIXME: 'Asynchronously' shouldn't mean 'later on the main thread'.
|
||
// Can we defer this to a background thread?
|
||
Platform::EventLoopPlugin::the().deferred_invoke(GC::create_function(realm.heap(), [&data, promise] {
|
||
// FIXME: This should be de-duplicated with StyleComputer::FontLoader::try_load_font
|
||
// We don't have the luxury of knowing the MIME type, so we have to try all formats.
|
||
auto ttf = Gfx::Typeface::try_load_from_externally_owned_memory(data);
|
||
if (!ttf.is_error()) {
|
||
promise->resolve(ttf.release_value());
|
||
return;
|
||
}
|
||
auto woff = WOFF::try_load_from_bytes(data);
|
||
if (!woff.is_error()) {
|
||
promise->resolve(woff.release_value());
|
||
return;
|
||
}
|
||
auto woff2 = WOFF2::try_load_from_bytes(data);
|
||
if (!woff2.is_error()) {
|
||
promise->resolve(woff2.release_value());
|
||
return;
|
||
}
|
||
promise->reject(Error::from_string_literal("Automatic format detection failed"));
|
||
}));
|
||
|
||
return promise;
|
||
}
|
||
|
||
GC_DEFINE_ALLOCATOR(FontFace);
|
||
|
||
// https://drafts.csswg.org/css-font-loading/#font-face-constructor
|
||
GC::Ref<FontFace> FontFace::construct_impl(JS::Realm& realm, String family, FontFaceSource source, FontFaceDescriptors const& descriptors)
|
||
{
|
||
auto& vm = realm.vm();
|
||
|
||
// 1. Let font face be a fresh FontFace object. Set font face’s status attribute to "unloaded",
|
||
// Set its internal [[FontStatusPromise]] slot to a fresh pending Promise object.
|
||
auto font_face = realm.create<FontFace>(realm, WebIDL::create_promise(realm));
|
||
|
||
// Parse the family argument, and the members of the descriptors argument,
|
||
// according to the grammars of the corresponding descriptors of the CSS @font-face rule.
|
||
// If the source argument is a CSSOMString, parse it according to the grammar of the CSS src descriptor of the @font-face rule.
|
||
// If any of them fail to parse correctly, reject font face’s [[FontStatusPromise]] with a DOMException named "SyntaxError",
|
||
// set font face’s corresponding attributes to the empty string, and set font face’s status attribute to "error".
|
||
// Otherwise, set font face’s corresponding attributes to the serialization of the parsed values.
|
||
|
||
Parser::ParsingParams parsing_params { realm };
|
||
auto try_parse_descriptor = [&parsing_params, &font_face, &realm](DescriptorID descriptor_id, String const& string) -> String {
|
||
auto result = parse_css_descriptor(parsing_params, AtRuleID::FontFace, descriptor_id, string);
|
||
if (!result) {
|
||
font_face->reject_status_promise(WebIDL::SyntaxError::create(realm, Utf16String::formatted("FontFace constructor: Invalid {}", to_string(descriptor_id))));
|
||
return {};
|
||
}
|
||
|
||
if (result->is_custom_ident())
|
||
return result->as_custom_ident().custom_ident().to_string();
|
||
|
||
return result->to_string(SerializationMode::Normal);
|
||
};
|
||
font_face->m_family = try_parse_descriptor(DescriptorID::FontFamily, family);
|
||
font_face->m_style = try_parse_descriptor(DescriptorID::FontStyle, descriptors.style);
|
||
font_face->m_weight = try_parse_descriptor(DescriptorID::FontWeight, descriptors.weight);
|
||
font_face->m_stretch = try_parse_descriptor(DescriptorID::FontWidth, descriptors.stretch);
|
||
font_face->m_unicode_range = try_parse_descriptor(DescriptorID::UnicodeRange, descriptors.unicode_range);
|
||
font_face->m_feature_settings = try_parse_descriptor(DescriptorID::FontFeatureSettings, descriptors.feature_settings);
|
||
font_face->m_variation_settings = try_parse_descriptor(DescriptorID::FontVariationSettings, descriptors.variation_settings);
|
||
font_face->m_display = try_parse_descriptor(DescriptorID::FontDisplay, descriptors.display);
|
||
font_face->m_ascent_override = try_parse_descriptor(DescriptorID::AscentOverride, descriptors.ascent_override);
|
||
font_face->m_descent_override = try_parse_descriptor(DescriptorID::DescentOverride, descriptors.descent_override);
|
||
font_face->m_line_gap_override = try_parse_descriptor(DescriptorID::LineGapOverride, descriptors.line_gap_override);
|
||
RefPtr<StyleValue const> parsed_source;
|
||
if (auto* source_string = source.get_pointer<String>()) {
|
||
parsed_source = parse_css_descriptor(parsing_params, AtRuleID::FontFace, DescriptorID::Src, *source_string);
|
||
if (!parsed_source) {
|
||
font_face->reject_status_promise(WebIDL::SyntaxError::create(realm, Utf16String::formatted("FontFace constructor: Invalid {}", to_string(DescriptorID::Src))));
|
||
}
|
||
}
|
||
// Return font face. If font face’s status is "error", terminate this algorithm;
|
||
// otherwise, complete the rest of these steps asynchronously.
|
||
// FIXME: Do the rest of this asynchronously.
|
||
if (font_face->status() == Bindings::FontFaceLoadStatus::Error)
|
||
return font_face;
|
||
|
||
// 2. If the source argument was a CSSOMString, set font face’s internal [[Urls]] slot to the string.
|
||
// If the source argument was a BinaryData, set font face’s internal [[Data]] slot to the passed argument.
|
||
if (source.has<String>()) {
|
||
font_face->m_urls = ParsedFontFace::sources_from_style_value(*parsed_source);
|
||
font_face->m_urls.remove_all_matching(is_unsupported_source);
|
||
} else {
|
||
auto buffer_source = source.get<GC::Root<WebIDL::BufferSource>>();
|
||
auto maybe_buffer = WebIDL::get_buffer_source_copy(buffer_source->raw_object());
|
||
if (maybe_buffer.is_error()) {
|
||
VERIFY(maybe_buffer.error().code() == ENOMEM);
|
||
auto throw_completion = vm.throw_completion<JS::InternalError>(vm.error_message(JS::VM::ErrorMessage::OutOfMemory));
|
||
font_face->reject_status_promise(throw_completion.value());
|
||
} else {
|
||
font_face->m_binary_data = maybe_buffer.release_value();
|
||
}
|
||
}
|
||
|
||
if (font_face->m_binary_data.is_empty() && font_face->m_urls.is_empty())
|
||
font_face->reject_status_promise(WebIDL::SyntaxError::create(realm, "FontFace constructor: Invalid font source"_utf16));
|
||
|
||
// 3. If font face’s [[Data]] slot is not null, queue a task to run the following steps synchronously:
|
||
if (font_face->m_binary_data.is_empty())
|
||
return font_face;
|
||
|
||
HTML::queue_global_task(HTML::Task::Source::FontLoading, HTML::relevant_global_object(*font_face), GC::create_function(vm.heap(), [&realm, font_face] {
|
||
HTML::TemporaryExecutionContext context(font_face->realm(), HTML::TemporaryExecutionContext::CallbacksEnabled::Yes);
|
||
// 1. Set font face’s status attribute to "loading".
|
||
font_face->m_status = Bindings::FontFaceLoadStatus::Loading;
|
||
|
||
// 2. For each FontFaceSet font face is in:
|
||
for (auto& font_face_set : font_face->m_containing_sets) {
|
||
// 1. If the FontFaceSet’s [[LoadingFonts]] list is empty, switch the FontFaceSet to loading.
|
||
if (font_face_set->loading_fonts().is_empty())
|
||
font_face_set->switch_to_loading();
|
||
|
||
// 2. Append font face to the FontFaceSet’s [[LoadingFonts]] list.
|
||
font_face_set->loading_fonts().append(font_face);
|
||
}
|
||
|
||
// 3. Asynchronously, attempt to parse the data in it as a font.
|
||
// When this is completed, successfully or not, queue a task to run the following steps synchronously:
|
||
font_face->m_font_load_promise = load_vector_font(realm, font_face->m_binary_data);
|
||
|
||
font_face->m_font_load_promise->when_resolved([font = GC::make_root(font_face)](auto const& vector_font) -> ErrorOr<void> {
|
||
HTML::queue_global_task(HTML::Task::Source::FontLoading, HTML::relevant_global_object(*font), GC::create_function(font->heap(), [font = GC::Ref(*font), vector_font] {
|
||
HTML::TemporaryExecutionContext context(font->realm(), HTML::TemporaryExecutionContext::CallbacksEnabled::Yes);
|
||
// 1. If the load was successful, font face now represents the parsed font;
|
||
// fulfill font face’s [[FontStatusPromise]] with font face, and set its status attribute to "loaded".
|
||
|
||
// FIXME: Are we supposed to set the properties of the FontFace based on the loaded vector font?
|
||
font->m_parsed_font = vector_font;
|
||
font->m_status = Bindings::FontFaceLoadStatus::Loaded;
|
||
WebIDL::resolve_promise(font->realm(), font->m_font_status_promise, font);
|
||
|
||
// For each FontFaceSet font face is in:
|
||
for (auto& font_face_set : font->m_containing_sets) {
|
||
// 1. Add font face to the FontFaceSet’s [[LoadedFonts]] list.
|
||
font_face_set->loaded_fonts().append(font);
|
||
|
||
// 2. Remove font face from the FontFaceSet’s [[LoadingFonts]] list. If font was the last item in
|
||
// that list (and so the list is now empty), switch the FontFaceSet to loaded.
|
||
font_face_set->loading_fonts().remove_all_matching([font](auto const& entry) { return entry == font; });
|
||
if (font_face_set->loading_fonts().is_empty())
|
||
font_face_set->switch_to_loaded();
|
||
}
|
||
|
||
font->m_font_load_promise = nullptr;
|
||
}));
|
||
return {};
|
||
});
|
||
font_face->m_font_load_promise->when_rejected([font = GC::make_root(font_face)](auto const& error) {
|
||
HTML::queue_global_task(HTML::Task::Source::FontLoading, HTML::relevant_global_object(*font), GC::create_function(font->heap(), [font = GC::Ref(*font), error = Error::copy(error)] {
|
||
HTML::TemporaryExecutionContext context(font->realm(), HTML::TemporaryExecutionContext::CallbacksEnabled::Yes);
|
||
// 2. Otherwise, reject font face’s [[FontStatusPromise]] with a DOMException named "SyntaxError"
|
||
// and set font face’s status attribute to "error".
|
||
font->reject_status_promise(WebIDL::SyntaxError::create(font->realm(), Utf16String::formatted("Failed to load font: {}", error)));
|
||
|
||
// For each FontFaceSet font face is in:
|
||
for (auto& font_face_set : font->m_containing_sets) {
|
||
// 1. Add font face to the FontFaceSet’s [[FailedFonts]] list.
|
||
font_face_set->failed_fonts().append(font);
|
||
|
||
// 2. Remove font face from the FontFaceSet’s [[LoadingFonts]] list. If font was the last item in
|
||
// that list (and so the list is now empty), switch the FontFaceSet to loaded.
|
||
font_face_set->loading_fonts().remove_all_matching([font](auto const& entry) { return entry == font; });
|
||
if (font_face_set->loading_fonts().is_empty())
|
||
font_face_set->switch_to_loaded();
|
||
}
|
||
|
||
font->m_font_load_promise = nullptr;
|
||
}));
|
||
});
|
||
}));
|
||
|
||
return font_face;
|
||
}
|
||
|
||
// https://drafts.csswg.org/css-font-loading/#font-face-css-connection
|
||
GC::Ref<FontFace> FontFace::create_css_connected(JS::Realm& realm, CSSFontFaceRule& rule)
|
||
{
|
||
HTML::TemporaryExecutionContext execution_context { realm };
|
||
|
||
auto font_face = realm.create<FontFace>(realm, WebIDL::create_promise(realm));
|
||
|
||
font_face->m_css_font_face_rule = &rule;
|
||
font_face->reparse_connected_css_font_face_rule_descriptors();
|
||
|
||
if (auto src_value = rule.descriptors()->descriptor(DescriptorID::Src)) {
|
||
font_face->m_urls = ParsedFontFace::sources_from_style_value(*src_value);
|
||
font_face->m_urls.remove_all_matching(is_unsupported_source);
|
||
}
|
||
|
||
rule.set_css_connected_font_face(font_face);
|
||
|
||
return font_face;
|
||
}
|
||
|
||
void FontFace::reparse_connected_css_font_face_rule_descriptors()
|
||
{
|
||
auto const& descriptors = m_css_font_face_rule->descriptors();
|
||
|
||
set_family_impl(*descriptors->descriptor(DescriptorID::FontFamily));
|
||
set_style_impl(*descriptors->descriptor_or_initial_value(DescriptorID::FontStyle));
|
||
set_weight_impl(*descriptors->descriptor_or_initial_value(DescriptorID::FontWeight));
|
||
set_stretch_impl(*descriptors->descriptor_or_initial_value(DescriptorID::FontWidth));
|
||
set_unicode_range_impl(*descriptors->descriptor_or_initial_value(DescriptorID::UnicodeRange));
|
||
set_feature_settings_impl(*descriptors->descriptor_or_initial_value(DescriptorID::FontFeatureSettings));
|
||
set_variation_settings_impl(*descriptors->descriptor_or_initial_value(DescriptorID::FontVariationSettings));
|
||
set_display_impl(*descriptors->descriptor_or_initial_value(DescriptorID::FontDisplay));
|
||
set_ascent_override_impl(*descriptors->descriptor_or_initial_value(DescriptorID::AscentOverride));
|
||
set_descent_override_impl(*descriptors->descriptor_or_initial_value(DescriptorID::DescentOverride));
|
||
set_line_gap_override_impl(*descriptors->descriptor_or_initial_value(DescriptorID::LineGapOverride));
|
||
}
|
||
|
||
ParsedFontFace FontFace::parsed_font_face() const
|
||
{
|
||
if (m_css_font_face_rule)
|
||
return m_css_font_face_rule->font_face();
|
||
|
||
// FIXME: The ParsedFontFace is kind of expensive to create. We should be using a shared sub-object for the data
|
||
return ParsedFontFace {
|
||
// Create a dummy CSSFontFaceRule so that we load relative to the document's base URL
|
||
CSSFontFaceRule::create(realm(), CSSFontFaceDescriptors::create(realm(), {})),
|
||
m_family,
|
||
// FIXME: Actually parse this as we're supposed to.
|
||
m_weight.to_number<int>().map([](auto weight) { return FontWeightRange { weight, weight }; }),
|
||
0, // FIXME: slope
|
||
Gfx::FontWidth::Normal, // FIXME: width
|
||
m_urls,
|
||
m_unicode_ranges,
|
||
{}, // FIXME: ascent_override
|
||
{}, // FIXME: descent_override
|
||
{}, // FIXME: line_gap_override
|
||
FontDisplay::Auto, // FIXME: font_display
|
||
{}, // font-named-instance doesn't exist in FontFace
|
||
{}, // font-language-override doesn't exist in FontFace
|
||
{}, // FIXME: feature_settings
|
||
{}, // FIXME: variation_settings
|
||
};
|
||
}
|
||
|
||
FontFace::FontFace(JS::Realm& realm, GC::Ref<WebIDL::Promise> font_status_promise)
|
||
: Bindings::PlatformObject(realm)
|
||
, m_font_status_promise(font_status_promise)
|
||
{
|
||
}
|
||
|
||
FontFace::~FontFace() = default;
|
||
|
||
void FontFace::initialize(JS::Realm& realm)
|
||
{
|
||
WEB_SET_PROTOTYPE_FOR_INTERFACE(FontFace);
|
||
Base::initialize(realm);
|
||
}
|
||
|
||
void FontFace::visit_edges(JS::Cell::Visitor& visitor)
|
||
{
|
||
Base::visit_edges(visitor);
|
||
|
||
visitor.visit(m_font_status_promise);
|
||
visitor.visit(m_css_font_face_rule);
|
||
for (auto const& font_face_set : m_containing_sets)
|
||
visitor.visit(font_face_set);
|
||
}
|
||
|
||
GC::Ref<WebIDL::Promise> FontFace::loaded() const
|
||
{
|
||
return m_font_status_promise;
|
||
}
|
||
|
||
void FontFace::reject_status_promise(JS::Value reason)
|
||
{
|
||
if (m_status != Bindings::FontFaceLoadStatus::Error) {
|
||
WebIDL::reject_promise(realm(), m_font_status_promise, reason);
|
||
WebIDL::mark_promise_as_handled(m_font_status_promise);
|
||
m_status = Bindings::FontFaceLoadStatus::Error;
|
||
}
|
||
}
|
||
|
||
void FontFace::disconnect_from_css_rule()
|
||
{
|
||
m_css_font_face_rule = nullptr;
|
||
}
|
||
|
||
// https://drafts.csswg.org/css-font-loading/#dom-fontface-family
|
||
WebIDL::ExceptionOr<void> FontFace::set_family(String const& string)
|
||
{
|
||
// On setting, parse the string according to the grammar for the corresponding @font-face descriptor.
|
||
// If it does not match the grammar, throw a SyntaxError; otherwise, set the attribute to the serialization of the
|
||
// parsed value.
|
||
|
||
auto property = parse_css_descriptor(Parser::ParsingParams(), AtRuleID::FontFace, DescriptorID::FontFamily, string);
|
||
if (!property)
|
||
return WebIDL::SyntaxError::create(realm(), "FontFace.family setter: Invalid descriptor value"_utf16);
|
||
|
||
if (m_css_font_face_rule)
|
||
TRY(m_css_font_face_rule->descriptors()->set_font_family(string));
|
||
|
||
set_family_impl(property.release_nonnull());
|
||
|
||
return {};
|
||
}
|
||
|
||
void FontFace::set_family_impl(NonnullRefPtr<StyleValue const> const& value)
|
||
{
|
||
m_family = string_from_style_value(value).to_string();
|
||
}
|
||
|
||
// https://drafts.csswg.org/css-font-loading/#dom-fontface-style
|
||
WebIDL::ExceptionOr<void> FontFace::set_style(String const& string)
|
||
{
|
||
// On setting, parse the string according to the grammar for the corresponding @font-face descriptor.
|
||
// If it does not match the grammar, throw a SyntaxError; otherwise, set the attribute to the serialization of the
|
||
// parsed value.
|
||
|
||
auto property = parse_css_descriptor(Parser::ParsingParams(), AtRuleID::FontFace, DescriptorID::FontStyle, string);
|
||
if (!property)
|
||
return WebIDL::SyntaxError::create(realm(), "FontFace.style setter: Invalid descriptor value"_utf16);
|
||
|
||
if (m_css_font_face_rule)
|
||
TRY(m_css_font_face_rule->descriptors()->set_font_style(string));
|
||
|
||
set_style_impl(property.release_nonnull());
|
||
|
||
return {};
|
||
}
|
||
|
||
void FontFace::set_style_impl(NonnullRefPtr<StyleValue const> const& value)
|
||
{
|
||
m_style = value->to_string(SerializationMode::Normal);
|
||
}
|
||
|
||
// https://drafts.csswg.org/css-font-loading/#dom-fontface-weight
|
||
WebIDL::ExceptionOr<void> FontFace::set_weight(String const& string)
|
||
{
|
||
// On setting, parse the string according to the grammar for the corresponding @font-face descriptor.
|
||
// If it does not match the grammar, throw a SyntaxError; otherwise, set the attribute to the serialization of the
|
||
// parsed value.
|
||
|
||
auto property = parse_css_descriptor(Parser::ParsingParams(), AtRuleID::FontFace, DescriptorID::FontWeight, string);
|
||
if (!property)
|
||
return WebIDL::SyntaxError::create(realm(), "FontFace.weight setter: Invalid descriptor value"_utf16);
|
||
|
||
if (m_css_font_face_rule)
|
||
TRY(m_css_font_face_rule->descriptors()->set_font_weight(string));
|
||
|
||
set_weight_impl(property.release_nonnull());
|
||
|
||
return {};
|
||
}
|
||
|
||
void FontFace::set_weight_impl(NonnullRefPtr<StyleValue const> const& value)
|
||
{
|
||
m_weight = value->to_string(SerializationMode::Normal);
|
||
}
|
||
|
||
// https://drafts.csswg.org/css-font-loading/#dom-fontface-stretch
|
||
WebIDL::ExceptionOr<void> FontFace::set_stretch(String const& string)
|
||
{
|
||
// On setting, parse the string according to the grammar for the corresponding @font-face descriptor.
|
||
// If it does not match the grammar, throw a SyntaxError; otherwise, set the attribute to the serialization of the
|
||
// parsed value.
|
||
|
||
// NOTE: font-stretch is now an alias for font-width
|
||
auto property = parse_css_descriptor(Parser::ParsingParams(), AtRuleID::FontFace, DescriptorID::FontWidth, string);
|
||
if (!property)
|
||
return WebIDL::SyntaxError::create(realm(), "FontFace.stretch setter: Invalid descriptor value"_utf16);
|
||
|
||
if (m_css_font_face_rule)
|
||
TRY(m_css_font_face_rule->descriptors()->set_font_width(string));
|
||
|
||
set_stretch_impl(property.release_nonnull());
|
||
|
||
return {};
|
||
}
|
||
|
||
void FontFace::set_stretch_impl(NonnullRefPtr<StyleValue const> const& value)
|
||
{
|
||
m_stretch = value->to_string(SerializationMode::Normal);
|
||
}
|
||
|
||
// https://drafts.csswg.org/css-font-loading/#dom-fontface-unicoderange
|
||
WebIDL::ExceptionOr<void> FontFace::set_unicode_range(String const& string)
|
||
{
|
||
// On setting, parse the string according to the grammar for the corresponding @font-face descriptor.
|
||
// If it does not match the grammar, throw a SyntaxError; otherwise, set the attribute to the serialization of the
|
||
// parsed value.
|
||
|
||
auto property = parse_css_descriptor(Parser::ParsingParams(), AtRuleID::FontFace, DescriptorID::UnicodeRange, string);
|
||
if (!property)
|
||
return WebIDL::SyntaxError::create(realm(), "FontFace.unicodeRange setter: Invalid descriptor value"_utf16);
|
||
|
||
if (m_css_font_face_rule)
|
||
TRY(m_css_font_face_rule->descriptors()->set_unicode_range(string));
|
||
|
||
set_unicode_range_impl(property.release_nonnull());
|
||
|
||
return {};
|
||
}
|
||
|
||
void FontFace::set_unicode_range_impl(NonnullRefPtr<StyleValue const> const& value)
|
||
{
|
||
m_unicode_range = value->to_string(SerializationMode::Normal);
|
||
}
|
||
|
||
// https://drafts.csswg.org/css-font-loading/#dom-fontface-featuresettings
|
||
WebIDL::ExceptionOr<void> FontFace::set_feature_settings(String const& string)
|
||
{
|
||
// On setting, parse the string according to the grammar for the corresponding @font-face descriptor.
|
||
// If it does not match the grammar, throw a SyntaxError; otherwise, set the attribute to the serialization of the
|
||
// parsed value.
|
||
|
||
auto property = parse_css_descriptor(Parser::ParsingParams(), AtRuleID::FontFace, DescriptorID::FontFeatureSettings, string);
|
||
if (!property)
|
||
return WebIDL::SyntaxError::create(realm(), "FontFace.featureSettings setter: Invalid descriptor value"_utf16);
|
||
|
||
if (m_css_font_face_rule)
|
||
TRY(m_css_font_face_rule->descriptors()->set_font_feature_settings(string));
|
||
|
||
set_feature_settings_impl(property.release_nonnull());
|
||
|
||
return {};
|
||
}
|
||
|
||
void FontFace::set_feature_settings_impl(NonnullRefPtr<StyleValue const> const& value)
|
||
{
|
||
m_feature_settings = value->to_string(SerializationMode::Normal);
|
||
}
|
||
|
||
// https://drafts.csswg.org/css-font-loading/#dom-fontface-variationsettings
|
||
WebIDL::ExceptionOr<void> FontFace::set_variation_settings(String const& string)
|
||
{
|
||
// On setting, parse the string according to the grammar for the corresponding @font-face descriptor.
|
||
// If it does not match the grammar, throw a SyntaxError; otherwise, set the attribute to the serialization of the
|
||
// parsed value.
|
||
|
||
auto property = parse_css_descriptor(Parser::ParsingParams(), AtRuleID::FontFace, DescriptorID::FontVariationSettings, string);
|
||
if (!property)
|
||
return WebIDL::SyntaxError::create(realm(), "FontFace.variationSettings setter: Invalid descriptor value"_utf16);
|
||
|
||
if (m_css_font_face_rule)
|
||
TRY(m_css_font_face_rule->descriptors()->set_font_variation_settings(string));
|
||
|
||
set_variation_settings_impl(property.release_nonnull());
|
||
|
||
return {};
|
||
}
|
||
|
||
void FontFace::set_variation_settings_impl(NonnullRefPtr<StyleValue const> const& value)
|
||
{
|
||
m_variation_settings = value->to_string(SerializationMode::Normal);
|
||
}
|
||
|
||
// https://drafts.csswg.org/css-font-loading/#dom-fontface-display
|
||
WebIDL::ExceptionOr<void> FontFace::set_display(String const& string)
|
||
{
|
||
// On setting, parse the string according to the grammar for the corresponding @font-face descriptor.
|
||
// If it does not match the grammar, throw a SyntaxError; otherwise, set the attribute to the serialization of the
|
||
// parsed value.
|
||
|
||
auto property = parse_css_descriptor(Parser::ParsingParams(), AtRuleID::FontFace, DescriptorID::FontDisplay, string);
|
||
if (!property)
|
||
return WebIDL::SyntaxError::create(realm(), "FontFace.display setter: Invalid descriptor value"_utf16);
|
||
|
||
if (m_css_font_face_rule)
|
||
TRY(m_css_font_face_rule->descriptors()->set_font_display(string));
|
||
|
||
set_display_impl(property.release_nonnull());
|
||
|
||
return {};
|
||
}
|
||
|
||
void FontFace::set_display_impl(NonnullRefPtr<StyleValue const> const& value)
|
||
{
|
||
m_display = value->to_string(SerializationMode::Normal);
|
||
}
|
||
|
||
// https://drafts.csswg.org/css-font-loading/#dom-fontface-ascentoverride
|
||
WebIDL::ExceptionOr<void> FontFace::set_ascent_override(String const& string)
|
||
{
|
||
// On setting, parse the string according to the grammar for the corresponding @font-face descriptor.
|
||
// If it does not match the grammar, throw a SyntaxError; otherwise, set the attribute to the serialization of the
|
||
// parsed value.
|
||
|
||
auto property = parse_css_descriptor(Parser::ParsingParams(), AtRuleID::FontFace, DescriptorID::AscentOverride, string);
|
||
if (!property)
|
||
return WebIDL::SyntaxError::create(realm(), "FontFace.ascentOverride setter: Invalid descriptor value"_utf16);
|
||
|
||
if (m_css_font_face_rule)
|
||
TRY(m_css_font_face_rule->descriptors()->set_ascent_override(string));
|
||
|
||
set_ascent_override_impl(property.release_nonnull());
|
||
|
||
return {};
|
||
}
|
||
|
||
void FontFace::set_ascent_override_impl(NonnullRefPtr<StyleValue const> const& value)
|
||
{
|
||
m_ascent_override = value->to_string(SerializationMode::Normal);
|
||
}
|
||
|
||
// https://drafts.csswg.org/css-font-loading/#dom-fontface-descentoverride
|
||
WebIDL::ExceptionOr<void> FontFace::set_descent_override(String const& string)
|
||
{
|
||
// On setting, parse the string according to the grammar for the corresponding @font-face descriptor.
|
||
// If it does not match the grammar, throw a SyntaxError; otherwise, set the attribute to the serialization of the
|
||
// parsed value.
|
||
|
||
auto property = parse_css_descriptor(Parser::ParsingParams(), AtRuleID::FontFace, DescriptorID::DescentOverride, string);
|
||
if (!property)
|
||
return WebIDL::SyntaxError::create(realm(), "FontFace.descentOverride setter: Invalid descriptor value"_utf16);
|
||
|
||
if (m_css_font_face_rule)
|
||
TRY(m_css_font_face_rule->descriptors()->set_descent_override(string));
|
||
|
||
set_descent_override_impl(property.release_nonnull());
|
||
|
||
return {};
|
||
}
|
||
|
||
void FontFace::set_descent_override_impl(NonnullRefPtr<StyleValue const> const& value)
|
||
{
|
||
m_descent_override = value->to_string(SerializationMode::Normal);
|
||
}
|
||
|
||
// https://drafts.csswg.org/css-font-loading/#dom-fontface-linegapoverride
|
||
WebIDL::ExceptionOr<void> FontFace::set_line_gap_override(String const& string)
|
||
{
|
||
// On setting, parse the string according to the grammar for the corresponding @font-face descriptor.
|
||
// If it does not match the grammar, throw a SyntaxError; otherwise, set the attribute to the serialization of the
|
||
// parsed value.
|
||
|
||
auto property = parse_css_descriptor(Parser::ParsingParams(), AtRuleID::FontFace, DescriptorID::LineGapOverride, string);
|
||
if (!property)
|
||
return WebIDL::SyntaxError::create(realm(), "FontFace.lineGapOverride setter: Invalid descriptor value"_utf16);
|
||
|
||
if (m_css_font_face_rule)
|
||
TRY(m_css_font_face_rule->descriptors()->set_line_gap_override(string));
|
||
|
||
set_line_gap_override_impl(property.release_nonnull());
|
||
|
||
return {};
|
||
}
|
||
|
||
void FontFace::set_line_gap_override_impl(NonnullRefPtr<StyleValue const> const& value)
|
||
{
|
||
m_line_gap_override = value->to_string(SerializationMode::Normal);
|
||
}
|
||
|
||
// https://drafts.csswg.org/css-font-loading/#dom-fontface-load
|
||
GC::Ref<WebIDL::Promise> FontFace::load()
|
||
{
|
||
// 1. Let font face be the FontFace object on which this method was called.
|
||
auto& font_face = *this;
|
||
|
||
// 2. If font face’s [[Urls]] slot is null, or its status attribute is anything other than "unloaded",
|
||
// return font face’s [[FontStatusPromise]] and abort these steps.
|
||
if (font_face.m_urls.is_empty() || font_face.m_status != Bindings::FontFaceLoadStatus::Unloaded)
|
||
return font_face.loaded();
|
||
|
||
// 3. Otherwise, set font face’s status attribute to "loading", return font face’s [[FontStatusPromise]],
|
||
// and continue executing the rest of this algorithm asynchronously.
|
||
m_status = Bindings::FontFaceLoadStatus::Loading;
|
||
if (m_css_font_face_rule)
|
||
m_css_font_face_rule->set_loading_state(CSSStyleSheet::LoadingState::Loading);
|
||
|
||
Web::Platform::EventLoopPlugin::the().deferred_invoke(GC::create_function(heap(), [this] {
|
||
// 4. Using the value of font face’s [[Urls]] slot, attempt to load a font as defined in [CSS-FONTS-3],
|
||
// as if it was the value of a @font-face rule’s src descriptor.
|
||
|
||
// 5. When the load operation completes, successfully or not, queue a task to run the following steps synchronously:
|
||
auto on_load = GC::create_function(heap(), [this](RefPtr<Gfx::Typeface const> maybe_typeface) {
|
||
HTML::queue_global_task(HTML::Task::Source::FontLoading, HTML::relevant_global_object(*this), GC::create_function(heap(), [this, maybe_typeface] {
|
||
HTML::TemporaryExecutionContext context(realm(), HTML::TemporaryExecutionContext::CallbacksEnabled::Yes);
|
||
// 1. If the attempt to load fails, reject font face’s [[FontStatusPromise]] with a DOMException whose name
|
||
// is "NetworkError" and set font face’s status attribute to "error".
|
||
if (!maybe_typeface) {
|
||
m_status = Bindings::FontFaceLoadStatus::Error;
|
||
if (m_css_font_face_rule)
|
||
m_css_font_face_rule->set_loading_state(CSSStyleSheet::LoadingState::Error);
|
||
WebIDL::reject_promise(realm(), m_font_status_promise, WebIDL::NetworkError::create(realm(), "Failed to load font"_utf16));
|
||
|
||
// For each FontFaceSet font face is in:
|
||
for (auto& font_face_set : m_containing_sets) {
|
||
// 1. Add font face to the FontFaceSet’s [[FailedFonts]] list.
|
||
font_face_set->failed_fonts().append(*this);
|
||
|
||
// 2. Remove font face from the FontFaceSet’s [[LoadingFonts]] list. If font was the last item
|
||
// in that list (and so the list is now empty), switch the FontFaceSet to loaded.
|
||
font_face_set->loading_fonts().remove_all_matching([this](auto const& entry) { return entry == this; });
|
||
if (font_face_set->loading_fonts().is_empty())
|
||
font_face_set->switch_to_loaded();
|
||
}
|
||
}
|
||
|
||
// 2. Otherwise, font face now represents the loaded font; fulfill font face’s [[FontStatusPromise]] with font face
|
||
// and set font face’s status attribute to "loaded".
|
||
else {
|
||
m_parsed_font = maybe_typeface;
|
||
m_status = Bindings::FontFaceLoadStatus::Loaded;
|
||
WebIDL::resolve_promise(realm(), m_font_status_promise, this);
|
||
if (m_css_font_face_rule)
|
||
m_css_font_face_rule->set_loading_state(CSSStyleSheet::LoadingState::Loaded);
|
||
|
||
// For each FontFaceSet font face is in:
|
||
for (auto& font_face_set : m_containing_sets) {
|
||
// 1. Add font face to the FontFaceSet’s [[LoadedFonts]] list.
|
||
font_face_set->loaded_fonts().append(*this);
|
||
|
||
// 2. Remove font face from the FontFaceSet’s [[LoadingFonts]] list. If font was the last item
|
||
// in that list (and so the list is now empty), switch the FontFaceSet to loaded.
|
||
font_face_set->loading_fonts().remove_all_matching([this](auto const& entry) { return entry == this; });
|
||
if (font_face_set->loading_fonts().is_empty())
|
||
font_face_set->switch_to_loaded();
|
||
}
|
||
}
|
||
}));
|
||
});
|
||
|
||
// FIXME: We should probably put the 'font cache' on the WindowOrWorkerGlobalScope instead of tying it to the document's style computer
|
||
auto& global = HTML::relevant_global_object(*this);
|
||
if (auto* window = as_if<HTML::Window>(global)) {
|
||
auto& font_computer = const_cast<FontComputer&>(window->document()->font_computer());
|
||
|
||
if (auto loader = font_computer.load_font_face(parsed_font_face(), move(on_load)))
|
||
loader->start_loading_next_url();
|
||
} else {
|
||
// FIXME: Don't know how to load fonts in workers! They don't have a StyleComputer
|
||
dbgln("FIXME: Worker font loading not implemented");
|
||
}
|
||
}));
|
||
|
||
return font_face.loaded();
|
||
}
|
||
|
||
void FontFace::add_to_set(FontFaceSet& set)
|
||
{
|
||
m_containing_sets.set(set);
|
||
}
|
||
|
||
void FontFace::remove_from_set(FontFaceSet& set)
|
||
{
|
||
m_containing_sets.remove(set);
|
||
}
|
||
|
||
bool font_format_is_supported(FlyString const& name)
|
||
{
|
||
// https://drafts.csswg.org/css-fonts-4/#font-format-definitions
|
||
if (name.equals_ignoring_ascii_case("collection"sv))
|
||
return Gfx::font_format_is_supported(Gfx::FontFormat::TrueTypeCollection);
|
||
if (name.equals_ignoring_ascii_case("embedded-opentype"sv))
|
||
return Gfx::font_format_is_supported(Gfx::FontFormat::EmbeddedOpenType);
|
||
if (name.equals_ignoring_ascii_case("opentype"sv))
|
||
return Gfx::font_format_is_supported(Gfx::FontFormat::OpenType);
|
||
if (name.equals_ignoring_ascii_case("svg"sv))
|
||
return Gfx::font_format_is_supported(Gfx::FontFormat::SVG);
|
||
if (name.equals_ignoring_ascii_case("truetype"sv))
|
||
return Gfx::font_format_is_supported(Gfx::FontFormat::TrueType);
|
||
if (name.equals_ignoring_ascii_case("woff"sv))
|
||
return Gfx::font_format_is_supported(Gfx::FontFormat::WOFF);
|
||
if (name.equals_ignoring_ascii_case("woff2"sv))
|
||
return Gfx::font_format_is_supported(Gfx::FontFormat::WOFF2);
|
||
return false;
|
||
}
|
||
|
||
bool font_tech_is_supported(FontTech font_tech)
|
||
{
|
||
// https://drafts.csswg.org/css-fonts-4/#font-tech-definitions
|
||
switch (font_tech) {
|
||
case FontTech::FeaturesOpentype:
|
||
return Gfx::font_tech_is_supported(Gfx::FontTech::FeaturesOpentype);
|
||
case FontTech::FeaturesAat:
|
||
return Gfx::font_tech_is_supported(Gfx::FontTech::FeaturesAat);
|
||
case FontTech::FeaturesGraphite:
|
||
return Gfx::font_tech_is_supported(Gfx::FontTech::FeaturesGraphite);
|
||
case FontTech::Variations:
|
||
return Gfx::font_tech_is_supported(Gfx::FontTech::Variations);
|
||
case FontTech::ColorColrv0:
|
||
return Gfx::font_tech_is_supported(Gfx::FontTech::ColorColrv0);
|
||
case FontTech::ColorColrv1:
|
||
return Gfx::font_tech_is_supported(Gfx::FontTech::ColorColrv1);
|
||
case FontTech::ColorSvg:
|
||
return Gfx::font_tech_is_supported(Gfx::FontTech::ColorSvg);
|
||
case FontTech::ColorSbix:
|
||
return Gfx::font_tech_is_supported(Gfx::FontTech::ColorSbix);
|
||
case FontTech::ColorCbdt:
|
||
return Gfx::font_tech_is_supported(Gfx::FontTech::ColorCbdt);
|
||
case FontTech::Palettes:
|
||
return Gfx::font_tech_is_supported(Gfx::FontTech::Palettes);
|
||
case FontTech::Incremental:
|
||
return Gfx::font_tech_is_supported(Gfx::FontTech::Incremental);
|
||
// https://drafts.csswg.org/css-fonts-5/#font-tech-definitions
|
||
case FontTech::Avar2:
|
||
return Gfx::font_tech_is_supported(Gfx::FontTech::Avar2);
|
||
}
|
||
return false;
|
||
}
|
||
|
||
bool font_tech_is_supported(FlyString const& name)
|
||
{
|
||
if (auto keyword = keyword_from_string(name); keyword.has_value()) {
|
||
if (auto font_tech = keyword_to_font_tech(*keyword); font_tech.has_value()) {
|
||
return font_tech_is_supported(*font_tech);
|
||
}
|
||
}
|
||
return false;
|
||
}
|
||
|
||
}
|