From afa95c2815a71e5974eb6b09e0f5a5387cce3d7f Mon Sep 17 00:00:00 2001
From: Callum Law <callumlaw1709@outlook.com>
Date: Wed, 2 Jul 2025 19:12:33 +1200
Subject: [PATCH] LibWeb: Mark `CalculatedStyleValue::resolve_*` methods as
 deprecated

The existing resolve methods are not to spec and we are working to
replace them with new ones based on the `simplify_a_calculation_tree`
method.

These are marked as deprecated rather than replaced outright as work
will need to be done on the caller side to be made compatible with the
new methods, for instance the new methods can fail to resolve (e.g.
if we are missing required context), where the existing methods will
always resolve (albeit sometimes with an incorrect value).

No functionality changes.
---
 Libraries/LibWeb/CSS/Angle.cpp                 |  2 +-
 Libraries/LibWeb/CSS/CSSStyleValue.cpp         |  2 +-
 Libraries/LibWeb/CSS/CalculatedOr.cpp          | 18 +++++++++---------
 Libraries/LibWeb/CSS/ComputedProperties.cpp    | 18 +++++++++---------
 Libraries/LibWeb/CSS/Frequency.cpp             |  2 +-
 Libraries/LibWeb/CSS/Length.cpp                |  4 ++--
 Libraries/LibWeb/CSS/ParsedFontFace.cpp        |  6 +++---
 .../LibWeb/CSS/Parser/DescriptorParsing.cpp    |  2 +-
 .../LibWeb/CSS/Parser/PropertyParsing.cpp      |  2 +-
 Libraries/LibWeb/CSS/Parser/ValueParsing.cpp   |  2 +-
 Libraries/LibWeb/CSS/StyleComputer.cpp         |  4 ++--
 .../LibWeb/CSS/StyleValues/CSSColorValue.cpp   | 13 ++++++-------
 Libraries/LibWeb/CSS/StyleValues/CSSRGB.cpp    |  4 ++--
 .../CSS/StyleValues/CalculatedStyleValue.cpp   | 18 +++++++++---------
 .../CSS/StyleValues/CalculatedStyleValue.h     | 18 +++++++++---------
 .../StyleValues/ColorFunctionStyleValue.cpp    |  4 ++--
 .../StyleValues/FilterValueListStyleValue.cpp  |  4 ++--
 .../StyleValues/TransformationStyleValue.cpp   |  2 +-
 Libraries/LibWeb/CSS/Time.cpp                  |  2 +-
 Libraries/LibWeb/CSS/Transformation.cpp        |  6 +++---
 Libraries/LibWeb/Layout/LayoutState.cpp        |  2 +-
 Libraries/LibWeb/Layout/Node.cpp               |  4 ++--
 22 files changed, 69 insertions(+), 70 deletions(-)

