mirrors/ladybird
0
0
Fork 0
mirror of https://github.com/LadybirdBrowser/ladybird.git synced 2025-04-22 12:35:14 +00:00
Code Issues Projects Releases Packages Wiki Activity Actions 9

LibWeb/CSS: Parse FontFace parameters as descriptors

Browse source 
This also rearranges the code to follow the spec better: We create an
empty FontFace first and then fill it in, instead of creating it
fully-formed at the end.
This commit is contained in:
Sam Atkins 2025-04-04 15:32:53 +01:00
parent 0383ecaa3d
commit ff491843b6
2 changed files with 65 additions and 57 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

117
Libraries/LibWeb/CSS/FontFace.cpp
View file

@ -5,6 +5,7 @@
* SPDX-License-Identifier: BSD-2-Clause
*/
#include <AK/ByteBuffer.h>
#include <LibCore/Promise.h>
#include <LibGC/Heap.h>
#include <LibGfx/Font/Typeface.h>
@ -66,63 +67,82 @@ GC::Ref<FontFace> FontFace::construct_impl(JS::Realm& realm, String family, Font
// 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 promise = WebIDL::create_promise(realm);
auto font_face = realm.create<FontFace>(realm, WebIDL::create_promise(realm));
// FIXME: Parse the family argument, and the members of the descriptors argument,
// 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.
// 2. (Out of order) 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.
Vector<CSS::ParsedFontFace::Source> sources;
ByteBuffer buffer;
if (auto* string = source.get_pointer<String>()) {
auto parser = CSS::Parser::Parser::create(CSS::Parser::ParsingParams(realm, base_url), *string);
sources = parser.parse_as_font_face_src();
if (sources.is_empty())
WebIDL::reject_promise(realm, promise, WebIDL::SyntaxError::create(realm, "FontFace constructor: Invalid source string"_string));
Parser::ParsingParams parsing_params { realm, base_url };
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, MUST(String::formatted("FontFace constructor: Invalid {}", to_string(descriptor_id)))));
return {};
}
return result->to_string(CSSStyleValue::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<CSSStyleValue> 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, MUST(String::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);
} 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));
WebIDL::reject_promise(realm, promise, throw_completion.value());
font_face->reject_status_promise(throw_completion.value());
} else {
buffer = maybe_buffer.release_value();
font_face->m_binary_data = maybe_buffer.release_value();
}
}
if (buffer.is_empty() && sources.is_empty())
WebIDL::reject_promise(realm, promise, WebIDL::SyntaxError::create(realm, "FontFace constructor: Invalid font source"_string));
auto font = realm.create<FontFace>(realm, promise, move(sources), move(buffer), move(family), descriptors);
// 1. (continued) Return font face. If font face’s status is "error", terminate this algorithm;
// otherwise, complete the rest of these steps asynchronously.
if (font->status() == Bindings::FontFaceLoadStatus::Error)
return font;
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"_string));
// 3. If font face’s [[Data]] slot is not null, queue a task to run the following steps synchronously:
if (font->m_binary_data.is_empty())
return font;
if (font_face->m_binary_data.is_empty())
return font_face;
HTML::queue_global_task(HTML::Task::Source::FontLoading, HTML::relevant_global_object(*font), GC::create_function(vm.heap(), [&realm, font] {
HTML::queue_global_task(HTML::Task::Source::FontLoading, HTML::relevant_global_object(*font_face), GC::create_function(vm.heap(), [&realm, font_face] {
// 1. Set font face’s status attribute to "loading".
font->m_status = Bindings::FontFaceLoadStatus::Loading;
font_face->m_status = Bindings::FontFaceLoadStatus::Loading;
// 2. FIXME: For each FontFaceSet font face is in:
// 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->m_font_load_promise = load_vector_font(realm, font->m_binary_data);
font_face->m_font_load_promise = load_vector_font(realm, font_face->m_binary_data);
font->m_font_load_promise->when_resolved([font = GC::make_root(font)](auto const& vector_font) -> ErrorOr<void> {
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;
@ -139,13 +159,12 @@ GC::Ref<FontFace> FontFace::construct_impl(JS::Realm& realm, String family, Font
}));
return {};
});
font->m_font_load_promise->when_rejected([font = GC::make_root(font)](auto const& error) {
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->m_status = Bindings::FontFaceLoadStatus::Error;
WebIDL::reject_promise(font->realm(), font->m_font_status_promise, WebIDL::SyntaxError::create(font->realm(), MUST(String::formatted("Failed to load font: {}", error))));
font->reject_status_promise(WebIDL::SyntaxError::create(font->realm(), MUST(String::formatted("Failed to load font: {}", error))));
// FIXME: For each FontFaceSet font face is in:
@ -154,33 +173,13 @@ GC::Ref<FontFace> FontFace::construct_impl(JS::Realm& realm, String family, Font
});
}));
return font;
return font_face;
}
FontFace::FontFace(JS::Realm& realm, GC::Ref<WebIDL::Promise> font_status_promise, Vector<ParsedFontFace::Source> urls, ByteBuffer data, String font_family, FontFaceDescriptors const& descriptors)
FontFace::FontFace(JS::Realm& realm, GC::Ref<WebIDL::Promise> font_status_promise)
: Bindings::PlatformObject(realm)
, m_font_status_promise(font_status_promise)
, m_urls(move(urls))
, m_binary_data(move(data))
{
m_family = move(font_family);
m_style = descriptors.style;
m_weight = descriptors.weight;
m_stretch = descriptors.stretch;
m_unicode_range = descriptors.unicode_range;
m_feature_settings = descriptors.feature_settings;
m_variation_settings = descriptors.variation_settings;
m_display = descriptors.display;
m_ascent_override = descriptors.ascent_override;
m_descent_override = descriptors.descent_override;
m_line_gap_override = descriptors.line_gap_override;
// FIXME: Parse from descriptor
// FIXME: Have gettter reflect this member instead of the string
m_unicode_ranges.empend(0x0u, 0x10FFFFu);
if (as<JS::Promise>(*m_font_status_promise->promise()).state() == JS::Promise::State::Rejected)
m_status = Bindings::FontFaceLoadStatus::Error;
}
FontFace::~FontFace() = default;
@ -204,6 +203,14 @@ 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);
m_status = Bindings::FontFaceLoadStatus::Error;
}
}
// https://drafts.csswg.org/css-font-loading/#dom-fontface-family
WebIDL::ExceptionOr<void> FontFace::set_family(String const& string)
{

5
Libraries/LibWeb/CSS/FontFace.h
View file

@ -80,10 +80,11 @@ public:
GC::Ref<WebIDL::Promise> font_status_promise() { return m_font_status_promise; }
private:
FontFace(JS::Realm&, GC::Ref<WebIDL::Promise> font_status_promise, Vector<ParsedFontFace::Source> urls, ByteBuffer data, String family, FontFaceDescriptors const& descriptors);
FontFace(JS::Realm&, GC::Ref<WebIDL::Promise> font_status_promise);
virtual void initialize(JS::Realm&) override;
virtual void visit_edges(Visitor&) override;
void reject_status_promise(JS::Value reason);
// FIXME: Should we be storing StyleValues instead?
String m_family;
@ -104,7 +105,7 @@ private:
GC::Ref<WebIDL::Promise> m_font_status_promise; // [[FontStatusPromise]]
Vector<ParsedFontFace::Source> m_urls; // [[Urls]]
ByteBuffer m_binary_data; // [[Data]]
ByteBuffer m_binary_data {}; // [[Data]]
RefPtr<Gfx::Typeface> m_parsed_font;
RefPtr<Core::Promise<NonnullRefPtr<Gfx::Typeface>>> m_font_load_promise;