Stowage/ladybird
2
0
Fork 0
mirror of https://github.com/LadybirdBrowser/ladybird.git synced 2026-04-18 09:50:27 +00:00
Code Issues Projects Releases Packages Wiki Activity
ladybird/Libraries/LibWeb/CSS/FontFace.cpp
Tim Ledbetter 5b584fde1d LibWeb: Register JS-created FontFace objects for font matching 
Previously, FontFace objects created via the JS and added to
`document.fonts` were stored in the FontFaceSet but never participated
in font matching during style resolution. We now store both
CSS-connected and JS-created font faces in a unified map on
`FontComputer`, keyed by family name, and include them all as
candidates in the font matching algorithm.
2026-04-05 00:13:35 +02:00

875 lines
41 KiB
C++
Raw Permalink Blame History

This file contains ambiguous Unicode characters

This file contains Unicode characters that might be confused with other characters. If you think that this is intentional, you can safely ignore this warning. Use the Escape button to reveal them.

/*
* 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/StyleComputer.h>
#include <LibWeb/CSS/StyleValues/ComputationContext.h>
#include <LibWeb/CSS/StyleValues/CustomIdentStyleValue.h>
#include <LibWeb/CSS/StyleValues/FontStyleStyleValue.h>
#include <LibWeb/CSS/StyleValues/NumberStyleValue.h>
#include <LibWeb/CSS/StyleValues/StringStyleValue.h>
#include <LibWeb/CSS/StyleValues/StyleValueList.h>
#include <LibWeb/CSS/StyleValues/UnicodeRangeStyleValue.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 FontWeightRange compute_weight_range(StyleValue const& value)
{
if (value.to_keyword() == Keyword::Auto || value.to_keyword() == Keyword::Normal)
return { 400, 400 };
auto& weight_values = value.as_value_list().values();
if (weight_values.size() == 1) {
auto one_weight = static_cast<int>(StyleComputer::compute_font_weight(weight_values[0], {})->as_number().number());
return { one_weight, one_weight };
}
if (weight_values.size() == 2) {
auto first = static_cast<int>(StyleComputer::compute_font_weight(weight_values[0], {})->as_number().number());
auto second = static_cast<int>(StyleComputer::compute_font_weight(weight_values[1], {})->as_number().number());
return { min(first, second), max(first, second) };
}
return { 400, 400 };
}
static int compute_slope(StyleValue const& value)
{
if (value.to_keyword() == Keyword::Auto || value.to_keyword() == Keyword::Normal)
return 0;
return StyleComputer::compute_font_style(value)->as_font_style().to_font_slope();
}
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_set_descriptor = [&](DescriptorID descriptor_id, String const& string, auto setter_impl) {
auto result = parse_css_descriptor(parsing_params, AtRuleID::FontFace, DescriptorNameAndID::from_id(descriptor_id), string);
if (!result) {
font_face->reject_status_promise(WebIDL::SyntaxError::create(realm, Utf16String::formatted("FontFace constructor: Invalid {}", to_string(descriptor_id))));
return;
}
(font_face.ptr()->*setter_impl)(result.release_nonnull());
};
try_set_descriptor(DescriptorID::FontFamily, family, &FontFace::set_family_impl);
try_set_descriptor(DescriptorID::FontStyle, descriptors.style, &FontFace::set_style_impl);
try_set_descriptor(DescriptorID::FontWeight, descriptors.weight, &FontFace::set_weight_impl);
try_set_descriptor(DescriptorID::FontWidth, descriptors.stretch, &FontFace::set_stretch_impl);
try_set_descriptor(DescriptorID::UnicodeRange, descriptors.unicode_range, &FontFace::set_unicode_range_impl);
try_set_descriptor(DescriptorID::FontFeatureSettings, descriptors.feature_settings, &FontFace::set_feature_settings_impl);
try_set_descriptor(DescriptorID::FontVariationSettings, descriptors.variation_settings, &FontFace::set_variation_settings_impl);
try_set_descriptor(DescriptorID::FontDisplay, descriptors.display, &FontFace::set_display_impl);
try_set_descriptor(DescriptorID::AscentOverride, descriptors.ascent_override, &FontFace::set_ascent_override_impl);
try_set_descriptor(DescriptorID::DescentOverride, descriptors.descent_override, &FontFace::set_descent_override_impl);
try_set_descriptor(DescriptorID::LineGapOverride, descriptors.line_gap_override, &FontFace::set_line_gap_override_impl);
RefPtr<StyleValue const> parsed_source;
if (auto* source_string = source.get_pointer<String>()) {
parsed_source = parse_css_descriptor(parsing_params, AtRuleID::FontFace, DescriptorNameAndID::from_id(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);
if (auto font_computer = font->font_computer(); font_computer.has_value())
font_computer->register_font_face(*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(DescriptorNameAndID::from_id(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();
ComputationContext computation_context {
.length_resolution_context = Length::ResolutionContext::for_document(*descriptors->parent_rule()->parent_style_sheet()->owning_document())
};
set_family_impl(*descriptors->descriptor(DescriptorNameAndID::from_id(DescriptorID::FontFamily)));
set_style_impl(*descriptors->descriptor_or_initial_value(DescriptorNameAndID::from_id(DescriptorID::FontStyle))->absolutized(computation_context));
set_weight_impl(*descriptors->descriptor_or_initial_value(DescriptorNameAndID::from_id(DescriptorID::FontWeight))->absolutized(computation_context));
set_stretch_impl(*descriptors->descriptor_or_initial_value(DescriptorNameAndID::from_id(DescriptorID::FontWidth)));
set_unicode_range_impl(*descriptors->descriptor_or_initial_value(DescriptorNameAndID::from_id(DescriptorID::UnicodeRange)));
set_feature_settings_impl(*descriptors->descriptor_or_initial_value(DescriptorNameAndID::from_id(DescriptorID::FontFeatureSettings)));
set_variation_settings_impl(*descriptors->descriptor_or_initial_value(DescriptorNameAndID::from_id(DescriptorID::FontVariationSettings)));
set_display_impl(*descriptors->descriptor_or_initial_value(DescriptorNameAndID::from_id(DescriptorID::FontDisplay)));
set_ascent_override_impl(*descriptors->descriptor_or_initial_value(DescriptorNameAndID::from_id(DescriptorID::AscentOverride)));
set_descent_override_impl(*descriptors->descriptor_or_initial_value(DescriptorNameAndID::from_id(DescriptorID::DescentOverride)));
set_line_gap_override_impl(*descriptors->descriptor_or_initial_value(DescriptorNameAndID::from_id(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,
m_cached_weight_range,
m_cached_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);
visitor.visit(m_font_loader);
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;
}
}
Optional<FontComputer&> FontFace::font_computer() const
{
for (auto& font_face_set : m_containing_sets) {
auto& global = HTML::relevant_global_object(font_face_set);
if (auto* window = as_if<HTML::Window>(global))
return window->associated_document().font_computer();
}
return {};
}
void FontFace::disconnect_from_css_rule()
{
m_css_font_face_rule = nullptr;
}
RefPtr<Gfx::FontCascadeList const> FontFace::font_with_point_size(float point_size, Gfx::FontVariationSettings const& variations, Gfx::ShapeFeatures const& shape_features) const
{
auto font_list = Gfx::FontCascadeList::create();
if (m_font_loader) {
if (auto font = m_font_loader->font_with_point_size(point_size, variations, shape_features))
font_list->add(*font, m_font_loader->unicode_ranges());
} else if (m_parsed_font) {
font_list->add(m_parsed_font->font(point_size, variations, shape_features), m_unicode_ranges);
}
if (font_list->is_empty())
return {};
return font_list;
}
// 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, DescriptorNameAndID::from_id(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));
if (should_be_registered_with_font_computer()) {
if (auto font_computer = this->font_computer(); font_computer.has_value())
font_computer->unregister_font_face(*this);
}
set_family_impl(property.release_nonnull());
if (should_be_registered_with_font_computer()) {
if (auto font_computer = this->font_computer(); font_computer.has_value())
font_computer->register_font_face(*this);
}
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, DescriptorNameAndID::from_id(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));
if (should_be_registered_with_font_computer()) {
if (auto font_computer = this->font_computer(); font_computer.has_value())
font_computer->unregister_font_face(*this);
}
set_style_impl(property.release_nonnull());
if (should_be_registered_with_font_computer()) {
if (auto font_computer = this->font_computer(); font_computer.has_value())
font_computer->register_font_face(*this);
}
return {};
}
void FontFace::set_style_impl(NonnullRefPtr<StyleValue const> const& value)
{
m_style = value->to_string(SerializationMode::Normal);
m_cached_slope = compute_slope(*value);
}
// 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, DescriptorNameAndID::from_id(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));
if (should_be_registered_with_font_computer()) {
if (auto font_computer = this->font_computer(); font_computer.has_value())
font_computer->unregister_font_face(*this);
}
set_weight_impl(property.release_nonnull());
if (should_be_registered_with_font_computer()) {
if (auto font_computer = this->font_computer(); font_computer.has_value())
font_computer->register_font_face(*this);
}
return {};
}
void FontFace::set_weight_impl(NonnullRefPtr<StyleValue const> const& value)
{
m_weight = value->to_string(SerializationMode::Normal);
m_cached_weight_range = compute_weight_range(*value);
}
// 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, DescriptorNameAndID::from_id(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());
if (should_be_registered_with_font_computer()) {
if (auto font_computer = this->font_computer(); font_computer.has_value())
font_computer->did_load_font(FlyString(m_family));
}
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, DescriptorNameAndID::from_id(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());
if (should_be_registered_with_font_computer()) {
if (auto font_computer = this->font_computer(); font_computer.has_value())
font_computer->did_load_font(FlyString(m_family));
}
return {};
}
void FontFace::set_unicode_range_impl(NonnullRefPtr<StyleValue const> const& value)
{
m_unicode_range = value->to_string(SerializationMode::Normal);
auto const& ranges = value->as_value_list().values();
m_unicode_ranges.clear_with_capacity();
m_unicode_ranges.ensure_capacity(ranges.size());
for (auto const& range : ranges)
m_unicode_ranges.unchecked_append(range->as_unicode_range().unicode_range());
}
// 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, DescriptorNameAndID::from_id(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, DescriptorNameAndID::from_id(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, DescriptorNameAndID::from_id(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, DescriptorNameAndID::from_id(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, DescriptorNameAndID::from_id(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, DescriptorNameAndID::from_id(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);
if (auto font_computer = this->font_computer(); font_computer.has_value())
font_computer->register_font_face(*this);
// 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();
}
}
m_font_loader = nullptr;
}));
});
// 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))) {
m_font_loader = loader;
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;
}
}
Reference in a new issue View git blame Copy permalink