LibWeb: Separate font computation logic from StyleComputer

Font computation and loading is distinct enough from style computation
that it makes more sense to have this in it's own class.

This will be useful later when we move the font loading process to
`ComputedProperties` in order to respect animated values.

Author: Calme1709

Libraries/LibWeb/CMakeLists.txt

@@ -162,6 +162,7 @@ set(SOURCES
     CSS/EdgeRect.cpp
     CSS/Fetch.cpp
     CSS/Flex.cpp
+    CSS/FontComputer.cpp
     CSS/FontFace.cpp
     CSS/FontFaceSet.cpp
     CSS/Frequency.cpp

Libraries/LibWeb/CSS/CSSStyleSheet.cpp

@@ -11,6 +11,7 @@
 #include <LibWeb/Bindings/Intrinsics.h>
 #include <LibWeb/CSS/CSSImportRule.h>
 #include <LibWeb/CSS/CSSStyleSheet.h>
+#include <LibWeb/CSS/FontComputer.h>
 #include <LibWeb/CSS/Parser/Parser.h>
 #include <LibWeb/CSS/StyleComputer.h>
 #include <LibWeb/CSS/StyleSheetList.h>
@@ -325,7 +326,7 @@ void CSSStyleSheet::add_owning_document_or_shadow_root(DOM::Node& document_or_sh
     // All owning documents or shadow roots must be part of the same document so we only need to load this style
     // sheet's fonts against the document of the first
     if (this->owning_documents_or_shadow_roots().size() == 1)
-        document_or_shadow_root.document().style_computer().load_fonts_from_sheet(*this);
+        document_or_shadow_root.document().font_computer().load_fonts_from_sheet(*this);
 
     for (auto const& import_rule : m_import_rules) {
         if (import_rule->loaded_style_sheet())
@@ -340,7 +341,7 @@ void CSSStyleSheet::remove_owning_document_or_shadow_root(DOM::Node& document_or
     // All owning documents or shadow roots must be part of the same document so we only need to unload this style
     // sheet's fonts once we have none remaining.
     if (this->owning_documents_or_shadow_roots().size() == 0)
-        document_or_shadow_root.document().style_computer().unload_fonts_from_sheet(*this);
+        document_or_shadow_root.document().font_computer().unload_fonts_from_sheet(*this);
 
     for (auto const& import_rule : m_import_rules) {
         if (import_rule->loaded_style_sheet())

Libraries/LibWeb/CSS/FontComputer.cpp

@@ -0,0 +1,124 @@
+/*
+ * Copyright (c) 2018-2025, Andreas Kling <[email protected]>
+ * Copyright (c) 2021, the SerenityOS developers.
+ * Copyright (c) 2021-2025, Sam Atkins <[email protected]>
+ * Copyright (c) 2024, Matthew Olsson <[email protected]>
+ * Copyright (c) 2025, Callum Law <[email protected]>
+ *
+ * SPDX-License-Identifier: BSD-2-Clause
+ */
+
+#include <LibGC/CellAllocator.h>
+#include <LibGfx/FontCascadeList.h>
+#include <LibWeb/Export.h>
+#include <LibWeb/Forward.h>
+
+#pragma once
+
+namespace Web::CSS {
+
+struct FontFaceKey;
+
+struct OwnFontFaceKey {
+    explicit OwnFontFaceKey(FontFaceKey const& other);
+
+    operator FontFaceKey() const;
+
+    [[nodiscard]] u32 hash() const { return pair_int_hash(family_name.hash(), pair_int_hash(weight, slope)); }
+    [[nodiscard]] bool operator==(OwnFontFaceKey const& other) const = default;
+    [[nodiscard]] bool operator==(FontFaceKey const& other) const;
+
+    FlyString family_name;
+    int weight { 0 };
+    int slope { 0 };
+};
+
+struct FontMatchingAlgorithmCacheKey {
+    FlyString family_name;
+    int weight;
+    int slope;
+    float font_size_in_pt;
+
+    [[nodiscard]] bool operator==(FontMatchingAlgorithmCacheKey const& other) const = default;
+};
+
+class FontLoader final : public GC::Cell {
+    GC_CELL(FontLoader, GC::Cell);
+    GC_DECLARE_ALLOCATOR(FontLoader);
+
+public:
+    FontLoader(FontComputer& font_computer, GC::Ptr<CSSStyleSheet> parent_style_sheet, FlyString family_name, Vector<Gfx::UnicodeRange> unicode_ranges, Vector<URL> urls, ESCAPING Function<void(RefPtr<Gfx::Typeface const>)> on_load = {});
+
+    virtual ~FontLoader();
+
+    Vector<Gfx::UnicodeRange> const& unicode_ranges() const { return m_unicode_ranges; }
+    RefPtr<Gfx::Typeface const> vector_font() const { return m_vector_font; }
+
+    RefPtr<Gfx::Font const> font_with_point_size(float point_size, Gfx::FontVariationSettings const& variations = {});
+    void start_loading_next_url();
+
+    bool is_loading() const;
+
+private:
+    virtual void visit_edges(Visitor&) override;
+
+    ErrorOr<NonnullRefPtr<Gfx::Typeface const>> try_load_font(Fetch::Infrastructure::Response const&, ByteBuffer const&);
+
+    void font_did_load_or_fail(RefPtr<Gfx::Typeface const>);
+
+    GC::Ref<FontComputer> m_font_computer;
+    GC::Ptr<CSSStyleSheet> m_parent_style_sheet;
+    FlyString m_family_name;
+    Vector<Gfx::UnicodeRange> m_unicode_ranges;
+    RefPtr<Gfx::Typeface const> m_vector_font;
+    Vector<URL> m_urls;
+    GC::Ptr<Fetch::Infrastructure::FetchController> m_fetch_controller;
+    Function<void(RefPtr<Gfx::Typeface const>)> m_on_load;
+};
+
+class WEB_API FontComputer final : public GC::Cell {
+    GC_CELL(FontComputer, GC::Cell);
+    GC_DECLARE_ALLOCATOR(FontComputer);
+
+public:
+    explicit FontComputer(DOM::Document& document)
+        : m_document(document)
+    {
+    }
+
+    ~FontComputer() = default;
+
+    DOM::Document& document() { return m_document; }
+    DOM::Document const& document() const { return m_document; }
+
+    Gfx::Font const& initial_font() const;
+
+    void did_load_font(FlyString const& family_name);
+
+    GC::Ptr<FontLoader> load_font_face(ParsedFontFace const&, ESCAPING Function<void(RefPtr<Gfx::Typeface const>)> on_load = {});
+
+    void load_fonts_from_sheet(CSSStyleSheet&);
+    void unload_fonts_from_sheet(CSSStyleSheet&);
+
+    RefPtr<Gfx::FontCascadeList const> compute_font_for_style_values(StyleValue const& font_family, CSSPixels const& font_size, int font_slope, double font_weight, Percentage const& font_width, HashMap<FlyString, double> const& font_variation_settings) const;
+
+    size_t number_of_css_font_faces_with_loading_in_progress() const;
+
+private:
+    virtual void visit_edges(Visitor&) override;
+
+    struct MatchingFontCandidate;
+    static RefPtr<Gfx::FontCascadeList const> find_matching_font_weight_ascending(Vector<MatchingFontCandidate> const& candidates, int target_weight, float font_size_in_pt, Gfx::FontVariationSettings const& variations, bool inclusive);
+    static RefPtr<Gfx::FontCascadeList const> find_matching_font_weight_descending(Vector<MatchingFontCandidate> const& candidates, int target_weight, float font_size_in_pt, Gfx::FontVariationSettings const& variations, bool inclusive);
+    RefPtr<Gfx::FontCascadeList const> font_matching_algorithm(FlyString const& family_name, int weight, int slope, float font_size_in_pt) const;
+    RefPtr<Gfx::FontCascadeList const> font_matching_algorithm_impl(FlyString const& family_name, int weight, int slope, float font_size_in_pt) const;
+
+    GC::Ref<DOM::Document> m_document;
+
+    using FontLoaderList = Vector<GC::Ref<FontLoader>>;
+    HashMap<OwnFontFaceKey, FontLoaderList> m_loaded_fonts;
+
+    mutable HashMap<FontMatchingAlgorithmCacheKey, RefPtr<Gfx::FontCascadeList const>> m_font_matching_algorithm_cache;
+};
+
+}

Libraries/LibWeb/CSS/FontComputer.h

@@ -16,9 +16,9 @@
 #include <LibJS/Runtime/Realm.h>
 #include <LibWeb/Bindings/FontFacePrototype.h>
 #include <LibWeb/Bindings/Intrinsics.h>
+#include <LibWeb/CSS/FontComputer.h>
 #include <LibWeb/CSS/FontFace.h>
 #include <LibWeb/CSS/Parser/Parser.h>
-#include <LibWeb/CSS/StyleComputer.h>
 #include <LibWeb/CSS/StyleValues/CustomIdentStyleValue.h>
 #include <LibWeb/HTML/Scripting/TemporaryExecutionContext.h>
 #include <LibWeb/HTML/Window.h>
@@ -483,7 +483,7 @@ GC::Ref<WebIDL::Promise> FontFace::load()
         // 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(*font);
         if (auto* window = as_if<HTML::Window>(global)) {
-            auto& style_computer = const_cast<StyleComputer&>(window->document()->style_computer());
+            auto& font_computer = const_cast<FontComputer&>(window->document()->font_computer());
 
             // FIXME: The ParsedFontFace is kind of expensive to create. We should be using a shared sub-object for the data
             ParsedFontFace parsed_font_face {
@@ -503,7 +503,7 @@ GC::Ref<WebIDL::Promise> FontFace::load()
                 {},                // FIXME: feature_settings
                 {},                // FIXME: variation_settings
             };
-            if (auto loader = style_computer.load_font_face(parsed_font_face, move(on_load)))
+            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

Libraries/LibWeb/CSS/FontFace.cpp

@@ -11,9 +11,9 @@
 #include <LibGfx/Font/Font.h>
 #include <LibGfx/Rect.h>
 #include <LibWeb/CSS/ComputedProperties.h>
+#include <LibWeb/CSS/FontComputer.h>
 #include <LibWeb/CSS/Length.h>
 #include <LibWeb/CSS/Percentage.h>
-#include <LibWeb/CSS/StyleComputer.h>
 #include <LibWeb/DOM/Document.h>
 #include <LibWeb/HTML/BrowsingContext.h>
 #include <LibWeb/HTML/Navigable.h>
@@ -139,7 +139,7 @@ Length::ResolutionContext Length::ResolutionContext::for_element(DOM::AbstractEl
 
 Length::ResolutionContext Length::ResolutionContext::for_window(HTML::Window const& window)
 {
-    auto const& initial_font = window.associated_document().style_computer().initial_font();
+    auto const& initial_font = window.associated_document().font_computer().initial_font();
     Gfx::FontPixelMetrics const& initial_font_metrics = initial_font.pixel_metrics();
     Length::FontMetrics font_metrics { CSSPixels { initial_font.pixel_size() }, initial_font_metrics, InitialValues::line_height() };
     return Length::ResolutionContext {
@@ -151,7 +151,7 @@ Length::ResolutionContext Length::ResolutionContext::for_window(HTML::Window con
 
 Length::ResolutionContext Length::ResolutionContext::for_document(DOM::Document const& document)
 {
-    auto const& initial_font = document.style_computer().initial_font();
+    auto const& initial_font = document.font_computer().initial_font();
     Gfx::FontPixelMetrics const& initial_font_metrics = initial_font.pixel_metrics();
     Length::FontMetrics font_metrics { CSSPixels { initial_font.pixel_size() }, initial_font_metrics, InitialValues::line_height() };
     CSSPixelRect viewport_rect;