diff --git a/Libraries/LibWeb/CSS/FontFace.cpp b/Libraries/LibWeb/CSS/FontFace.cpp index 90b32a58101..86d186ea819 100644 --- a/Libraries/LibWeb/CSS/FontFace.cpp +++ b/Libraries/LibWeb/CSS/FontFace.cpp @@ -5,6 +5,7 @@ * SPDX-License-Identifier: BSD-2-Clause */ +#include #include #include #include @@ -66,63 +67,82 @@ GC::Ref 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(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 sources; - ByteBuffer buffer; - if (auto* string = source.get_pointer()) { - 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 parsed_source; + if (auto* source_string = source.get_pointer()) { + 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()) { + font_face->m_urls = ParsedFontFace::sources_from_style_value(*parsed_source); } else { auto buffer_source = source.get>(); 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(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(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 { + font_face->m_font_load_promise->when_resolved([font = GC::make_root(font_face)](auto const& vector_font) -> ErrorOr { 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::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::construct_impl(JS::Realm& realm, String family, Font }); })); - return font; + return font_face; } -FontFace::FontFace(JS::Realm& realm, GC::Ref font_status_promise, Vector urls, ByteBuffer data, String font_family, FontFaceDescriptors const& descriptors) +FontFace::FontFace(JS::Realm& realm, GC::Ref 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(*m_font_status_promise->promise()).state() == JS::Promise::State::Rejected) - m_status = Bindings::FontFaceLoadStatus::Error; } FontFace::~FontFace() = default; @@ -204,6 +203,14 @@ GC::Ref 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 FontFace::set_family(String const& string) { diff --git a/Libraries/LibWeb/CSS/FontFace.h b/Libraries/LibWeb/CSS/FontFace.h index 3f8da2edf9d..97eb4ecc5c5 100644 --- a/Libraries/LibWeb/CSS/FontFace.h +++ b/Libraries/LibWeb/CSS/FontFace.h @@ -80,10 +80,11 @@ public: GC::Ref font_status_promise() { return m_font_status_promise; } private: - FontFace(JS::Realm&, GC::Ref font_status_promise, Vector urls, ByteBuffer data, String family, FontFaceDescriptors const& descriptors); + FontFace(JS::Realm&, GC::Ref 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 m_font_status_promise; // [[FontStatusPromise]] Vector m_urls; // [[Urls]] - ByteBuffer m_binary_data; // [[Data]] + ByteBuffer m_binary_data {}; // [[Data]] RefPtr m_parsed_font; RefPtr>> m_font_load_promise;