diff --git a/Libraries/LibWeb/CSS/Angle.cpp b/Libraries/LibWeb/CSS/Angle.cpp
index 5985313364e..219658b4dc9 100644
--- a/Libraries/LibWeb/CSS/Angle.cpp
+++ b/Libraries/LibWeb/CSS/Angle.cpp
@@ -88,7 +88,7 @@ Optional<Angle::Type> Angle::unit_from_name(StringView name)
 
 Angle Angle::resolve_calculated(NonnullRefPtr<CalculatedStyleValue const> const& calculated, Layout::Node const& layout_node, Angle const& reference_value)
 {
-    return calculated->resolve_angle(
+    return calculated->resolve_angle_deprecated(
                          {
                              .percentage_basis = reference_value,
                              .length_resolution_context = Length::ResolutionContext::for_layout_node(layout_node),
diff --git a/Libraries/LibWeb/CSS/CSSStyleValue.cpp b/Libraries/LibWeb/CSS/CSSStyleValue.cpp
index 7a0c8119edb..a86a6a39fc7 100644
--- a/Libraries/LibWeb/CSS/CSSStyleValue.cpp
+++ b/Libraries/LibWeb/CSS/CSSStyleValue.cpp
@@ -450,7 +450,7 @@ int CSSStyleValue::to_font_weight() const
         return round_to<int>(as_number().number());
     }
     if (is_calculated()) {
-        auto maybe_weight = as_calculated().resolve_integer({});
+        auto maybe_weight = as_calculated().resolve_integer_deprecated({});
         if (maybe_weight.has_value())
             return maybe_weight.value();
     }
diff --git a/Libraries/LibWeb/CSS/CalculatedOr.cpp b/Libraries/LibWeb/CSS/CalculatedOr.cpp
index ec21a2bb467..99ce172162b 100644
--- a/Libraries/LibWeb/CSS/CalculatedOr.cpp
+++ b/Libraries/LibWeb/CSS/CalculatedOr.cpp
@@ -19,7 +19,7 @@ namespace Web::CSS {
 
 Optional<Angle> AngleOrCalculated::resolve_calculated(NonnullRefPtr<CalculatedStyleValue const> const& calculated, CalculationResolutionContext const& context) const
 {
-    return calculated->resolve_angle(context);
+    return calculated->resolve_angle_deprecated(context);
 }
 
 NonnullRefPtr<CSSStyleValue const> AngleOrCalculated::create_style_value() const
@@ -29,7 +29,7 @@ NonnullRefPtr<CSSStyleValue const> AngleOrCalculated::create_style_value() const
 
 Optional<Flex> FlexOrCalculated::resolve_calculated(NonnullRefPtr<CalculatedStyleValue const> const& calculated, CalculationResolutionContext const& context) const
 {
-    return calculated->resolve_flex(context);
+    return calculated->resolve_flex_deprecated(context);
 }
 
 NonnullRefPtr<CSSStyleValue const> FlexOrCalculated::create_style_value() const
@@ -39,7 +39,7 @@ NonnullRefPtr<CSSStyleValue const> FlexOrCalculated::create_style_value() const
 
 Optional<Frequency> FrequencyOrCalculated::resolve_calculated(NonnullRefPtr<CalculatedStyleValue const> const& calculated, CalculationResolutionContext const& context) const
 {
-    return calculated->resolve_frequency(context);
+    return calculated->resolve_frequency_deprecated(context);
 }
 
 NonnullRefPtr<CSSStyleValue const> FrequencyOrCalculated::create_style_value() const
@@ -49,7 +49,7 @@ NonnullRefPtr<CSSStyleValue const> FrequencyOrCalculated::create_style_value() c
 
 Optional<i64> IntegerOrCalculated::resolve_calculated(NonnullRefPtr<CalculatedStyleValue const> const& calculated, CalculationResolutionContext const& context) const
 {
-    return calculated->resolve_integer(context);
+    return calculated->resolve_integer_deprecated(context);
 }
 
 NonnullRefPtr<CSSStyleValue const> IntegerOrCalculated::create_style_value() const
@@ -59,7 +59,7 @@ NonnullRefPtr<CSSStyleValue const> IntegerOrCalculated::create_style_value() con
 
 Optional<Length> LengthOrCalculated::resolve_calculated(NonnullRefPtr<CalculatedStyleValue const> const& calculated, CalculationResolutionContext const& context) const
 {
-    return calculated->resolve_length(context);
+    return calculated->resolve_length_deprecated(context);
 }
 
 NonnullRefPtr<CSSStyleValue const> LengthOrCalculated::create_style_value() const
@@ -69,7 +69,7 @@ NonnullRefPtr<CSSStyleValue const> LengthOrCalculated::create_style_value() cons
 
 Optional<double> NumberOrCalculated::resolve_calculated(NonnullRefPtr<CalculatedStyleValue const> const& calculated, CalculationResolutionContext const& context) const
 {
-    return calculated->resolve_number(context);
+    return calculated->resolve_number_deprecated(context);
 }
 
 NonnullRefPtr<CSSStyleValue const> NumberOrCalculated::create_style_value() const
@@ -79,7 +79,7 @@ NonnullRefPtr<CSSStyleValue const> NumberOrCalculated::create_style_value() cons
 
 Optional<Percentage> PercentageOrCalculated::resolve_calculated(NonnullRefPtr<CalculatedStyleValue const> const& calculated, CalculationResolutionContext const& context) const
 {
-    return calculated->resolve_percentage(context);
+    return calculated->resolve_percentage_deprecated(context);
 }
 
 NonnullRefPtr<CSSStyleValue const> PercentageOrCalculated::create_style_value() const
@@ -89,7 +89,7 @@ NonnullRefPtr<CSSStyleValue const> PercentageOrCalculated::create_style_value()
 
 Optional<Resolution> ResolutionOrCalculated::resolve_calculated(NonnullRefPtr<CalculatedStyleValue const> const& calculated, CalculationResolutionContext const& context) const
 {
-    return calculated->resolve_resolution(context);
+    return calculated->resolve_resolution_deprecated(context);
 }
 
 NonnullRefPtr<CSSStyleValue const> ResolutionOrCalculated::create_style_value() const
@@ -99,7 +99,7 @@ NonnullRefPtr<CSSStyleValue const> ResolutionOrCalculated::create_style_value()
 
 Optional<Time> TimeOrCalculated::resolve_calculated(NonnullRefPtr<CalculatedStyleValue const> const& calculated, CalculationResolutionContext const& context) const
 {
-    return calculated->resolve_time(context);
+    return calculated->resolve_time_deprecated(context);
 }
 
 NonnullRefPtr<CSSStyleValue const> TimeOrCalculated::create_style_value() const
diff --git a/Libraries/LibWeb/CSS/ComputedProperties.cpp b/Libraries/LibWeb/CSS/ComputedProperties.cpp
index 49988d84c1a..89fcae0c53f 100644
--- a/Libraries/LibWeb/CSS/ComputedProperties.cpp
+++ b/Libraries/LibWeb/CSS/ComputedProperties.cpp
@@ -309,7 +309,7 @@ CSSPixels ComputedProperties::compute_line_height(CSSPixelRect const& viewport_r
             .length_resolution_context = Length::ResolutionContext { viewport_rect, font_metrics, root_font_metrics },
         };
         if (line_height.as_calculated().resolves_to_number()) {
-            auto resolved = line_height.as_calculated().resolve_number(context);
+            auto resolved = line_height.as_calculated().resolve_number_deprecated(context);
             if (!resolved.has_value()) {
                 dbgln("FIXME: Failed to resolve calc() line-height (number): {}", line_height.as_calculated().to_string(SerializationMode::Normal));
                 return CSSPixels::nearest_value_for(m_font_list->first().pixel_metrics().line_spacing());
@@ -317,7 +317,7 @@ CSSPixels ComputedProperties::compute_line_height(CSSPixelRect const& viewport_r
             return Length(resolved.value(), Length::Type::Em).to_px(viewport_rect, font_metrics, root_font_metrics);
         }
 
-        auto resolved = line_height.as_calculated().resolve_length(context);
+        auto resolved = line_height.as_calculated().resolve_length_deprecated(context);
         if (!resolved.has_value()) {
             dbgln("FIXME: Failed to resolve calc() line-height: {}", line_height.as_calculated().to_string(SerializationMode::Normal));
             return CSSPixels::nearest_value_for(m_font_list->first().pixel_metrics().line_spacing());
@@ -347,7 +347,7 @@ Optional<int> ComputedProperties::z_index() const
         return clamp(value.as_integer().integer());
     }
     if (value.is_calculated()) {
-        auto maybe_double = value.as_calculated().resolve_number({});
+        auto maybe_double = value.as_calculated().resolve_number_deprecated({});
         if (maybe_double.has_value()) {
             return clamp(maybe_double.value());
         }
@@ -365,13 +365,13 @@ float ComputedProperties::resolve_opacity_value(CSSStyleValue const& value)
         auto const& calculated = value.as_calculated();
         CalculationResolutionContext context {};
         if (calculated.resolves_to_percentage()) {
-            auto maybe_percentage = value.as_calculated().resolve_percentage(context);
+            auto maybe_percentage = value.as_calculated().resolve_percentage_deprecated(context);
             if (maybe_percentage.has_value())
                 unclamped_opacity = maybe_percentage->as_fraction();
             else
                 dbgln("Unable to resolve calc() as opacity (percentage): {}", value.to_string(SerializationMode::Normal));
         } else if (calculated.resolves_to_number()) {
-            auto maybe_number = value.as_calculated().resolve_number(context);
+            auto maybe_number = value.as_calculated().resolve_number_deprecated(context);
             if (maybe_number.has_value())
                 unclamped_opacity = maybe_number.value();
             else
@@ -517,7 +517,7 @@ Length ComputedProperties::border_spacing_horizontal(Layout::Node const& layout_
         if (style_value.is_length())
             return style_value.as_length().length();
         if (style_value.is_calculated())
-            return style_value.as_calculated().resolve_length({ .length_resolution_context = Length::ResolutionContext::for_layout_node(layout_node) }).value_or(Length(0, Length::Type::Px));
+            return style_value.as_calculated().resolve_length_deprecated({ .length_resolution_context = Length::ResolutionContext::for_layout_node(layout_node) }).value_or(Length(0, Length::Type::Px));
         return {};
     };
 
@@ -539,7 +539,7 @@ Length ComputedProperties::border_spacing_vertical(Layout::Node const& layout_no
         if (style_value.is_length())
             return style_value.as_length().length();
         if (style_value.is_calculated())
-            return style_value.as_calculated().resolve_length({ .length_resolution_context = Length::ResolutionContext::for_layout_node(layout_node) }).value_or(Length(0, Length::Type::Px));
+            return style_value.as_calculated().resolve_length_deprecated({ .length_resolution_context = Length::ResolutionContext::for_layout_node(layout_node) }).value_or(Length(0, Length::Type::Px));
         return {};
     };
 
@@ -1181,7 +1181,7 @@ Vector<ShadowData> ComputedProperties::shadow(PropertyID property_id, Layout::No
         if (value->is_length())
             return value->as_length().length();
         if (value->is_calculated())
-            return value->as_calculated().resolve_length({ .length_resolution_context = Length::ResolutionContext::for_layout_node(layout_node) });
+            return value->as_calculated().resolve_length_deprecated({ .length_resolution_context = Length::ResolutionContext::for_layout_node(layout_node) });
         return {};
     };
 
@@ -1883,7 +1883,7 @@ Vector<CounterData> ComputedProperties::counter_data(PropertyID property_id) con
                 if (counter.value->is_integer()) {
                     data.value = AK::clamp_to<i32>(counter.value->as_integer().integer());
                 } else if (counter.value->is_calculated()) {
-                    auto maybe_int = counter.value->as_calculated().resolve_integer({});
+                    auto maybe_int = counter.value->as_calculated().resolve_integer_deprecated({});
                     if (maybe_int.has_value())
                         data.value = AK::clamp_to<i32>(*maybe_int);
                 } else {
diff --git a/Libraries/LibWeb/CSS/Frequency.cpp b/Libraries/LibWeb/CSS/Frequency.cpp
index c50f8a60cab..17b1f1c7250 100644
--- a/Libraries/LibWeb/CSS/Frequency.cpp
+++ b/Libraries/LibWeb/CSS/Frequency.cpp
@@ -67,7 +67,7 @@ Optional<Frequency::Type> Frequency::unit_from_name(StringView name)
 
 Frequency Frequency::resolve_calculated(NonnullRefPtr<CalculatedStyleValue const> const& calculated, Layout::Node const& layout_node, Frequency const& reference_value)
 {
-    return calculated->resolve_frequency(
+    return calculated->resolve_frequency_deprecated(
                          {
                              .percentage_basis = reference_value,
                              .length_resolution_context = Length::ResolutionContext::for_layout_node(layout_node),
diff --git a/Libraries/LibWeb/CSS/Length.cpp b/Libraries/LibWeb/CSS/Length.cpp
index f93a5ca1641..158a065e30c 100644
--- a/Libraries/LibWeb/CSS/Length.cpp
+++ b/Libraries/LibWeb/CSS/Length.cpp
@@ -423,7 +423,7 @@ Length Length::absolutized(CSSPixelRect const& viewport_rect, FontMetrics const&
 
 Length Length::resolve_calculated(NonnullRefPtr<CalculatedStyleValue const> const& calculated, Layout::Node const& layout_node, Length const& reference_value)
 {
-    return calculated->resolve_length(
+    return calculated->resolve_length_deprecated(
                          {
                              .percentage_basis = reference_value,
                              .length_resolution_context = ResolutionContext::for_layout_node(layout_node),
@@ -433,7 +433,7 @@ Length Length::resolve_calculated(NonnullRefPtr<CalculatedStyleValue const> cons
 
 Length Length::resolve_calculated(NonnullRefPtr<CalculatedStyleValue const> const& calculated, Layout::Node const& layout_node, CSSPixels reference_value)
 {
-    return calculated->resolve_length(
+    return calculated->resolve_length_deprecated(
                          {
                              .percentage_basis = make_px(reference_value),
                              .length_resolution_context = ResolutionContext::for_layout_node(layout_node),
diff --git a/Libraries/LibWeb/CSS/ParsedFontFace.cpp b/Libraries/LibWeb/CSS/ParsedFontFace.cpp
index cbc6766e872..26f2776625e 100644
--- a/Libraries/LibWeb/CSS/ParsedFontFace.cpp
+++ b/Libraries/LibWeb/CSS/ParsedFontFace.cpp
@@ -60,7 +60,7 @@ ParsedFontFace ParsedFontFace::from_descriptors(CSSFontFaceDescriptors const& de
             return value.as_percentage().percentage();
         if (value.is_calculated()) {
             // FIXME: These should probably be simplified already?
-            return value.as_calculated().resolve_percentage({});
+            return value.as_calculated().resolve_percentage_deprecated({});
         }
         if (value.to_keyword() == Keyword::Normal)
             return {};
@@ -139,7 +139,7 @@ ParsedFontFace ParsedFontFace::from_descriptors(CSSFontFaceDescriptors const& de
                 if (setting_value->is_integer()) {
                     settings.set(feature_tag->as_open_type_tagged().tag(), setting_value->as_integer().integer());
                 } else if (setting_value->is_calculated() && setting_value->as_calculated().resolves_to_number()) {
-                    if (auto integer = setting_value->as_calculated().resolve_integer({}); integer.has_value()) {
+                    if (auto integer = setting_value->as_calculated().resolve_integer_deprecated({}); integer.has_value()) {
                         settings.set(feature_tag->as_open_type_tagged().tag(), *integer);
                     }
                 }
@@ -161,7 +161,7 @@ ParsedFontFace ParsedFontFace::from_descriptors(CSSFontFaceDescriptors const& de
                 if (setting_value->is_number()) {
                     settings.set(variation_tag->as_open_type_tagged().tag(), setting_value->as_number().number());
                 } else if (setting_value->is_calculated() && setting_value->as_calculated().resolves_to_number()) {
-                    if (auto number = setting_value->as_calculated().resolve_number({}); number.has_value()) {
+                    if (auto number = setting_value->as_calculated().resolve_number_deprecated({}); number.has_value()) {
                         settings.set(variation_tag->as_open_type_tagged().tag(), *number);
                     }
                 }
diff --git a/Libraries/LibWeb/CSS/Parser/DescriptorParsing.cpp b/Libraries/LibWeb/CSS/Parser/DescriptorParsing.cpp
index bdf50d7c9b2..49a4cd57e0a 100644
--- a/Libraries/LibWeb/CSS/Parser/DescriptorParsing.cpp
+++ b/Libraries/LibWeb/CSS/Parser/DescriptorParsing.cpp
@@ -188,7 +188,7 @@ Parser::ParseErrorOr<NonnullRefPtr<CSSStyleValue const>> Parser::parse_descripto
                         }
                         // All calculations in descriptors must be resolvable at parse-time.
                         if (percentage_value->is_calculated()) {
-                            auto percentage = percentage_value->as_calculated().resolve_percentage({});
+                            auto percentage = percentage_value->as_calculated().resolve_percentage_deprecated({});
                             if (percentage.has_value() && percentage->value() >= 0)
                                 return PercentageStyleValue::create(percentage.release_value());
                             return nullptr;
diff --git a/Libraries/LibWeb/CSS/Parser/PropertyParsing.cpp b/Libraries/LibWeb/CSS/Parser/PropertyParsing.cpp
index 3d34b152837..1a50a8cac50 100644
--- a/Libraries/LibWeb/CSS/Parser/PropertyParsing.cpp
+++ b/Libraries/LibWeb/CSS/Parser/PropertyParsing.cpp
@@ -3629,7 +3629,7 @@ RefPtr<CSSStyleValue const> Parser::parse_opacity_value(PropertyID property_id,
     if (value->is_percentage())
         value = NumberStyleValue::create(value->as_percentage().percentage().as_fraction());
     if (value->is_calculated() && value->as_calculated().resolves_to_percentage()) {
-        auto maybe_percentage = value->as_calculated().resolve_percentage({});
+        auto maybe_percentage = value->as_calculated().resolve_percentage_deprecated({});
         if (maybe_percentage.has_value()) {
             auto resolved_percentage = maybe_percentage->as_fraction();
             CalculationContext context {};
diff --git a/Libraries/LibWeb/CSS/Parser/ValueParsing.cpp b/Libraries/LibWeb/CSS/Parser/ValueParsing.cpp
index 0103dc4b240..a27f6018b03 100644
--- a/Libraries/LibWeb/CSS/Parser/ValueParsing.cpp
+++ b/Libraries/LibWeb/CSS/Parser/ValueParsing.cpp
@@ -363,7 +363,7 @@ Optional<Ratio> Parser::parse_ratio(TokenStream<ComponentValue>& tokens)
                 return maybe_calc->as_number().value();
             if (!maybe_calc->is_calculated() || !maybe_calc->as_calculated().resolves_to_number())
                 return {};
-            if (auto resolved_number = maybe_calc->as_calculated().resolve_number({}); resolved_number.has_value() && resolved_number.value() >= 0) {
+            if (auto resolved_number = maybe_calc->as_calculated().resolve_number_deprecated({}); resolved_number.has_value() && resolved_number.value() >= 0) {
                 return resolved_number.value();
             }
         }
diff --git a/Libraries/LibWeb/CSS/StyleComputer.cpp b/Libraries/LibWeb/CSS/StyleComputer.cpp
index 47331d0a3f6..d05e84738d8 100644
--- a/Libraries/LibWeb/CSS/StyleComputer.cpp
+++ b/Libraries/LibWeb/CSS/StyleComputer.cpp
@@ -1972,7 +1972,7 @@ RefPtr<Gfx::FontCascadeList const> StyleComputer::compute_font_for_style_values(
         } else if (font_size.is_length()) {
             maybe_length = font_size.as_length().length();
         } else if (font_size.is_calculated()) {
-            maybe_length = font_size.as_calculated().resolve_length({
+            maybe_length = font_size.as_calculated().resolve_length_deprecated({
                 .percentage_basis = Length::make_px(parent_font_size),
                 .length_resolution_context = length_resolution_context,
             });
@@ -3196,7 +3196,7 @@ void StyleComputer::compute_math_depth(ComputedProperties& style, DOM::Element c
         if (integer_value.is_integer())
             return integer_value.as_integer().integer();
         if (integer_value.is_calculated())
-            return integer_value.as_calculated().resolve_integer({}).value();
+            return integer_value.as_calculated().resolve_integer_deprecated({}).value();
         VERIFY_NOT_REACHED();
     };
 
diff --git a/Libraries/LibWeb/CSS/StyleValues/CSSColorValue.cpp b/Libraries/LibWeb/CSS/StyleValues/CSSColorValue.cpp
index 2279c828d64..4822f04ffe5 100644
--- a/Libraries/LibWeb/CSS/StyleValues/CSSColorValue.cpp
+++ b/Libraries/LibWeb/CSS/StyleValues/CSSColorValue.cpp
@@ -53,12 +53,11 @@ Optional<double> CSSColorValue::resolve_hue(CSSStyleValue const& style_value, Ca
 
     if (style_value.is_calculated()) {
         if (style_value.as_calculated().resolves_to_number())
-            return normalized(style_value.as_calculated().resolve_number(resolution_context).value());
+            return normalized(style_value.as_calculated().resolve_number_deprecated(resolution_context).value());
 
         if (style_value.as_calculated().resolves_to_angle())
-            return normalized(style_value.as_calculated().resolve_angle(resolution_context).value().to_degrees());
+            return normalized(style_value.as_calculated().resolve_angle_deprecated(resolution_context).value().to_degrees());
     }
-
     if (style_value.is_keyword() && style_value.to_keyword() == Keyword::None)
         return 0;
 
@@ -81,9 +80,9 @@ Optional<double> CSSColorValue::resolve_with_reference_value(CSSStyleValue const
     if (style_value.is_calculated()) {
         auto const& calculated = style_value.as_calculated();
         if (calculated.resolves_to_number())
-            return calculated.resolve_number(resolution_context).value();
+            return calculated.resolve_number_deprecated(resolution_context).value();
         if (calculated.resolves_to_percentage())
-            return normalize_percentage(calculated.resolve_percentage(resolution_context).value());
+            return normalize_percentage(calculated.resolve_percentage_deprecated(resolution_context).value());
     }
 
     if (style_value.is_keyword() && style_value.to_keyword() == Keyword::None)
@@ -110,9 +109,9 @@ Optional<double> CSSColorValue::resolve_alpha(CSSStyleValue const& style_value,
     if (style_value.is_calculated()) {
         auto const& calculated = style_value.as_calculated();
         if (calculated.resolves_to_number())
-            return normalized(calculated.resolve_number(resolution_context).value());
+            return normalized(calculated.resolve_number_deprecated(resolution_context).value());
         if (calculated.resolves_to_percentage())
-            return normalized(calculated.resolve_percentage(resolution_context).value().as_fraction());
+            return normalized(calculated.resolve_percentage_deprecated(resolution_context).value().as_fraction());
     }
 
     if (style_value.is_keyword() && style_value.to_keyword() == Keyword::None)
diff --git a/Libraries/LibWeb/CSS/StyleValues/CSSRGB.cpp b/Libraries/LibWeb/CSS/StyleValues/CSSRGB.cpp
index 74eac2e7404..0b094cc8983 100644
--- a/Libraries/LibWeb/CSS/StyleValues/CSSRGB.cpp
+++ b/Libraries/LibWeb/CSS/StyleValues/CSSRGB.cpp
@@ -33,9 +33,9 @@ Color CSSRGB::to_color(Optional<Layout::NodeWithStyle const&>, CalculationResolu
         if (style_value.is_calculated()) {
             auto const& calculated = style_value.as_calculated();
             if (calculated.resolves_to_number())
-                return normalized(calculated.resolve_number(resolution_context).value());
+                return normalized(calculated.resolve_number_deprecated(resolution_context).value());
             if (calculated.resolves_to_percentage())
-                return normalized(calculated.resolve_percentage(resolution_context).value().value() * 255 / 100);
+                return normalized(calculated.resolve_percentage_deprecated(resolution_context).value().value() * 255 / 100);
         }
 
         if (style_value.is_keyword() && style_value.to_keyword() == Keyword::None)
diff --git a/Libraries/LibWeb/CSS/StyleValues/CalculatedStyleValue.cpp b/Libraries/LibWeb/CSS/StyleValues/CalculatedStyleValue.cpp
index 9c0ba4fc917..bf10fc0e5ad 100644
--- a/Libraries/LibWeb/CSS/StyleValues/CalculatedStyleValue.cpp
+++ b/Libraries/LibWeb/CSS/StyleValues/CalculatedStyleValue.cpp
@@ -2669,7 +2669,7 @@ bool CalculatedStyleValue::equals(CSSStyleValue const& other) const
     return m_calculation->equals(*other.as_calculated().m_calculation);
 }
 
-Optional<Angle> CalculatedStyleValue::resolve_angle(CalculationResolutionContext const& context) const
+Optional<Angle> CalculatedStyleValue::resolve_angle_deprecated(CalculationResolutionContext const& context) const
 {
     auto result = m_calculation->resolve(context);
     if (result.type().has_value() && result.type()->matches_angle(m_context.percentages_resolve_as))
@@ -2677,7 +2677,7 @@ Optional<Angle> CalculatedStyleValue::resolve_angle(CalculationResolutionContext
     return {};
 }
 
-Optional<Flex> CalculatedStyleValue::resolve_flex(CalculationResolutionContext const& context) const
+Optional<Flex> CalculatedStyleValue::resolve_flex_deprecated(CalculationResolutionContext const& context) const
 {
     auto result = m_calculation->resolve(context);
     if (result.type().has_value() && result.type()->matches_flex(m_context.percentages_resolve_as))
@@ -2685,7 +2685,7 @@ Optional<Flex> CalculatedStyleValue::resolve_flex(CalculationResolutionContext c
     return {};
 }
 
-Optional<Frequency> CalculatedStyleValue::resolve_frequency(CalculationResolutionContext const& context) const
+Optional<Frequency> CalculatedStyleValue::resolve_frequency_deprecated(CalculationResolutionContext const& context) const
 {
     auto result = m_calculation->resolve(context);
     if (result.type().has_value() && result.type()->matches_frequency(m_context.percentages_resolve_as))
@@ -2693,7 +2693,7 @@ Optional<Frequency> CalculatedStyleValue::resolve_frequency(CalculationResolutio
     return {};
 }
 
-Optional<Length> CalculatedStyleValue::resolve_length(CalculationResolutionContext const& context) const
+Optional<Length> CalculatedStyleValue::resolve_length_deprecated(CalculationResolutionContext const& context) const
 {
     auto result = m_calculation->resolve(context);
     if (result.type().has_value() && result.type()->matches_length(m_context.percentages_resolve_as))
@@ -2701,7 +2701,7 @@ Optional<Length> CalculatedStyleValue::resolve_length(CalculationResolutionConte
     return {};
 }
 
-Optional<Percentage> CalculatedStyleValue::resolve_percentage(CalculationResolutionContext const& context) const
+Optional<Percentage> CalculatedStyleValue::resolve_percentage_deprecated(CalculationResolutionContext const& context) const
 {
     auto result = m_calculation->resolve(context);
     if (result.type().has_value() && result.type()->matches_percentage())
@@ -2709,7 +2709,7 @@ Optional<Percentage> CalculatedStyleValue::resolve_percentage(CalculationResolut
     return {};
 }
 
-Optional<Resolution> CalculatedStyleValue::resolve_resolution(CalculationResolutionContext const& context) const
+Optional<Resolution> CalculatedStyleValue::resolve_resolution_deprecated(CalculationResolutionContext const& context) const
 {
     auto result = m_calculation->resolve(context);
     if (result.type().has_value() && result.type()->matches_resolution(m_context.percentages_resolve_as))
@@ -2717,7 +2717,7 @@ Optional<Resolution> CalculatedStyleValue::resolve_resolution(CalculationResolut
     return {};
 }
 
-Optional<Time> CalculatedStyleValue::resolve_time(CalculationResolutionContext const& context) const
+Optional<Time> CalculatedStyleValue::resolve_time_deprecated(CalculationResolutionContext const& context) const
 {
     auto result = m_calculation->resolve(context);
     if (result.type().has_value() && result.type()->matches_time(m_context.percentages_resolve_as))
@@ -2725,7 +2725,7 @@ Optional<Time> CalculatedStyleValue::resolve_time(CalculationResolutionContext c
     return {};
 }
 
-Optional<double> CalculatedStyleValue::resolve_number(CalculationResolutionContext const& context) const
+Optional<double> CalculatedStyleValue::resolve_number_deprecated(CalculationResolutionContext const& context) const
 {
     auto result = m_calculation->resolve(context);
     if (!result.type().has_value() || !result.type()->matches_number(m_context.percentages_resolve_as))
@@ -2740,7 +2740,7 @@ Optional<double> CalculatedStyleValue::resolve_number(CalculationResolutionConte
     return value;
 }
 
-Optional<i64> CalculatedStyleValue::resolve_integer(CalculationResolutionContext const& context) const
+Optional<i64> CalculatedStyleValue::resolve_integer_deprecated(CalculationResolutionContext const& context) const
 {
     auto result = m_calculation->resolve(context);
     if (result.type().has_value() && result.type()->matches_number(m_context.percentages_resolve_as))
diff --git a/Libraries/LibWeb/CSS/StyleValues/CalculatedStyleValue.h b/Libraries/LibWeb/CSS/StyleValues/CalculatedStyleValue.h
index 564de779bfc..2267f9b8be9 100644
--- a/Libraries/LibWeb/CSS/StyleValues/CalculatedStyleValue.h
+++ b/Libraries/LibWeb/CSS/StyleValues/CalculatedStyleValue.h
@@ -77,32 +77,32 @@ public:
 
     bool resolves_to_angle() const { return m_resolved_type.matches_angle(m_context.percentages_resolve_as); }
     bool resolves_to_angle_percentage() const { return m_resolved_type.matches_angle_percentage(m_context.percentages_resolve_as); }
-    Optional<Angle> resolve_angle(CalculationResolutionContext const&) const;
+    Optional<Angle> resolve_angle_deprecated(CalculationResolutionContext const&) const;
 
     bool resolves_to_flex() const { return m_resolved_type.matches_flex(m_context.percentages_resolve_as); }
-    Optional<Flex> resolve_flex(CalculationResolutionContext const&) const;
+    Optional<Flex> resolve_flex_deprecated(CalculationResolutionContext const&) const;
 
     bool resolves_to_frequency() const { return m_resolved_type.matches_frequency(m_context.percentages_resolve_as); }
     bool resolves_to_frequency_percentage() const { return m_resolved_type.matches_frequency_percentage(m_context.percentages_resolve_as); }
-    Optional<Frequency> resolve_frequency(CalculationResolutionContext const&) const;
+    Optional<Frequency> resolve_frequency_deprecated(CalculationResolutionContext const&) const;
 
     bool resolves_to_length() const { return m_resolved_type.matches_length(m_context.percentages_resolve_as); }
     bool resolves_to_length_percentage() const { return m_resolved_type.matches_length_percentage(m_context.percentages_resolve_as); }
-    Optional<Length> resolve_length(CalculationResolutionContext const&) const;
+    Optional<Length> resolve_length_deprecated(CalculationResolutionContext const&) const;
 
     bool resolves_to_percentage() const { return m_resolved_type.matches_percentage(); }
-    Optional<Percentage> resolve_percentage(CalculationResolutionContext const&) const;
+    Optional<Percentage> resolve_percentage_deprecated(CalculationResolutionContext const&) const;
 
     bool resolves_to_resolution() const { return m_resolved_type.matches_resolution(m_context.percentages_resolve_as); }
-    Optional<Resolution> resolve_resolution(CalculationResolutionContext const&) const;
+    Optional<Resolution> resolve_resolution_deprecated(CalculationResolutionContext const&) const;
 
     bool resolves_to_time() const { return m_resolved_type.matches_time(m_context.percentages_resolve_as); }
     bool resolves_to_time_percentage() const { return m_resolved_type.matches_time_percentage(m_context.percentages_resolve_as); }
-    Optional<Time> resolve_time(CalculationResolutionContext const&) const;
+    Optional<Time> resolve_time_deprecated(CalculationResolutionContext const&) const;
 
     bool resolves_to_number() const { return m_resolved_type.matches_number(m_context.percentages_resolve_as); }
-    Optional<double> resolve_number(CalculationResolutionContext const&) const;
-    Optional<i64> resolve_integer(CalculationResolutionContext const&) const;
+    Optional<double> resolve_number_deprecated(CalculationResolutionContext const&) const;
+    Optional<i64> resolve_integer_deprecated(CalculationResolutionContext const&) const;
 
     bool resolves_to_dimension() const { return m_resolved_type.matches_dimension(); }
 
diff --git a/Libraries/LibWeb/CSS/StyleValues/ColorFunctionStyleValue.cpp b/Libraries/LibWeb/CSS/StyleValues/ColorFunctionStyleValue.cpp
index 27c181cf4fc..6c3a4475496 100644
--- a/Libraries/LibWeb/CSS/StyleValues/ColorFunctionStyleValue.cpp
+++ b/Libraries/LibWeb/CSS/StyleValues/ColorFunctionStyleValue.cpp
@@ -102,14 +102,14 @@ String ColorFunctionStyleValue::to_string(SerializationMode mode) const
             CalculationResolutionContext context {};
             auto const& calculated = value->as_calculated();
             if (calculated.resolves_to_percentage()) {
-                if (auto resolved_percentage = calculated.resolve_percentage(context); resolved_percentage.has_value()) {
+                if (auto resolved_percentage = calculated.resolve_percentage_deprecated(context); resolved_percentage.has_value()) {
                     auto resolved_number = resolved_percentage->value() / 100;
                     if (!isfinite(resolved_number))
                         resolved_number = 0;
                     return NumberStyleValue::create(resolved_number);
                 }
             } else if (calculated.resolves_to_number()) {
-                if (auto resolved_number = calculated.resolve_number(context); resolved_number.has_value())
+                if (auto resolved_number = calculated.resolve_number_deprecated(context); resolved_number.has_value())
                     return NumberStyleValue::create(*resolved_number);
             }
         }
diff --git a/Libraries/LibWeb/CSS/StyleValues/FilterValueListStyleValue.cpp b/Libraries/LibWeb/CSS/StyleValues/FilterValueListStyleValue.cpp
index 9904752d354..cebf42322b6 100644
--- a/Libraries/LibWeb/CSS/StyleValues/FilterValueListStyleValue.cpp
+++ b/Libraries/LibWeb/CSS/StyleValues/FilterValueListStyleValue.cpp
@@ -34,10 +34,10 @@ float FilterOperation::Color::resolved_amount() const
     if (amount.is_calculated()) {
         CalculationResolutionContext context {};
         if (amount.calculated()->resolves_to_number())
-            return amount.calculated()->resolve_number(context).value();
+            return amount.calculated()->resolve_number_deprecated(context).value();
 
         if (amount.calculated()->resolves_to_percentage())
-            return amount.calculated()->resolve_percentage(context)->as_fraction();
+            return amount.calculated()->resolve_percentage_deprecated(context)->as_fraction();
     }
 
     VERIFY_NOT_REACHED();
diff --git a/Libraries/LibWeb/CSS/StyleValues/TransformationStyleValue.cpp b/Libraries/LibWeb/CSS/StyleValues/TransformationStyleValue.cpp
index f9857633d6c..ba6f46286f0 100644
--- a/Libraries/LibWeb/CSS/StyleValues/TransformationStyleValue.cpp
+++ b/Libraries/LibWeb/CSS/StyleValues/TransformationStyleValue.cpp
@@ -68,7 +68,7 @@ String TransformationStyleValue::to_string(SerializationMode mode) const
             if (value->is_number())
                 return value->as_number().number();
             if (value->is_calculated() && value->as_calculated().resolves_to_number())
-                return value->as_calculated().resolve_number({});
+                return value->as_calculated().resolve_number_deprecated({});
 
             VERIFY_NOT_REACHED();
         };
diff --git a/Libraries/LibWeb/CSS/Time.cpp b/Libraries/LibWeb/CSS/Time.cpp
index dbacbdaae38..e362aeb108f 100644
--- a/Libraries/LibWeb/CSS/Time.cpp
+++ b/Libraries/LibWeb/CSS/Time.cpp
@@ -78,7 +78,7 @@ Optional<Time::Type> Time::unit_from_name(StringView name)
 
 Time Time::resolve_calculated(NonnullRefPtr<CalculatedStyleValue const> const& calculated, Layout::Node const& layout_node, Time const& reference_value)
 {
-    return calculated->resolve_time(
+    return calculated->resolve_time_deprecated(
                          {
                              .percentage_basis = reference_value,
                              .length_resolution_context = Length::ResolutionContext::for_layout_node(layout_node),
diff --git a/Libraries/LibWeb/CSS/Transformation.cpp b/Libraries/LibWeb/CSS/Transformation.cpp
index 06410238f98..dcf340c1693 100644
--- a/Libraries/LibWeb/CSS/Transformation.cpp
+++ b/Libraries/LibWeb/CSS/Transformation.cpp
@@ -43,7 +43,7 @@ ErrorOr<Gfx::FloatMatrix4x4> Transformation::to_matrix(Optional<Painting::Painta
                         return length.absolute_length_to_px().to_float();
                 }
                 if (value.is_calculated() && value.calculated()->resolves_to_length()) {
-                    if (auto const& resolved = value.calculated()->resolve_length(context); resolved->is_absolute())
+                    if (auto const& resolved = value.calculated()->resolve_length_deprecated(context); resolved->is_absolute())
                         return resolved->absolute_length_to_px().to_float();
                 }
                 return Error::from_string_literal("Transform contains non absolute units");
@@ -55,9 +55,9 @@ ErrorOr<Gfx::FloatMatrix4x4> Transformation::to_matrix(Optional<Painting::Painta
                     return value.percentage().as_fraction();
                 if (value.is_calculated()) {
                     if (value.calculated()->resolves_to_number())
-                        return value.calculated()->resolve_number(context).value();
+                        return value.calculated()->resolve_number_deprecated(context).value();
                     if (value.calculated()->resolves_to_percentage())
-                        return value.calculated()->resolve_percentage(context)->as_fraction();
+                        return value.calculated()->resolve_percentage_deprecated(context)->as_fraction();
                 }
                 return Error::from_string_literal("Transform contains non absolute units");
             });
diff --git a/Libraries/LibWeb/Layout/LayoutState.cpp b/Libraries/LibWeb/Layout/LayoutState.cpp
index 795e8da0b95..5787f616711 100644
--- a/Libraries/LibWeb/Layout/LayoutState.cpp
+++ b/Libraries/LibWeb/Layout/LayoutState.cpp
@@ -563,7 +563,7 @@ void LayoutState::UsedValues::set_node(NodeWithStyle& node, UsedValues const* co
                 auto containing_block_size_as_length = width ? containing_block_used_values->content_width() : containing_block_used_values->content_height();
                 context.percentage_basis = CSS::Length::make_px(containing_block_size_as_length);
             }
-            resolved_definite_size = clamp_to_max_dimension_value(adjust_for_box_sizing(size.calculated().resolve_length(context)->to_px(node), size, width));
+            resolved_definite_size = clamp_to_max_dimension_value(adjust_for_box_sizing(size.calculated().resolve_length_deprecated(context)->to_px(node), size, width));
             return true;
         }
 
diff --git a/Libraries/LibWeb/Layout/Node.cpp b/Libraries/LibWeb/Layout/Node.cpp
index dadbcf2960f..92879bdafb0 100644
--- a/Libraries/LibWeb/Layout/Node.cpp
+++ b/Libraries/LibWeb/Layout/Node.cpp
@@ -781,14 +781,14 @@ void NodeWithStyle::apply_style(CSS::ComputedProperties const& computed_style)
         computed_values.set_transition_delay(transition_delay.time());
     } else if (transition_delay_property.is_calculated()) {
         auto const& transition_delay = transition_delay_property.as_calculated();
-        computed_values.set_transition_delay(transition_delay.resolve_time({ .length_resolution_context = CSS::Length::ResolutionContext::for_layout_node(*this) }).value());
+        computed_values.set_transition_delay(transition_delay.resolve_time_deprecated({ .length_resolution_context = CSS::Length::ResolutionContext::for_layout_node(*this) }).value());
     }
 
     auto resolve_border_width = [&](CSS::PropertyID width_property) -> CSSPixels {
         auto const& value = computed_style.property(width_property);
         if (value.is_calculated())
             return max(CSSPixels { 0 },
-                value.as_calculated().resolve_length({ .length_resolution_context = CSS::Length::ResolutionContext::for_layout_node(*this) })->to_px(*this));
+                value.as_calculated().resolve_length_deprecated({ .length_resolution_context = CSS::Length::ResolutionContext::for_layout_node(*this) })->to_px(*this));
         if (value.is_length()) {
             // FIXME: Currently, interpolation can set property values outside of their valid range.
             //        We should instead clamp property values to the valid range when interpolating.