diff --git a/Libraries/LibWeb/CSS/Interpolation.cpp b/Libraries/LibWeb/CSS/Interpolation.cpp index 3f0ebc5e4b9..37b1d0493c6 100644 --- a/Libraries/LibWeb/CSS/Interpolation.cpp +++ b/Libraries/LibWeb/CSS/Interpolation.cpp @@ -1294,7 +1294,7 @@ static RefPtr interpolate_mixed_value(CalculationContext const }); return CalculatedStyleValue::create( - simplify_a_calculation_tree(SumCalculationNode::create({ from_contribution, to_contribution }), calculation_context, {}, nullptr), + simplify_a_calculation_tree(SumCalculationNode::create({ from_contribution, to_contribution }), calculation_context, {}), *from_node->numeric_type()->added_to(*to_node->numeric_type()), calculation_context); } diff --git a/Libraries/LibWeb/CSS/ParsedFontFace.cpp b/Libraries/LibWeb/CSS/ParsedFontFace.cpp index c1bf3f4e091..689b02df9dc 100644 --- a/Libraries/LibWeb/CSS/ParsedFontFace.cpp +++ b/Libraries/LibWeb/CSS/ParsedFontFace.cpp @@ -89,10 +89,8 @@ ParsedFontFace ParsedFontFace::from_descriptors(CSSFontFaceDescriptors const& de if (value->to_keyword() == Keyword::Auto) { weight = 400; } else { - // NOTE: We can disregard the dependencies here because they won't change - PropertyComputationDependencies property_computation_dependencies; // NOTE: The value we pass here for inherited_font_weight is irrelevant as relative keywords (lighter, bolder) should be disallowed at parse time - weight = StyleComputer::compute_font_weight(*value, 0, computation_context, property_computation_dependencies)->as_number().number(); + weight = StyleComputer::compute_font_weight(*value, 0, computation_context)->as_number().number(); } } @@ -105,9 +103,7 @@ ParsedFontFace ParsedFontFace::from_descriptors(CSSFontFaceDescriptors const& de if (value->to_keyword() == Keyword::Auto) { slope = 0; } else { - // NOTE: We can disregard the dependencies here because they won't change - PropertyComputationDependencies property_computation_dependencies; - slope = StyleComputer::compute_font_style(*value, computation_context, property_computation_dependencies)->as_font_style().to_font_slope(); + slope = StyleComputer::compute_font_style(*value, computation_context)->as_font_style().to_font_slope(); } } @@ -120,9 +116,7 @@ ParsedFontFace ParsedFontFace::from_descriptors(CSSFontFaceDescriptors const& de if (value->to_keyword() == Keyword::Auto) { width = 100; } else { - // NOTE: We can disregard the dependencies here because they won't change - PropertyComputationDependencies property_computation_dependencies; - width = StyleComputer::compute_font_width(*value, computation_context, property_computation_dependencies)->as_percentage().raw_value(); + width = StyleComputer::compute_font_width(*value, computation_context)->as_percentage().raw_value(); } } diff --git a/Libraries/LibWeb/CSS/Parser/ValueParsing.cpp b/Libraries/LibWeb/CSS/Parser/ValueParsing.cpp index 06fa67a19f6..2d7699f6565 100644 --- a/Libraries/LibWeb/CSS/Parser/ValueParsing.cpp +++ b/Libraries/LibWeb/CSS/Parser/ValueParsing.cpp @@ -4188,7 +4188,7 @@ RefPtr Parser::parse_a_calc_function_node(Function const& if (auto maybe_function = parse_math_function(function, context)) { // NOTE: We have to simplify manually here, since parse_math_function() is a helper for calc() parsing // that doesn't do it directly by itself. - return simplify_a_calculation_tree(*maybe_function, context, CalculationResolutionContext {}, nullptr); + return simplify_a_calculation_tree(*maybe_function, context, CalculationResolutionContext {}); } return nullptr; @@ -4468,7 +4468,7 @@ RefPtr Parser::parse_a_calculation(Vector return nullptr; // 6. Return the result of simplifying a calculation tree from values. - return simplify_a_calculation_tree(*calculation_tree, context, CalculationResolutionContext {}, nullptr); + return simplify_a_calculation_tree(*calculation_tree, context, CalculationResolutionContext {}); } // https://drafts.csswg.org/css-values-5/#tree-counting diff --git a/Libraries/LibWeb/CSS/StyleComputer.cpp b/Libraries/LibWeb/CSS/StyleComputer.cpp index 0647e785d91..80b35d7f479 100644 --- a/Libraries/LibWeb/CSS/StyleComputer.cpp +++ b/Libraries/LibWeb/CSS/StyleComputer.cpp @@ -895,16 +895,6 @@ static void cascade_custom_properties(DOM::AbstractElement abstract_element, Vec custom_properties.update(important_custom_properties); } -// TODO: This could be useful for marking which properties need recomputation when inherited style changes -ALWAYS_INLINE static void mark_property_computation_dependencies(Optional abstract_element, PropertyComputationDependencies const& property_computation_dependencies) -{ - if (!abstract_element.has_value()) - return; - - if (property_computation_dependencies.tree_counting_function) - abstract_element->element().set_style_uses_tree_counting_function(); -} - void StyleComputer::collect_animation_into(DOM::AbstractElement abstract_element, GC::Ref effect, ComputedProperties& computed_properties) const { auto animation = effect->associated_animation(); @@ -1091,44 +1081,32 @@ void StyleComputer::collect_animation_into(DOM::AbstractElement abstract_element auto inherited_font_size = inheritance_parent_has_computed_properties ? inheritance_parent->computed_properties()->font_size() : InitialValues::font_size(); auto inherited_math_depth = inheritance_parent_has_computed_properties ? inheritance_parent->computed_properties()->math_depth() : InitialValues::math_depth(); - PropertyComputationDependencies property_computation_dependencies; auto const& font_size_in_computed_form = compute_font_size( *font_size_specified_value.value(), computed_math_depth, inherited_font_size, inherited_math_depth, - font_computation_context, - property_computation_dependencies); + font_computation_context); result.set(PropertyID::FontSize, font_size_in_computed_form); - mark_property_computation_dependencies(abstract_element, property_computation_dependencies); } if (auto const& font_weight_specified_value = specified_values.get(PropertyID::FontWeight); font_weight_specified_value.has_value()) { auto inherited_font_weight = inheritance_parent_has_computed_properties ? inheritance_parent->computed_properties()->font_weight() : InitialValues::font_weight(); - PropertyComputationDependencies property_computation_dependencies; auto const& font_weight_in_computed_form = compute_font_weight( *font_weight_specified_value.value(), inherited_font_weight, - font_computation_context, - property_computation_dependencies); + font_computation_context); result.set(PropertyID::FontWeight, font_weight_in_computed_form); - mark_property_computation_dependencies(abstract_element, property_computation_dependencies); } - if (auto const& font_width_specified_value = specified_values.get(PropertyID::FontWidth); font_width_specified_value.has_value()) { - PropertyComputationDependencies property_computation_dependencies; - result.set(PropertyID::FontWidth, compute_font_width(*font_width_specified_value.value(), font_computation_context, property_computation_dependencies)); - mark_property_computation_dependencies(abstract_element, property_computation_dependencies); - } + if (auto const& font_width_specified_value = specified_values.get(PropertyID::FontWidth); font_width_specified_value.has_value()) + result.set(PropertyID::FontWidth, compute_font_width(*font_width_specified_value.value(), font_computation_context)); - if (auto const& font_style_specified_value = specified_values.get(PropertyID::FontStyle); font_style_specified_value.has_value()) { - PropertyComputationDependencies property_computation_dependencies; - result.set(PropertyID::FontStyle, compute_font_style(*font_style_specified_value.value(), font_computation_context, property_computation_dependencies)); - mark_property_computation_dependencies(abstract_element, property_computation_dependencies); - } + if (auto const& font_style_specified_value = specified_values.get(PropertyID::FontStyle); font_style_specified_value.has_value()) + result.set(PropertyID::FontStyle, compute_font_style(*font_style_specified_value.value(), font_computation_context)); if (auto const& line_height_specified_value = specified_values.get(PropertyID::LineHeight); line_height_specified_value.has_value()) { ComputationContext line_height_computation_context { @@ -1142,9 +1120,7 @@ void StyleComputer::collect_animation_into(DOM::AbstractElement abstract_element .abstract_element = abstract_element }; - PropertyComputationDependencies property_computation_dependencies; - result.set(PropertyID::LineHeight, compute_line_height(*line_height_specified_value.value(), line_height_computation_context, property_computation_dependencies)); - mark_property_computation_dependencies(abstract_element, property_computation_dependencies); + result.set(PropertyID::LineHeight, compute_line_height(*line_height_specified_value.value(), line_height_computation_context)); } ComputationContext computation_context { @@ -1171,9 +1147,7 @@ void StyleComputer::collect_animation_into(DOM::AbstractElement abstract_element if (first_is_one_of(property_id, PropertyID::FontSize, PropertyID::FontWeight, PropertyID::FontWidth, PropertyID::FontStyle, PropertyID::LineHeight)) continue; - PropertyComputationDependencies property_computation_dependencies; - result.set(property_id, compute_value_of_property(property_id, *style_value, get_property_specified_value, computation_context, m_document->page().client().device_pixels_per_css_pixel(), property_computation_dependencies)); - mark_property_computation_dependencies(abstract_element, property_computation_dependencies); + result.set(property_id, compute_value_of_property(property_id, *style_value, get_property_specified_value, computation_context, m_document->page().client().device_pixels_per_css_pixel())); } return result; @@ -2068,41 +2042,33 @@ void StyleComputer::compute_font(ComputedProperties& style, Optionalcomputed_properties()->font_weight() : InitialValues::font_weight(); auto const& font_weight_specified_value = style.property(PropertyID::FontWeight, ComputedProperties::WithAnimationsApplied::No); - PropertyComputationDependencies font_weight_property_computation_dependencies; style.set_property( PropertyID::FontWeight, - compute_font_weight(font_weight_specified_value, inherited_font_weight, font_computation_context, font_weight_property_computation_dependencies), + compute_font_weight(font_weight_specified_value, inherited_font_weight, font_computation_context), style.is_property_inherited(PropertyID::FontWeight) ? ComputedProperties::Inherited::Yes : ComputedProperties::Inherited::No); - mark_property_computation_dependencies(abstract_element, font_weight_property_computation_dependencies); auto const& font_width_specified_value = style.property(PropertyID::FontWidth, ComputedProperties::WithAnimationsApplied::No); - PropertyComputationDependencies font_width_property_computation_dependencies; style.set_property( PropertyID::FontWidth, - compute_font_width(font_width_specified_value, font_computation_context, font_width_property_computation_dependencies), + compute_font_width(font_width_specified_value, font_computation_context), style.is_property_inherited(PropertyID::FontWidth) ? ComputedProperties::Inherited::Yes : ComputedProperties::Inherited::No); - mark_property_computation_dependencies(abstract_element, font_width_property_computation_dependencies); auto const& font_style_specified_value = style.property(PropertyID::FontStyle, ComputedProperties::WithAnimationsApplied::No); - PropertyComputationDependencies font_style_property_computation_dependencies; style.set_property( PropertyID::FontStyle, - compute_font_style(font_style_specified_value, font_computation_context, font_style_property_computation_dependencies), + compute_font_style(font_style_specified_value, font_computation_context), style.is_property_inherited(PropertyID::FontStyle) ? ComputedProperties::Inherited::Yes : ComputedProperties::Inherited::No); - mark_property_computation_dependencies(abstract_element, font_style_property_computation_dependencies); auto const& font_family = style.property(CSS::PropertyID::FontFamily); @@ -2131,12 +2097,10 @@ void StyleComputer::compute_font(ComputedProperties& style, Optional(abstract_element->element())) { const_cast(*this).m_root_element_font_metrics = calculate_root_element_font_metrics(style); @@ -2213,9 +2177,7 @@ void StyleComputer::compute_property_values(ComputedProperties& style, Optional< }; style.for_each_property([&](PropertyID property_id, auto& specified_value) { - PropertyComputationDependencies property_computation_dependencies; - auto const& computed_value = compute_value_of_property(property_id, specified_value, get_property_specified_value, computation_context, m_document->page().client().device_pixels_per_css_pixel(), property_computation_dependencies); - mark_property_computation_dependencies(abstract_element, property_computation_dependencies); + auto const& computed_value = compute_value_of_property(property_id, specified_value, get_property_specified_value, computation_context, m_document->page().client().device_pixels_per_css_pixel()); auto const& is_inherited = style.is_property_inherited(property_id) ? ComputedProperties::Inherited::Yes : ComputedProperties::Inherited::No; @@ -3279,10 +3241,9 @@ NonnullRefPtr StyleComputer::compute_value_of_property( NonnullRefPtr const& specified_value, Function(PropertyID)> const& get_property_specified_value, ComputationContext const& computation_context, - double device_pixels_per_css_pixel, - PropertyComputationDependencies& property_computation_dependencies) + double device_pixels_per_css_pixel) { - auto const& absolutized_value = specified_value->absolutized(computation_context, property_computation_dependencies); + auto const& absolutized_value = specified_value->absolutized(computation_context); switch (property_id) { case PropertyID::AnimationName: @@ -3436,12 +3397,12 @@ NonnullRefPtr StyleComputer::compute_corner_shape(NonnullRefPt VERIFY_NOT_REACHED(); } -NonnullRefPtr StyleComputer::compute_font_size(NonnullRefPtr const& specified_value, int computed_math_depth, CSSPixels inherited_font_size, int inherited_math_depth, ComputationContext const& computation_context, PropertyComputationDependencies& property_computation_dependencies) +NonnullRefPtr StyleComputer::compute_font_size(NonnullRefPtr const& specified_value, int computed_math_depth, CSSPixels inherited_font_size, int inherited_math_depth, ComputationContext const& computation_context) { // https://drafts.csswg.org/css-fonts/#font-size-prop // an absolute length - auto const& absolutized_value = specified_value->absolutized(computation_context, property_computation_dependencies); + auto const& absolutized_value = specified_value->absolutized(computation_context); // if (auto absolute_size = keyword_to_absolute_size(absolutized_value->to_keyword()); absolute_size.has_value()) @@ -3507,7 +3468,7 @@ NonnullRefPtr StyleComputer::compute_font_size(NonnullRefPtr StyleComputer::compute_font_style(NonnullRefPtr const& specified_value, ComputationContext const& computation_context, PropertyComputationDependencies& property_computation_dependencies) +NonnullRefPtr StyleComputer::compute_font_style(NonnullRefPtr const& specified_value, ComputationContext const& computation_context) { // https://drafts.csswg.org/css-fonts-4/#font-style-prop // the keyword specified, plus angle in degrees if specified @@ -3516,15 +3477,15 @@ NonnullRefPtr StyleComputer::compute_font_style(NonnullRefPtr< if (specified_value->is_keyword()) return FontStyleStyleValue::create(*keyword_to_font_style(specified_value->to_keyword())); - return specified_value->absolutized(computation_context, property_computation_dependencies); + return specified_value->absolutized(computation_context); } -NonnullRefPtr StyleComputer::compute_font_weight(NonnullRefPtr const& specified_value, double inherited_font_weight, ComputationContext const& computation_context, PropertyComputationDependencies& property_computation_dependencies) +NonnullRefPtr StyleComputer::compute_font_weight(NonnullRefPtr const& specified_value, double inherited_font_weight, ComputationContext const& computation_context) { // https://drafts.csswg.org/css-fonts-4/#font-weight-prop // a number, see below - auto const& absolutized_value = specified_value->absolutized(computation_context, property_computation_dependencies); + auto const& absolutized_value = specified_value->absolutized(computation_context); // if (absolutized_value->is_number()) @@ -3588,12 +3549,12 @@ NonnullRefPtr StyleComputer::compute_font_weight(NonnullRefPtr VERIFY_NOT_REACHED(); } -NonnullRefPtr StyleComputer::compute_font_width(NonnullRefPtr const& specified_value, ComputationContext const& computation_context, PropertyComputationDependencies& property_computation_dependencies) +NonnullRefPtr StyleComputer::compute_font_width(NonnullRefPtr const& specified_value, ComputationContext const& computation_context) { // https://drafts.csswg.org/css-fonts-4/#font-width-prop // a percentage, see below - auto absolutized_value = specified_value->absolutized(computation_context, property_computation_dependencies); + auto absolutized_value = specified_value->absolutized(computation_context); // if (absolutized_value->is_percentage()) @@ -3636,11 +3597,11 @@ NonnullRefPtr StyleComputer::compute_font_width(NonnullRefPtr< } } -NonnullRefPtr StyleComputer::compute_line_height(NonnullRefPtr const& specified_value, ComputationContext const& computation_context, PropertyComputationDependencies& property_computation_dependencies) +NonnullRefPtr StyleComputer::compute_line_height(NonnullRefPtr const& specified_value, ComputationContext const& computation_context) { // https://drafts.csswg.org/css-inline-3/#line-height-property - auto absolutized_value = specified_value->absolutized(computation_context, property_computation_dependencies); + auto absolutized_value = specified_value->absolutized(computation_context); // normal // diff --git a/Libraries/LibWeb/CSS/StyleComputer.h b/Libraries/LibWeb/CSS/StyleComputer.h index 95f9e3339a1..0ff321f6195 100644 --- a/Libraries/LibWeb/CSS/StyleComputer.h +++ b/Libraries/LibWeb/CSS/StyleComputer.h @@ -198,16 +198,16 @@ public: static NonnullRefPtr compute_value_of_custom_property(DOM::AbstractElement, FlyString const& custom_property, Optional = {}); - static NonnullRefPtr compute_value_of_property(PropertyID, NonnullRefPtr const& specified_value, Function(PropertyID)> const& get_property_specified_value, ComputationContext const&, double device_pixels_per_css_pixel, PropertyComputationDependencies& property_computation_dependencies); + static NonnullRefPtr compute_value_of_property(PropertyID, NonnullRefPtr const& specified_value, Function(PropertyID)> const& get_property_specified_value, ComputationContext const&, double device_pixels_per_css_pixel); static NonnullRefPtr compute_animation_name(NonnullRefPtr const& absolutized_value); static NonnullRefPtr compute_border_or_outline_width(NonnullRefPtr const& absolutized_value, NonnullRefPtr const& style_specified_value, double device_pixels_per_css_pixel); static NonnullRefPtr compute_corner_shape(NonnullRefPtr const& absolutized_value); - static NonnullRefPtr compute_font_size(NonnullRefPtr const& specified_value, int computed_math_depth, CSSPixels inherited_font_size, int inherited_math_depth, ComputationContext const&, PropertyComputationDependencies&); - static NonnullRefPtr compute_font_style(NonnullRefPtr const& specified_value, ComputationContext const&, PropertyComputationDependencies&); - static NonnullRefPtr compute_font_weight(NonnullRefPtr const& specified_value, double inherited_font_weight, ComputationContext const&, PropertyComputationDependencies&); - static NonnullRefPtr compute_font_width(NonnullRefPtr const& specified_value, ComputationContext const&, PropertyComputationDependencies&); + static NonnullRefPtr compute_font_size(NonnullRefPtr const& specified_value, int computed_math_depth, CSSPixels inherited_font_size, int inherited_math_depth, ComputationContext const&); + static NonnullRefPtr compute_font_style(NonnullRefPtr const& specified_value, ComputationContext const&); + static NonnullRefPtr compute_font_weight(NonnullRefPtr const& specified_value, double inherited_font_weight, ComputationContext const&); + static NonnullRefPtr compute_font_width(NonnullRefPtr const& specified_value, ComputationContext const&); static NonnullRefPtr compute_font_variation_settings(NonnullRefPtr const& absolutized_value); - static NonnullRefPtr compute_line_height(NonnullRefPtr const& specified_value, ComputationContext const&, PropertyComputationDependencies&); + static NonnullRefPtr compute_line_height(NonnullRefPtr const& specified_value, ComputationContext const&); static NonnullRefPtr compute_opacity(NonnullRefPtr const& absolutized_value); static NonnullRefPtr compute_position_area(NonnullRefPtr const& absolutized_value); diff --git a/Libraries/LibWeb/CSS/StyleValues/AbstractNonMathCalcFunctionStyleValue.h b/Libraries/LibWeb/CSS/StyleValues/AbstractNonMathCalcFunctionStyleValue.h index 311172d6304..444af396277 100644 --- a/Libraries/LibWeb/CSS/StyleValues/AbstractNonMathCalcFunctionStyleValue.h +++ b/Libraries/LibWeb/CSS/StyleValues/AbstractNonMathCalcFunctionStyleValue.h @@ -14,7 +14,7 @@ class AbstractNonMathCalcFunctionStyleValue : public StyleValue { using StyleValue::StyleValue; public: - virtual RefPtr resolve_to_calculation_node(CalculationContext const&, CalculationResolutionContext const&, PropertyComputationDependencies*) const = 0; + virtual RefPtr resolve_to_calculation_node(CalculationContext const&, CalculationResolutionContext const&) const = 0; }; } diff --git a/Libraries/LibWeb/CSS/StyleValues/BackgroundSizeStyleValue.cpp b/Libraries/LibWeb/CSS/StyleValues/BackgroundSizeStyleValue.cpp index c4b2960a9e8..f9c96663e1f 100644 --- a/Libraries/LibWeb/CSS/StyleValues/BackgroundSizeStyleValue.cpp +++ b/Libraries/LibWeb/CSS/StyleValues/BackgroundSizeStyleValue.cpp @@ -26,10 +26,10 @@ String BackgroundSizeStyleValue::to_string(SerializationMode mode) const return MUST(String::formatted("{} {}", m_properties.size_x->to_string(mode), m_properties.size_y->to_string(mode))); } -ValueComparingNonnullRefPtr BackgroundSizeStyleValue::absolutized(ComputationContext const& computation_context, PropertyComputationDependencies& property_computation_dependencies) const +ValueComparingNonnullRefPtr BackgroundSizeStyleValue::absolutized(ComputationContext const& computation_context) const { - auto absolutized_size_x = m_properties.size_x->absolutized(computation_context, property_computation_dependencies); - auto absolutized_size_y = m_properties.size_y->absolutized(computation_context, property_computation_dependencies); + auto absolutized_size_x = m_properties.size_x->absolutized(computation_context); + auto absolutized_size_y = m_properties.size_y->absolutized(computation_context); if (absolutized_size_x == m_properties.size_x && absolutized_size_y == m_properties.size_y) return *this; diff --git a/Libraries/LibWeb/CSS/StyleValues/BackgroundSizeStyleValue.h b/Libraries/LibWeb/CSS/StyleValues/BackgroundSizeStyleValue.h index 4c81e14d5a3..24e2f5eb61f 100644 --- a/Libraries/LibWeb/CSS/StyleValues/BackgroundSizeStyleValue.h +++ b/Libraries/LibWeb/CSS/StyleValues/BackgroundSizeStyleValue.h @@ -28,7 +28,7 @@ public: ValueComparingNonnullRefPtr size_y() const { return m_properties.size_y; } virtual String to_string(SerializationMode) const override; - virtual ValueComparingNonnullRefPtr absolutized(ComputationContext const&, PropertyComputationDependencies&) const override; + virtual ValueComparingNonnullRefPtr absolutized(ComputationContext const&) const override; bool properties_equal(BackgroundSizeStyleValue const& other) const { return m_properties == other.m_properties; } diff --git a/Libraries/LibWeb/CSS/StyleValues/BorderRadiusStyleValue.cpp b/Libraries/LibWeb/CSS/StyleValues/BorderRadiusStyleValue.cpp index ff35a0f7e84..8e6ae302de2 100644 --- a/Libraries/LibWeb/CSS/StyleValues/BorderRadiusStyleValue.cpp +++ b/Libraries/LibWeb/CSS/StyleValues/BorderRadiusStyleValue.cpp @@ -18,10 +18,10 @@ String BorderRadiusStyleValue::to_string(SerializationMode mode) const return MUST(String::formatted("{} {}", m_properties.horizontal_radius->to_string(mode), m_properties.vertical_radius->to_string(mode))); } -ValueComparingNonnullRefPtr BorderRadiusStyleValue::absolutized(ComputationContext const& computation_context, PropertyComputationDependencies& property_computation_dependencies) const +ValueComparingNonnullRefPtr BorderRadiusStyleValue::absolutized(ComputationContext const& computation_context) const { - auto absolutized_horizontal_radius = m_properties.horizontal_radius->absolutized(computation_context, property_computation_dependencies); - auto absolutized_vertical_radius = m_properties.vertical_radius->absolutized(computation_context, property_computation_dependencies); + auto absolutized_horizontal_radius = m_properties.horizontal_radius->absolutized(computation_context); + auto absolutized_vertical_radius = m_properties.vertical_radius->absolutized(computation_context); if (absolutized_vertical_radius == m_properties.vertical_radius && absolutized_horizontal_radius == m_properties.horizontal_radius) return *this; diff --git a/Libraries/LibWeb/CSS/StyleValues/BorderRadiusStyleValue.h b/Libraries/LibWeb/CSS/StyleValues/BorderRadiusStyleValue.h index 629cfad051d..144814ebabf 100644 --- a/Libraries/LibWeb/CSS/StyleValues/BorderRadiusStyleValue.h +++ b/Libraries/LibWeb/CSS/StyleValues/BorderRadiusStyleValue.h @@ -38,7 +38,7 @@ private: { } - virtual ValueComparingNonnullRefPtr absolutized(ComputationContext const&, PropertyComputationDependencies&) const override; + virtual ValueComparingNonnullRefPtr absolutized(ComputationContext const&) const override; struct Properties { bool is_elliptical; ValueComparingNonnullRefPtr horizontal_radius; diff --git a/Libraries/LibWeb/CSS/StyleValues/CalculatedStyleValue.cpp b/Libraries/LibWeb/CSS/StyleValues/CalculatedStyleValue.cpp index 7071007b67f..507d3697d84 100644 --- a/Libraries/LibWeb/CSS/StyleValues/CalculatedStyleValue.cpp +++ b/Libraries/LibWeb/CSS/StyleValues/CalculatedStyleValue.cpp @@ -115,14 +115,14 @@ static Optional multiply_the_types(Vector -static NonnullRefPtr simplify_children_vector(T const& original, CalculationContext const& context, CalculationResolutionContext const& resolution_context, PropertyComputationDependencies* property_computation_dependencies) +static NonnullRefPtr simplify_children_vector(T const& original, CalculationContext const& context, CalculationResolutionContext const& resolution_context) { Vector> simplified_children; simplified_children.ensure_capacity(original.children().size()); bool any_changed = false; for (auto const& child : original.children()) { - auto simplified = simplify_a_calculation_tree(child, context, resolution_context, property_computation_dependencies); + auto simplified = simplify_a_calculation_tree(child, context, resolution_context); if (simplified != child) any_changed = true; simplified_children.append(move(simplified)); @@ -134,19 +134,19 @@ static NonnullRefPtr simplify_children_vector(T const& or } template -static NonnullRefPtr simplify_child(T const& original, NonnullRefPtr const& child, CalculationContext const& context, CalculationResolutionContext const& resolution_context, PropertyComputationDependencies* property_computation_dependencies) +static NonnullRefPtr simplify_child(T const& original, NonnullRefPtr const& child, CalculationContext const& context, CalculationResolutionContext const& resolution_context) { - auto simplified = simplify_a_calculation_tree(child, context, resolution_context, property_computation_dependencies); + auto simplified = simplify_a_calculation_tree(child, context, resolution_context); if (simplified != child) return T::create(move(simplified)); return original; } template -static NonnullRefPtr simplify_2_children(T const& original, NonnullRefPtr const& child_1, NonnullRefPtr const& child_2, CalculationContext const& context, CalculationResolutionContext const& resolution_context, PropertyComputationDependencies* property_computation_dependencies) +static NonnullRefPtr simplify_2_children(T const& original, NonnullRefPtr const& child_1, NonnullRefPtr const& child_2, CalculationContext const& context, CalculationResolutionContext const& resolution_context) { - auto simplified_1 = simplify_a_calculation_tree(child_1, context, resolution_context, property_computation_dependencies); - auto simplified_2 = simplify_a_calculation_tree(child_2, context, resolution_context, property_computation_dependencies); + auto simplified_1 = simplify_a_calculation_tree(child_1, context, resolution_context); + auto simplified_2 = simplify_a_calculation_tree(child_2, context, resolution_context); if (simplified_1 != child_1 || simplified_2 != child_2) return T::create(move(simplified_1), move(simplified_2)); return original; @@ -833,9 +833,9 @@ bool SumCalculationNode::contains_percentage() const return false; } -NonnullRefPtr SumCalculationNode::with_simplified_children(CalculationContext const& context, CalculationResolutionContext const& resolution_context, PropertyComputationDependencies* property_computation_dependencies) const +NonnullRefPtr SumCalculationNode::with_simplified_children(CalculationContext const& context, CalculationResolutionContext const& resolution_context) const { - return simplify_children_vector(*this, context, resolution_context, property_computation_dependencies); + return simplify_children_vector(*this, context, resolution_context); } void SumCalculationNode::dump(StringBuilder& builder, int indent) const @@ -895,9 +895,9 @@ bool ProductCalculationNode::contains_percentage() const return false; } -NonnullRefPtr ProductCalculationNode::with_simplified_children(CalculationContext const& context, CalculationResolutionContext const& resolution_context, PropertyComputationDependencies* property_computation_dependencies) const +NonnullRefPtr ProductCalculationNode::with_simplified_children(CalculationContext const& context, CalculationResolutionContext const& resolution_context) const { - return simplify_children_vector(*this, context, resolution_context, property_computation_dependencies); + return simplify_children_vector(*this, context, resolution_context); } void ProductCalculationNode::dump(StringBuilder& builder, int indent) const @@ -949,9 +949,9 @@ bool NegateCalculationNode::contains_percentage() const return m_value->contains_percentage(); } -NonnullRefPtr NegateCalculationNode::with_simplified_children(CalculationContext const& context, CalculationResolutionContext const& resolution_context, PropertyComputationDependencies* property_computation_dependencies) const +NonnullRefPtr NegateCalculationNode::with_simplified_children(CalculationContext const& context, CalculationResolutionContext const& resolution_context) const { - return simplify_child(*this, m_value, context, resolution_context, property_computation_dependencies); + return simplify_child(*this, m_value, context, resolution_context); } void NegateCalculationNode::dump(StringBuilder& builder, int indent) const @@ -1002,9 +1002,9 @@ bool InvertCalculationNode::contains_percentage() const return m_value->contains_percentage(); } -NonnullRefPtr InvertCalculationNode::with_simplified_children(CalculationContext const& context, CalculationResolutionContext const& resolution_context, PropertyComputationDependencies* property_computation_dependencies) const +NonnullRefPtr InvertCalculationNode::with_simplified_children(CalculationContext const& context, CalculationResolutionContext const& resolution_context) const { - return simplify_child(*this, m_value, context, resolution_context, property_computation_dependencies); + return simplify_child(*this, m_value, context, resolution_context); } void InvertCalculationNode::dump(StringBuilder& builder, int indent) const @@ -1056,9 +1056,9 @@ bool MinCalculationNode::contains_percentage() const return false; } -NonnullRefPtr MinCalculationNode::with_simplified_children(CalculationContext const& context, CalculationResolutionContext const& resolution_context, PropertyComputationDependencies* property_computation_dependencies) const +NonnullRefPtr MinCalculationNode::with_simplified_children(CalculationContext const& context, CalculationResolutionContext const& resolution_context) const { - return simplify_children_vector(*this, context, resolution_context, property_computation_dependencies); + return simplify_children_vector(*this, context, resolution_context); } // https://drafts.csswg.org/css-values-4/#funcdef-min @@ -1170,9 +1170,9 @@ bool MaxCalculationNode::contains_percentage() const return false; } -NonnullRefPtr MaxCalculationNode::with_simplified_children(CalculationContext const& context, CalculationResolutionContext const& resolution_context, PropertyComputationDependencies* property_computation_dependencies) const +NonnullRefPtr MaxCalculationNode::with_simplified_children(CalculationContext const& context, CalculationResolutionContext const& resolution_context) const { - return simplify_children_vector(*this, context, resolution_context, property_computation_dependencies); + return simplify_children_vector(*this, context, resolution_context); } // https://drafts.csswg.org/css-values-4/#funcdef-max @@ -1234,11 +1234,11 @@ bool ClampCalculationNode::contains_percentage() const return m_min_value->contains_percentage() || m_center_value->contains_percentage() || m_max_value->contains_percentage(); } -NonnullRefPtr ClampCalculationNode::with_simplified_children(CalculationContext const& context, CalculationResolutionContext const& resolution_context, PropertyComputationDependencies* property_computation_dependencies) const +NonnullRefPtr ClampCalculationNode::with_simplified_children(CalculationContext const& context, CalculationResolutionContext const& resolution_context) const { - auto simplified_min = simplify_a_calculation_tree(m_min_value, context, resolution_context, property_computation_dependencies); - auto simplified_center = simplify_a_calculation_tree(m_center_value, context, resolution_context, property_computation_dependencies); - auto simplified_max = simplify_a_calculation_tree(m_max_value, context, resolution_context, property_computation_dependencies); + auto simplified_min = simplify_a_calculation_tree(m_min_value, context, resolution_context); + auto simplified_center = simplify_a_calculation_tree(m_center_value, context, resolution_context); + auto simplified_max = simplify_a_calculation_tree(m_max_value, context, resolution_context); if (simplified_min != m_min_value || simplified_center != m_center_value || simplified_max != m_max_value) return create(move(simplified_min), move(simplified_center), move(simplified_max)); return *this; @@ -1334,9 +1334,9 @@ bool AbsCalculationNode::contains_percentage() const return m_value->contains_percentage(); } -NonnullRefPtr AbsCalculationNode::with_simplified_children(CalculationContext const& context, CalculationResolutionContext const& resolution_context, PropertyComputationDependencies* property_computation_dependencies) const +NonnullRefPtr AbsCalculationNode::with_simplified_children(CalculationContext const& context, CalculationResolutionContext const& resolution_context) const { - return simplify_child(*this, m_value, context, resolution_context, property_computation_dependencies); + return simplify_child(*this, m_value, context, resolution_context); } // https://drafts.csswg.org/css-values-4/#funcdef-abs @@ -1385,9 +1385,9 @@ bool SignCalculationNode::contains_percentage() const return m_value->contains_percentage(); } -NonnullRefPtr SignCalculationNode::with_simplified_children(CalculationContext const& context, CalculationResolutionContext const& resolution_context, PropertyComputationDependencies* property_computation_dependencies) const +NonnullRefPtr SignCalculationNode::with_simplified_children(CalculationContext const& context, CalculationResolutionContext const& resolution_context) const { - return simplify_child(*this, m_value, context, resolution_context, property_computation_dependencies); + return simplify_child(*this, m_value, context, resolution_context); } // https://drafts.csswg.org/css-values-4/#funcdef-sign @@ -1452,9 +1452,9 @@ bool SinCalculationNode::contains_percentage() const return m_value->contains_percentage(); } -NonnullRefPtr SinCalculationNode::with_simplified_children(CalculationContext const& context, CalculationResolutionContext const& resolution_context, PropertyComputationDependencies* property_computation_dependencies) const +NonnullRefPtr SinCalculationNode::with_simplified_children(CalculationContext const& context, CalculationResolutionContext const& resolution_context) const { - return simplify_child(*this, m_value, context, resolution_context, property_computation_dependencies); + return simplify_child(*this, m_value, context, resolution_context); } enum class SinCosOrTan { @@ -1537,9 +1537,9 @@ bool CosCalculationNode::contains_percentage() const return m_value->contains_percentage(); } -NonnullRefPtr CosCalculationNode::with_simplified_children(CalculationContext const& context, CalculationResolutionContext const& resolution_context, PropertyComputationDependencies* property_computation_dependencies) const +NonnullRefPtr CosCalculationNode::with_simplified_children(CalculationContext const& context, CalculationResolutionContext const& resolution_context) const { - return simplify_child(*this, m_value, context, resolution_context, property_computation_dependencies); + return simplify_child(*this, m_value, context, resolution_context); } // https://drafts.csswg.org/css-values-4/#funcdef-cos @@ -1583,9 +1583,9 @@ bool TanCalculationNode::contains_percentage() const return m_value->contains_percentage(); } -NonnullRefPtr TanCalculationNode::with_simplified_children(CalculationContext const& context, CalculationResolutionContext const& resolution_context, PropertyComputationDependencies* property_computation_dependencies) const +NonnullRefPtr TanCalculationNode::with_simplified_children(CalculationContext const& context, CalculationResolutionContext const& resolution_context) const { - return simplify_child(*this, m_value, context, resolution_context, property_computation_dependencies); + return simplify_child(*this, m_value, context, resolution_context); } // https://drafts.csswg.org/css-values-4/#funcdef-tan @@ -1629,9 +1629,9 @@ bool AsinCalculationNode::contains_percentage() const return m_value->contains_percentage(); } -NonnullRefPtr AsinCalculationNode::with_simplified_children(CalculationContext const& context, CalculationResolutionContext const& resolution_context, PropertyComputationDependencies* property_computation_dependencies) const +NonnullRefPtr AsinCalculationNode::with_simplified_children(CalculationContext const& context, CalculationResolutionContext const& resolution_context) const { - return simplify_child(*this, m_value, context, resolution_context, property_computation_dependencies); + return simplify_child(*this, m_value, context, resolution_context); } enum class AsinAcosOrAtan { @@ -1719,9 +1719,9 @@ bool AcosCalculationNode::contains_percentage() const return m_value->contains_percentage(); } -NonnullRefPtr AcosCalculationNode::with_simplified_children(CalculationContext const& context, CalculationResolutionContext const& resolution_context, PropertyComputationDependencies* property_computation_dependencies) const +NonnullRefPtr AcosCalculationNode::with_simplified_children(CalculationContext const& context, CalculationResolutionContext const& resolution_context) const { - return simplify_child(*this, m_value, context, resolution_context, property_computation_dependencies); + return simplify_child(*this, m_value, context, resolution_context); } // https://drafts.csswg.org/css-values-4/#funcdef-acos @@ -1765,9 +1765,9 @@ bool AtanCalculationNode::contains_percentage() const return m_value->contains_percentage(); } -NonnullRefPtr AtanCalculationNode::with_simplified_children(CalculationContext const& context, CalculationResolutionContext const& resolution_context, PropertyComputationDependencies* property_computation_dependencies) const +NonnullRefPtr AtanCalculationNode::with_simplified_children(CalculationContext const& context, CalculationResolutionContext const& resolution_context) const { - return simplify_child(*this, m_value, context, resolution_context, property_computation_dependencies); + return simplify_child(*this, m_value, context, resolution_context); } // https://drafts.csswg.org/css-values-4/#funcdef-atan @@ -1812,9 +1812,9 @@ bool Atan2CalculationNode::contains_percentage() const return m_y->contains_percentage() || m_x->contains_percentage(); } -NonnullRefPtr Atan2CalculationNode::with_simplified_children(CalculationContext const& context, CalculationResolutionContext const& resolution_context, PropertyComputationDependencies* property_computation_dependencies) const +NonnullRefPtr Atan2CalculationNode::with_simplified_children(CalculationContext const& context, CalculationResolutionContext const& resolution_context) const { - return simplify_2_children(*this, m_x, m_y, context, resolution_context, property_computation_dependencies); + return simplify_2_children(*this, m_x, m_y, context, resolution_context); } // https://drafts.csswg.org/css-values-4/#funcdef-atan2 @@ -1878,9 +1878,9 @@ PowCalculationNode::PowCalculationNode(NonnullRefPtr x, N PowCalculationNode::~PowCalculationNode() = default; -NonnullRefPtr PowCalculationNode::with_simplified_children(CalculationContext const& context, CalculationResolutionContext const& resolution_context, PropertyComputationDependencies* property_computation_dependencies) const +NonnullRefPtr PowCalculationNode::with_simplified_children(CalculationContext const& context, CalculationResolutionContext const& resolution_context) const { - return simplify_2_children(*this, m_x, m_y, context, resolution_context, property_computation_dependencies); + return simplify_2_children(*this, m_x, m_y, context, resolution_context); } // https://drafts.csswg.org/css-values-4/#funcdef-pow @@ -1933,9 +1933,9 @@ SqrtCalculationNode::SqrtCalculationNode(NonnullRefPtr va SqrtCalculationNode::~SqrtCalculationNode() = default; -NonnullRefPtr SqrtCalculationNode::with_simplified_children(CalculationContext const& context, CalculationResolutionContext const& resolution_context, PropertyComputationDependencies* property_computation_dependencies) const +NonnullRefPtr SqrtCalculationNode::with_simplified_children(CalculationContext const& context, CalculationResolutionContext const& resolution_context) const { - return simplify_child(*this, m_value, context, resolution_context, property_computation_dependencies); + return simplify_child(*this, m_value, context, resolution_context); } // https://drafts.csswg.org/css-values-4/#funcdef-sqrt @@ -1997,9 +1997,9 @@ bool HypotCalculationNode::contains_percentage() const return false; } -NonnullRefPtr HypotCalculationNode::with_simplified_children(CalculationContext const& context, CalculationResolutionContext const& resolution_context, PropertyComputationDependencies* property_computation_dependencies) const +NonnullRefPtr HypotCalculationNode::with_simplified_children(CalculationContext const& context, CalculationResolutionContext const& resolution_context) const { - return simplify_children_vector(*this, context, resolution_context, property_computation_dependencies); + return simplify_children_vector(*this, context, resolution_context); } // https://drafts.csswg.org/css-values-4/#funcdef-hypot @@ -2072,9 +2072,9 @@ LogCalculationNode::LogCalculationNode(NonnullRefPtr x, N LogCalculationNode::~LogCalculationNode() = default; -NonnullRefPtr LogCalculationNode::with_simplified_children(CalculationContext const& context, CalculationResolutionContext const& resolution_context, PropertyComputationDependencies* property_computation_dependencies) const +NonnullRefPtr LogCalculationNode::with_simplified_children(CalculationContext const& context, CalculationResolutionContext const& resolution_context) const { - return simplify_2_children(*this, m_x, m_y, context, resolution_context, property_computation_dependencies); + return simplify_2_children(*this, m_x, m_y, context, resolution_context); } // https://drafts.csswg.org/css-values-4/#funcdef-log @@ -2128,9 +2128,9 @@ ExpCalculationNode::ExpCalculationNode(NonnullRefPtr valu ExpCalculationNode::~ExpCalculationNode() = default; -NonnullRefPtr ExpCalculationNode::with_simplified_children(CalculationContext const& context, CalculationResolutionContext const& resolution_context, PropertyComputationDependencies* property_computation_dependencies) const +NonnullRefPtr ExpCalculationNode::with_simplified_children(CalculationContext const& context, CalculationResolutionContext const& resolution_context) const { - return simplify_child(*this, m_value, context, resolution_context, property_computation_dependencies); + return simplify_child(*this, m_value, context, resolution_context); } // https://drafts.csswg.org/css-values-4/#funcdef-exp @@ -2188,10 +2188,10 @@ bool RoundCalculationNode::contains_percentage() const return m_x->contains_percentage() || m_y->contains_percentage(); } -NonnullRefPtr RoundCalculationNode::with_simplified_children(CalculationContext const& context, CalculationResolutionContext const& resolution_context, PropertyComputationDependencies* property_computation_dependencies) const +NonnullRefPtr RoundCalculationNode::with_simplified_children(CalculationContext const& context, CalculationResolutionContext const& resolution_context) const { - auto simplified_x = simplify_a_calculation_tree(m_x, context, resolution_context, property_computation_dependencies); - auto simplified_y = simplify_a_calculation_tree(m_y, context, resolution_context, property_computation_dependencies); + auto simplified_x = simplify_a_calculation_tree(m_x, context, resolution_context); + auto simplified_y = simplify_a_calculation_tree(m_y, context, resolution_context); if (simplified_x != m_x || simplified_y != m_y) return create(m_strategy, move(simplified_x), move(simplified_y)); return *this; @@ -2359,9 +2359,9 @@ bool ModCalculationNode::contains_percentage() const return m_x->contains_percentage() || m_y->contains_percentage(); } -NonnullRefPtr ModCalculationNode::with_simplified_children(CalculationContext const& context, CalculationResolutionContext const& resolution_context, PropertyComputationDependencies* property_computation_dependencies) const +NonnullRefPtr ModCalculationNode::with_simplified_children(CalculationContext const& context, CalculationResolutionContext const& resolution_context) const { - return simplify_2_children(*this, m_x, m_y, context, resolution_context, property_computation_dependencies); + return simplify_2_children(*this, m_x, m_y, context, resolution_context); } enum class ModOrRem { @@ -2449,9 +2449,9 @@ bool RemCalculationNode::contains_percentage() const return m_x->contains_percentage() || m_y->contains_percentage(); } -NonnullRefPtr RemCalculationNode::with_simplified_children(CalculationContext const& context, CalculationResolutionContext const& resolution_context, PropertyComputationDependencies* property_computation_dependencies) const +NonnullRefPtr RemCalculationNode::with_simplified_children(CalculationContext const& context, CalculationResolutionContext const& resolution_context) const { - return simplify_2_children(*this, m_x, m_y, context, resolution_context, property_computation_dependencies); + return simplify_2_children(*this, m_x, m_y, context, resolution_context); } // https://drafts.csswg.org/css-values-4/#funcdef-mod @@ -2577,9 +2577,9 @@ String CalculatedStyleValue::to_string(SerializationMode serialization_mode) con return serialize_a_math_function(m_calculation, m_context, serialization_mode); } -ValueComparingNonnullRefPtr CalculatedStyleValue::absolutized(ComputationContext const& computation_context, PropertyComputationDependencies& property_computation_dependencies) const +ValueComparingNonnullRefPtr CalculatedStyleValue::absolutized(ComputationContext const& computation_context) const { - auto simplified_calculation_tree = simplify_a_calculation_tree(m_calculation, m_context, CalculationResolutionContext::from_computation_context(computation_context), &property_computation_dependencies); + auto simplified_calculation_tree = simplify_a_calculation_tree(m_calculation, m_context, CalculationResolutionContext::from_computation_context(computation_context)); auto const simplified_percentage_dimension_mix = [&]() -> Optional> { // NOTE: A percentage dimension mix is a SumCalculationNode with two NumericCalculationNode children which have @@ -2634,7 +2634,7 @@ Optional CalculatedStyleValue::resolve_valu { // The calculation tree is again simplified at used value time; with used value time information. // NOTE: Any nodes which rely on dynamic state should have been simplified away in absolutized so we can pass a nullptr here - auto simplified_tree = simplify_a_calculation_tree(m_calculation, m_context, resolution_context, nullptr); + auto simplified_tree = simplify_a_calculation_tree(m_calculation, m_context, resolution_context); if (!is(*simplified_tree)) return {}; @@ -2857,7 +2857,7 @@ static RefPtr make_calculation_node(CalculatedStyl } // https://drafts.csswg.org/css-values-4/#calc-simplification -NonnullRefPtr simplify_a_calculation_tree(CalculationNode const& original_root, CalculationContext const& context, CalculationResolutionContext const& resolution_context, PropertyComputationDependencies* property_computation_dependencies) +NonnullRefPtr simplify_a_calculation_tree(CalculationNode const& original_root, CalculationContext const& context, CalculationResolutionContext const& resolution_context) { // To simplify a calculation tree root: // FIXME: If needed, we could detect that nothing has changed and then return the original `root`, in more places. @@ -2968,7 +2968,7 @@ NonnullRefPtr simplify_a_calculation_tree(CalculationNode if (root->type() == CalculationNode::Type::NonMathFunction) { // 1. If there is enough information available to determine its numeric value, return its value, expressed in // the value’s canonical unit. - if (auto resolved_calculation_node = as(*root).function()->resolve_to_calculation_node(context, resolution_context, property_computation_dependencies)) + if (auto resolved_calculation_node = as(*root).function()->resolve_to_calculation_node(context, resolution_context)) return resolved_calculation_node.release_nonnull(); // 2. Otherwise, return root. @@ -2976,7 +2976,7 @@ NonnullRefPtr simplify_a_calculation_tree(CalculationNode } // 3. At this point, root is an operator node. Simplify all the calculation children of root. - root = root->with_simplified_children(context, resolution_context, property_computation_dependencies); + root = root->with_simplified_children(context, resolution_context); // 4. If root is an operator node that’s not one of the calc-operator nodes, and all of its calculation children // are numeric values with enough information to compute the operation root represents, return the result of diff --git a/Libraries/LibWeb/CSS/StyleValues/CalculatedStyleValue.h b/Libraries/LibWeb/CSS/StyleValues/CalculatedStyleValue.h index c61366b6d99..0f687a9b3a1 100644 --- a/Libraries/LibWeb/CSS/StyleValues/CalculatedStyleValue.h +++ b/Libraries/LibWeb/CSS/StyleValues/CalculatedStyleValue.h @@ -71,7 +71,7 @@ public: } virtual String to_string(SerializationMode) const override; - virtual ValueComparingNonnullRefPtr absolutized(ComputationContext const&, PropertyComputationDependencies&) const override; + virtual ValueComparingNonnullRefPtr absolutized(ComputationContext const&) const override; virtual bool equals(StyleValue const& other) const override; NonnullRefPtr calculation() const { return m_calculation; } @@ -245,7 +245,7 @@ public: Optional const& numeric_type() const { return m_numeric_type; } virtual bool contains_percentage() const = 0; - virtual NonnullRefPtr with_simplified_children(CalculationContext const&, CalculationResolutionContext const&, PropertyComputationDependencies*) const = 0; + virtual NonnullRefPtr with_simplified_children(CalculationContext const&, CalculationResolutionContext const&) const = 0; // Step 4 of simpliRfy_a_calculation_tree(). Only valid for math-function nodes. virtual Optional run_operation_if_possible(CalculationContext const&, CalculationResolutionContext const&) const { VERIFY_NOT_REACHED(); } @@ -275,7 +275,7 @@ public: virtual bool contains_percentage() const override; bool is_in_canonical_unit() const; - virtual NonnullRefPtr with_simplified_children(CalculationContext const&, CalculationResolutionContext const&, PropertyComputationDependencies*) const override { return *this; } + virtual NonnullRefPtr with_simplified_children(CalculationContext const&, CalculationResolutionContext const&) const override { return *this; } virtual Vector> children() const override { return {}; } NumericValue const& value() const { return m_value; } @@ -300,7 +300,7 @@ public: ~SumCalculationNode(); virtual bool contains_percentage() const override; - virtual NonnullRefPtr with_simplified_children(CalculationContext const&, CalculationResolutionContext const&, PropertyComputationDependencies*) const override; + virtual NonnullRefPtr with_simplified_children(CalculationContext const&, CalculationResolutionContext const&) const override; virtual Vector> children() const override { return m_values; } @@ -319,7 +319,7 @@ public: ~ProductCalculationNode(); virtual bool contains_percentage() const override; - virtual NonnullRefPtr with_simplified_children(CalculationContext const&, CalculationResolutionContext const&, PropertyComputationDependencies*) const override; + virtual NonnullRefPtr with_simplified_children(CalculationContext const&, CalculationResolutionContext const&) const override; virtual Vector> children() const override { return m_values; } @@ -338,7 +338,7 @@ public: ~NegateCalculationNode(); virtual bool contains_percentage() const override; - virtual NonnullRefPtr with_simplified_children(CalculationContext const&, CalculationResolutionContext const&, PropertyComputationDependencies*) const override; + virtual NonnullRefPtr with_simplified_children(CalculationContext const&, CalculationResolutionContext const&) const override; virtual Vector> children() const override { return { { m_value } }; } CalculationNode const& child() const { return m_value; } @@ -358,7 +358,7 @@ public: ~InvertCalculationNode(); virtual bool contains_percentage() const override; - virtual NonnullRefPtr with_simplified_children(CalculationContext const&, CalculationResolutionContext const&, PropertyComputationDependencies*) const override; + virtual NonnullRefPtr with_simplified_children(CalculationContext const&, CalculationResolutionContext const&) const override; virtual Vector> children() const override { return { { m_value } }; } CalculationNode const& child() const { return m_value; } @@ -378,7 +378,7 @@ public: ~MinCalculationNode(); virtual bool contains_percentage() const override; - virtual NonnullRefPtr with_simplified_children(CalculationContext const&, CalculationResolutionContext const&, PropertyComputationDependencies*) const override; + virtual NonnullRefPtr with_simplified_children(CalculationContext const&, CalculationResolutionContext const&) const override; virtual Optional run_operation_if_possible(CalculationContext const&, CalculationResolutionContext const&) const override; virtual Vector> children() const override { return m_values; } @@ -398,7 +398,7 @@ public: ~MaxCalculationNode(); virtual bool contains_percentage() const override; - virtual NonnullRefPtr with_simplified_children(CalculationContext const&, CalculationResolutionContext const&, PropertyComputationDependencies*) const override; + virtual NonnullRefPtr with_simplified_children(CalculationContext const&, CalculationResolutionContext const&) const override; virtual Optional run_operation_if_possible(CalculationContext const&, CalculationResolutionContext const&) const override; virtual Vector> children() const override { return m_values; } @@ -418,7 +418,7 @@ public: ~ClampCalculationNode(); virtual bool contains_percentage() const override; - virtual NonnullRefPtr with_simplified_children(CalculationContext const&, CalculationResolutionContext const&, PropertyComputationDependencies*) const override; + virtual NonnullRefPtr with_simplified_children(CalculationContext const&, CalculationResolutionContext const&) const override; virtual Optional run_operation_if_possible(CalculationContext const&, CalculationResolutionContext const&) const override; virtual Vector> children() const override { return { { m_min_value, m_center_value, m_max_value } }; } @@ -440,7 +440,7 @@ public: ~AbsCalculationNode(); virtual bool contains_percentage() const override; - virtual NonnullRefPtr with_simplified_children(CalculationContext const&, CalculationResolutionContext const&, PropertyComputationDependencies*) const override; + virtual NonnullRefPtr with_simplified_children(CalculationContext const&, CalculationResolutionContext const&) const override; virtual Optional run_operation_if_possible(CalculationContext const&, CalculationResolutionContext const&) const override; virtual Vector> children() const override { return { { m_value } }; } @@ -459,7 +459,7 @@ public: ~SignCalculationNode(); virtual bool contains_percentage() const override; - virtual NonnullRefPtr with_simplified_children(CalculationContext const&, CalculationResolutionContext const&, PropertyComputationDependencies*) const override; + virtual NonnullRefPtr with_simplified_children(CalculationContext const&, CalculationResolutionContext const&) const override; virtual Optional run_operation_if_possible(CalculationContext const&, CalculationResolutionContext const&) const override; virtual Vector> children() const override { return { { m_value } }; } @@ -478,7 +478,7 @@ public: ~SinCalculationNode(); virtual bool contains_percentage() const override; - virtual NonnullRefPtr with_simplified_children(CalculationContext const&, CalculationResolutionContext const&, PropertyComputationDependencies*) const override; + virtual NonnullRefPtr with_simplified_children(CalculationContext const&, CalculationResolutionContext const&) const override; virtual Optional run_operation_if_possible(CalculationContext const&, CalculationResolutionContext const&) const override; virtual Vector> children() const override { return { { m_value } }; } @@ -497,7 +497,7 @@ public: ~CosCalculationNode(); virtual bool contains_percentage() const override; - virtual NonnullRefPtr with_simplified_children(CalculationContext const&, CalculationResolutionContext const&, PropertyComputationDependencies*) const override; + virtual NonnullRefPtr with_simplified_children(CalculationContext const&, CalculationResolutionContext const&) const override; virtual Optional run_operation_if_possible(CalculationContext const&, CalculationResolutionContext const&) const override; virtual Vector> children() const override { return { { m_value } }; } @@ -516,7 +516,7 @@ public: ~TanCalculationNode(); virtual bool contains_percentage() const override; - virtual NonnullRefPtr with_simplified_children(CalculationContext const&, CalculationResolutionContext const&, PropertyComputationDependencies*) const override; + virtual NonnullRefPtr with_simplified_children(CalculationContext const&, CalculationResolutionContext const&) const override; virtual Optional run_operation_if_possible(CalculationContext const&, CalculationResolutionContext const&) const override; virtual Vector> children() const override { return { { m_value } }; } @@ -535,7 +535,7 @@ public: ~AsinCalculationNode(); virtual bool contains_percentage() const override; - virtual NonnullRefPtr with_simplified_children(CalculationContext const&, CalculationResolutionContext const&, PropertyComputationDependencies*) const override; + virtual NonnullRefPtr with_simplified_children(CalculationContext const&, CalculationResolutionContext const&) const override; virtual Optional run_operation_if_possible(CalculationContext const&, CalculationResolutionContext const&) const override; virtual Vector> children() const override { return { { m_value } }; } @@ -554,7 +554,7 @@ public: ~AcosCalculationNode(); virtual bool contains_percentage() const override; - virtual NonnullRefPtr with_simplified_children(CalculationContext const&, CalculationResolutionContext const&, PropertyComputationDependencies*) const override; + virtual NonnullRefPtr with_simplified_children(CalculationContext const&, CalculationResolutionContext const&) const override; virtual Optional run_operation_if_possible(CalculationContext const&, CalculationResolutionContext const&) const override; virtual Vector> children() const override { return { { m_value } }; } @@ -573,7 +573,7 @@ public: ~AtanCalculationNode(); virtual bool contains_percentage() const override; - virtual NonnullRefPtr with_simplified_children(CalculationContext const&, CalculationResolutionContext const&, PropertyComputationDependencies*) const override; + virtual NonnullRefPtr with_simplified_children(CalculationContext const&, CalculationResolutionContext const&) const override; virtual Optional run_operation_if_possible(CalculationContext const&, CalculationResolutionContext const&) const override; virtual Vector> children() const override { return { { m_value } }; } @@ -592,7 +592,7 @@ public: ~Atan2CalculationNode(); virtual bool contains_percentage() const override; - virtual NonnullRefPtr with_simplified_children(CalculationContext const&, CalculationResolutionContext const&, PropertyComputationDependencies*) const override; + virtual NonnullRefPtr with_simplified_children(CalculationContext const&, CalculationResolutionContext const&) const override; virtual Optional run_operation_if_possible(CalculationContext const&, CalculationResolutionContext const&) const override; virtual Vector> children() const override { return { { m_y, m_x } }; } @@ -612,7 +612,7 @@ public: ~PowCalculationNode(); virtual bool contains_percentage() const override { return false; } - virtual NonnullRefPtr with_simplified_children(CalculationContext const&, CalculationResolutionContext const&, PropertyComputationDependencies*) const override; + virtual NonnullRefPtr with_simplified_children(CalculationContext const&, CalculationResolutionContext const&) const override; virtual Optional run_operation_if_possible(CalculationContext const&, CalculationResolutionContext const&) const override; virtual Vector> children() const override { return { { m_x, m_y } }; } @@ -632,7 +632,7 @@ public: ~SqrtCalculationNode(); virtual bool contains_percentage() const override { return false; } - virtual NonnullRefPtr with_simplified_children(CalculationContext const&, CalculationResolutionContext const&, PropertyComputationDependencies*) const override; + virtual NonnullRefPtr with_simplified_children(CalculationContext const&, CalculationResolutionContext const&) const override; virtual Optional run_operation_if_possible(CalculationContext const&, CalculationResolutionContext const&) const override; virtual Vector> children() const override { return { { m_value } }; } @@ -651,7 +651,7 @@ public: ~HypotCalculationNode(); virtual bool contains_percentage() const override; - virtual NonnullRefPtr with_simplified_children(CalculationContext const&, CalculationResolutionContext const&, PropertyComputationDependencies*) const override; + virtual NonnullRefPtr with_simplified_children(CalculationContext const&, CalculationResolutionContext const&) const override; virtual Optional run_operation_if_possible(CalculationContext const&, CalculationResolutionContext const&) const override; virtual Vector> children() const override { return m_values; } @@ -670,7 +670,7 @@ public: ~LogCalculationNode(); virtual bool contains_percentage() const override { return false; } - virtual NonnullRefPtr with_simplified_children(CalculationContext const&, CalculationResolutionContext const&, PropertyComputationDependencies*) const override; + virtual NonnullRefPtr with_simplified_children(CalculationContext const&, CalculationResolutionContext const&) const override; virtual Optional run_operation_if_possible(CalculationContext const&, CalculationResolutionContext const&) const override; virtual Vector> children() const override { return { { m_x, m_y } }; } @@ -690,7 +690,7 @@ public: ~ExpCalculationNode(); virtual bool contains_percentage() const override { return false; } - virtual NonnullRefPtr with_simplified_children(CalculationContext const&, CalculationResolutionContext const&, PropertyComputationDependencies*) const override; + virtual NonnullRefPtr with_simplified_children(CalculationContext const&, CalculationResolutionContext const&) const override; virtual Optional run_operation_if_possible(CalculationContext const&, CalculationResolutionContext const&) const override; virtual Vector> children() const override { return { { m_value } }; } @@ -709,7 +709,7 @@ public: ~RoundCalculationNode(); virtual bool contains_percentage() const override; - virtual NonnullRefPtr with_simplified_children(CalculationContext const&, CalculationResolutionContext const&, PropertyComputationDependencies*) const override; + virtual NonnullRefPtr with_simplified_children(CalculationContext const&, CalculationResolutionContext const&) const override; virtual Optional run_operation_if_possible(CalculationContext const&, CalculationResolutionContext const&) const override; // NOTE: This excludes the rounding strategy! @@ -732,7 +732,7 @@ public: ~ModCalculationNode(); virtual bool contains_percentage() const override; - virtual NonnullRefPtr with_simplified_children(CalculationContext const&, CalculationResolutionContext const&, PropertyComputationDependencies*) const override; + virtual NonnullRefPtr with_simplified_children(CalculationContext const&, CalculationResolutionContext const&) const override; virtual Optional run_operation_if_possible(CalculationContext const&, CalculationResolutionContext const&) const override; virtual Vector> children() const override { return { { m_x, m_y } }; } @@ -752,7 +752,7 @@ public: ~RemCalculationNode(); virtual bool contains_percentage() const override; - virtual NonnullRefPtr with_simplified_children(CalculationContext const&, CalculationResolutionContext const&, PropertyComputationDependencies*) const override; + virtual NonnullRefPtr with_simplified_children(CalculationContext const&, CalculationResolutionContext const&) const override; virtual Optional run_operation_if_possible(CalculationContext const&, CalculationResolutionContext const&) const override; virtual Vector> children() const override { return { { m_x, m_y } }; } @@ -772,7 +772,7 @@ public: ~NonMathFunctionCalculationNode(); virtual bool contains_percentage() const override { return false; } - virtual NonnullRefPtr with_simplified_children(CalculationContext const&, CalculationResolutionContext const&, PropertyComputationDependencies*) const override { return *this; } + virtual NonnullRefPtr with_simplified_children(CalculationContext const&, CalculationResolutionContext const&) const override { return *this; } virtual Vector> children() const override { return {}; } virtual void dump(StringBuilder&, int indent) const override; @@ -786,6 +786,6 @@ private: }; // https://drafts.csswg.org/css-values-4/#calc-simplification -NonnullRefPtr simplify_a_calculation_tree(CalculationNode const& root, CalculationContext const& context, CalculationResolutionContext const& resolution_context, PropertyComputationDependencies* property_computation_dependencies); +NonnullRefPtr simplify_a_calculation_tree(CalculationNode const& root, CalculationContext const& context, CalculationResolutionContext const& resolution_context); } diff --git a/Libraries/LibWeb/CSS/StyleValues/CounterDefinitionsStyleValue.cpp b/Libraries/LibWeb/CSS/StyleValues/CounterDefinitionsStyleValue.cpp index d347e0dedcf..68e955f244d 100644 --- a/Libraries/LibWeb/CSS/StyleValues/CounterDefinitionsStyleValue.cpp +++ b/Libraries/LibWeb/CSS/StyleValues/CounterDefinitionsStyleValue.cpp @@ -29,7 +29,7 @@ String CounterDefinitionsStyleValue::to_string(SerializationMode mode) const return stb.to_string_without_validation(); } -ValueComparingNonnullRefPtr CounterDefinitionsStyleValue::absolutized(ComputationContext const& computation_context, PropertyComputationDependencies& property_computation_dependencies) const +ValueComparingNonnullRefPtr CounterDefinitionsStyleValue::absolutized(ComputationContext const& computation_context) const { Vector computed_definitions; @@ -41,7 +41,7 @@ ValueComparingNonnullRefPtr CounterDefinitionsStyleValue::abso }; if (specified_definition.value) - computed_definition.value = specified_definition.value->absolutized(computation_context, property_computation_dependencies); + computed_definition.value = specified_definition.value->absolutized(computation_context); computed_definitions.append(computed_definition); } diff --git a/Libraries/LibWeb/CSS/StyleValues/CounterDefinitionsStyleValue.h b/Libraries/LibWeb/CSS/StyleValues/CounterDefinitionsStyleValue.h index 0e0a5872510..cf8706a1ad9 100644 --- a/Libraries/LibWeb/CSS/StyleValues/CounterDefinitionsStyleValue.h +++ b/Libraries/LibWeb/CSS/StyleValues/CounterDefinitionsStyleValue.h @@ -31,7 +31,7 @@ public: auto const& counter_definitions() const { return m_counter_definitions; } virtual String to_string(SerializationMode) const override; - virtual ValueComparingNonnullRefPtr absolutized(ComputationContext const&, PropertyComputationDependencies&) const override; + virtual ValueComparingNonnullRefPtr absolutized(ComputationContext const&) const override; bool properties_equal(CounterDefinitionsStyleValue const& other) const; diff --git a/Libraries/LibWeb/CSS/StyleValues/CursorStyleValue.cpp b/Libraries/LibWeb/CSS/StyleValues/CursorStyleValue.cpp index 9bfadac0c7f..b16e015f5d5 100644 --- a/Libraries/LibWeb/CSS/StyleValues/CursorStyleValue.cpp +++ b/Libraries/LibWeb/CSS/StyleValues/CursorStyleValue.cpp @@ -30,18 +30,18 @@ String CursorStyleValue::to_string(SerializationMode mode) const return builder.to_string_without_validation(); } -ValueComparingNonnullRefPtr CursorStyleValue::absolutized(ComputationContext const& computation_context, PropertyComputationDependencies& property_computation_dependencies) const +ValueComparingNonnullRefPtr CursorStyleValue::absolutized(ComputationContext const& computation_context) const { RefPtr absolutized_x; RefPtr absolutized_y; if (m_properties.x) - absolutized_x = m_properties.x->absolutized(computation_context, property_computation_dependencies); + absolutized_x = m_properties.x->absolutized(computation_context); if (m_properties.y) - absolutized_y = m_properties.y->absolutized(computation_context, property_computation_dependencies); + absolutized_y = m_properties.y->absolutized(computation_context); - return CursorStyleValue::create(m_properties.image->absolutized(computation_context, property_computation_dependencies)->as_abstract_image(), absolutized_x, absolutized_y); + return CursorStyleValue::create(m_properties.image->absolutized(computation_context)->as_abstract_image(), absolutized_x, absolutized_y); } Optional CursorStyleValue::make_image_cursor(Layout::NodeWithStyle const& layout_node) const diff --git a/Libraries/LibWeb/CSS/StyleValues/CursorStyleValue.h b/Libraries/LibWeb/CSS/StyleValues/CursorStyleValue.h index 09419d0a3c7..53899f7f93c 100644 --- a/Libraries/LibWeb/CSS/StyleValues/CursorStyleValue.h +++ b/Libraries/LibWeb/CSS/StyleValues/CursorStyleValue.h @@ -30,7 +30,7 @@ public: virtual String to_string(SerializationMode) const override; - virtual ValueComparingNonnullRefPtr absolutized(ComputationContext const&, PropertyComputationDependencies&) const override; + virtual ValueComparingNonnullRefPtr absolutized(ComputationContext const&) const override; bool properties_equal(CursorStyleValue const& other) const { return m_properties == other.m_properties; } diff --git a/Libraries/LibWeb/CSS/StyleValues/EasingStyleValue.cpp b/Libraries/LibWeb/CSS/StyleValues/EasingStyleValue.cpp index f14d059c3a6..d7aa3620be5 100644 --- a/Libraries/LibWeb/CSS/StyleValues/EasingStyleValue.cpp +++ b/Libraries/LibWeb/CSS/StyleValues/EasingStyleValue.cpp @@ -84,7 +84,7 @@ String EasingStyleValue::Function::to_string(SerializationMode mode) const }); } -ValueComparingNonnullRefPtr EasingStyleValue::absolutized(ComputationContext const& computation_context, PropertyComputationDependencies& property_computation_dependencies) const +ValueComparingNonnullRefPtr EasingStyleValue::absolutized(ComputationContext const& computation_context) const { auto const& absolutized_function = m_function.visit( [&](Linear const& linear) -> Function { @@ -94,24 +94,24 @@ ValueComparingNonnullRefPtr EasingStyleValue::absolutized(Comp RefPtr absolutized_input; if (stop.input) - absolutized_input = stop.input->absolutized(computation_context, property_computation_dependencies); + absolutized_input = stop.input->absolutized(computation_context); - absolutized_stops.append({ stop.output->absolutized(computation_context, property_computation_dependencies), absolutized_input }); + absolutized_stops.append({ stop.output->absolutized(computation_context), absolutized_input }); } return Linear { absolutized_stops }; }, [&](CubicBezier const& cubic_bezier) -> Function { return CubicBezier { - cubic_bezier.x1->absolutized(computation_context, property_computation_dependencies), - cubic_bezier.y1->absolutized(computation_context, property_computation_dependencies), - cubic_bezier.x2->absolutized(computation_context, property_computation_dependencies), - cubic_bezier.y2->absolutized(computation_context, property_computation_dependencies) + cubic_bezier.x1->absolutized(computation_context), + cubic_bezier.y1->absolutized(computation_context), + cubic_bezier.x2->absolutized(computation_context), + cubic_bezier.y2->absolutized(computation_context) }; }, [&](Steps const& steps) -> Function { return Steps { - steps.number_of_intervals->absolutized(computation_context, property_computation_dependencies), + steps.number_of_intervals->absolutized(computation_context), steps.position }; }); diff --git a/Libraries/LibWeb/CSS/StyleValues/EasingStyleValue.h b/Libraries/LibWeb/CSS/StyleValues/EasingStyleValue.h index 87af6141ec1..1e61e1aacb2 100644 --- a/Libraries/LibWeb/CSS/StyleValues/EasingStyleValue.h +++ b/Libraries/LibWeb/CSS/StyleValues/EasingStyleValue.h @@ -80,7 +80,7 @@ public: virtual String to_string(SerializationMode mode) const override { return m_function.to_string(mode); } - virtual ValueComparingNonnullRefPtr absolutized(ComputationContext const&, PropertyComputationDependencies&) const override; + virtual ValueComparingNonnullRefPtr absolutized(ComputationContext const&) const override; bool properties_equal(EasingStyleValue const& other) const { return m_function == other.m_function; } diff --git a/Libraries/LibWeb/CSS/StyleValues/FontStyleStyleValue.cpp b/Libraries/LibWeb/CSS/StyleValues/FontStyleStyleValue.cpp index 3d2228527b4..a8e67b68b96 100644 --- a/Libraries/LibWeb/CSS/StyleValues/FontStyleStyleValue.cpp +++ b/Libraries/LibWeb/CSS/StyleValues/FontStyleStyleValue.cpp @@ -56,12 +56,12 @@ String FontStyleStyleValue::to_string(SerializationMode mode) const return MUST(builder.to_string()); } -ValueComparingNonnullRefPtr FontStyleStyleValue::absolutized(ComputationContext const& computation_context, PropertyComputationDependencies& property_computation_dependencies) const +ValueComparingNonnullRefPtr FontStyleStyleValue::absolutized(ComputationContext const& computation_context) const { ValueComparingRefPtr absolutized_angle; if (m_angle_value) - absolutized_angle = m_angle_value->absolutized(computation_context, property_computation_dependencies); + absolutized_angle = m_angle_value->absolutized(computation_context); if (absolutized_angle == m_angle_value) return *this; diff --git a/Libraries/LibWeb/CSS/StyleValues/FontStyleStyleValue.h b/Libraries/LibWeb/CSS/StyleValues/FontStyleStyleValue.h index d573333d3fd..06b43302b16 100644 --- a/Libraries/LibWeb/CSS/StyleValues/FontStyleStyleValue.h +++ b/Libraries/LibWeb/CSS/StyleValues/FontStyleStyleValue.h @@ -26,7 +26,7 @@ public: int to_font_slope() const; virtual String to_string(SerializationMode) const override; - virtual ValueComparingNonnullRefPtr absolutized(ComputationContext const& computation_context, PropertyComputationDependencies&) const override; + virtual ValueComparingNonnullRefPtr absolutized(ComputationContext const& computation_context) const override; bool equals(StyleValue const& other) const override { diff --git a/Libraries/LibWeb/CSS/StyleValues/ImageStyleValue.cpp b/Libraries/LibWeb/CSS/StyleValues/ImageStyleValue.cpp index 3064906d650..786d100a548 100644 --- a/Libraries/LibWeb/CSS/StyleValues/ImageStyleValue.cpp +++ b/Libraries/LibWeb/CSS/StyleValues/ImageStyleValue.cpp @@ -186,7 +186,7 @@ void ImageStyleValue::set_style_sheet(GC::Ptr style_sheet) m_style_sheet = style_sheet; } -ValueComparingNonnullRefPtr ImageStyleValue::absolutized(ComputationContext const&, PropertyComputationDependencies&) const +ValueComparingNonnullRefPtr ImageStyleValue::absolutized(ComputationContext const&) const { if (m_url.url().is_empty()) return *this; diff --git a/Libraries/LibWeb/CSS/StyleValues/ImageStyleValue.h b/Libraries/LibWeb/CSS/StyleValues/ImageStyleValue.h index 91cec0e35c2..cc1939f40a2 100644 --- a/Libraries/LibWeb/CSS/StyleValues/ImageStyleValue.h +++ b/Libraries/LibWeb/CSS/StyleValues/ImageStyleValue.h @@ -72,7 +72,7 @@ private: virtual void set_style_sheet(GC::Ptr) override; - virtual ValueComparingNonnullRefPtr absolutized(ComputationContext const&, PropertyComputationDependencies&) const override; + virtual ValueComparingNonnullRefPtr absolutized(ComputationContext const&) const override; void animate(); Gfx::ImmutableBitmap const* bitmap(size_t frame_index, Gfx::IntSize = {}) const; diff --git a/Libraries/LibWeb/CSS/StyleValues/LengthStyleValue.cpp b/Libraries/LibWeb/CSS/StyleValues/LengthStyleValue.cpp index cbd7b9995f4..0af2b2ab648 100644 --- a/Libraries/LibWeb/CSS/StyleValues/LengthStyleValue.cpp +++ b/Libraries/LibWeb/CSS/StyleValues/LengthStyleValue.cpp @@ -26,7 +26,7 @@ ValueComparingNonnullRefPtr LengthStyleValue::create(Len return adopt_ref(*new (nothrow) LengthStyleValue(length)); } -ValueComparingNonnullRefPtr LengthStyleValue::absolutized(ComputationContext const& computation_context, PropertyComputationDependencies&) const +ValueComparingNonnullRefPtr LengthStyleValue::absolutized(ComputationContext const& computation_context) const { if (auto length = m_length.absolutize(computation_context.length_resolution_context.viewport_rect, computation_context.length_resolution_context.font_metrics, computation_context.length_resolution_context.root_font_metrics); length.has_value()) return LengthStyleValue::create(length.release_value()); diff --git a/Libraries/LibWeb/CSS/StyleValues/LengthStyleValue.h b/Libraries/LibWeb/CSS/StyleValues/LengthStyleValue.h index cf92c4c2b81..e274483f58f 100644 --- a/Libraries/LibWeb/CSS/StyleValues/LengthStyleValue.h +++ b/Libraries/LibWeb/CSS/StyleValues/LengthStyleValue.h @@ -25,7 +25,7 @@ public: virtual FlyString unit_name() const override { return m_length.unit_name(); } virtual String to_string(SerializationMode serialization_mode) const override { return m_length.to_string(serialization_mode); } - virtual ValueComparingNonnullRefPtr absolutized(ComputationContext const&, PropertyComputationDependencies&) const override; + virtual ValueComparingNonnullRefPtr absolutized(ComputationContext const&) const override; bool equals(StyleValue const& other) const override; diff --git a/Libraries/LibWeb/CSS/StyleValues/OpenTypeTaggedStyleValue.cpp b/Libraries/LibWeb/CSS/StyleValues/OpenTypeTaggedStyleValue.cpp index 5b9ca30dcee..bb8059ef34c 100644 --- a/Libraries/LibWeb/CSS/StyleValues/OpenTypeTaggedStyleValue.cpp +++ b/Libraries/LibWeb/CSS/StyleValues/OpenTypeTaggedStyleValue.cpp @@ -9,9 +9,9 @@ namespace Web::CSS { -ValueComparingNonnullRefPtr OpenTypeTaggedStyleValue::absolutized(ComputationContext const& computation_context, PropertyComputationDependencies& property_computation_dependencies) const +ValueComparingNonnullRefPtr OpenTypeTaggedStyleValue::absolutized(ComputationContext const& computation_context) const { - auto const& absolutized_value = m_value->absolutized(computation_context, property_computation_dependencies); + auto const& absolutized_value = m_value->absolutized(computation_context); if (absolutized_value == m_value) return *this; diff --git a/Libraries/LibWeb/CSS/StyleValues/OpenTypeTaggedStyleValue.h b/Libraries/LibWeb/CSS/StyleValues/OpenTypeTaggedStyleValue.h index 5aab75b2c2f..7cc34e561e9 100644 --- a/Libraries/LibWeb/CSS/StyleValues/OpenTypeTaggedStyleValue.h +++ b/Libraries/LibWeb/CSS/StyleValues/OpenTypeTaggedStyleValue.h @@ -29,7 +29,7 @@ public: FlyString const& tag() const { return m_tag; } ValueComparingNonnullRefPtr const& value() const { return m_value; } - virtual ValueComparingNonnullRefPtr absolutized(ComputationContext const&, PropertyComputationDependencies&) const override; + virtual ValueComparingNonnullRefPtr absolutized(ComputationContext const&) const override; virtual String to_string(SerializationMode) const override; diff --git a/Libraries/LibWeb/CSS/StyleValues/ShadowStyleValue.cpp b/Libraries/LibWeb/CSS/StyleValues/ShadowStyleValue.cpp index af60d474d91..ba1374fe315 100644 --- a/Libraries/LibWeb/CSS/StyleValues/ShadowStyleValue.cpp +++ b/Libraries/LibWeb/CSS/StyleValues/ShadowStyleValue.cpp @@ -56,12 +56,12 @@ ValueComparingNonnullRefPtr ShadowStyleValue::spread_distance( return *m_properties.spread_distance; } -ValueComparingNonnullRefPtr ShadowStyleValue::absolutized(ComputationContext const& computation_context, PropertyComputationDependencies& property_computation_dependencies) const +ValueComparingNonnullRefPtr ShadowStyleValue::absolutized(ComputationContext const& computation_context) const { - auto absolutized_offset_x = offset_x()->absolutized(computation_context, property_computation_dependencies); - auto absolutized_offset_y = offset_y()->absolutized(computation_context, property_computation_dependencies); - auto absolutized_blur_radius = blur_radius()->absolutized(computation_context, property_computation_dependencies); - auto absolutized_spread_distance = spread_distance()->absolutized(computation_context, property_computation_dependencies); + auto absolutized_offset_x = offset_x()->absolutized(computation_context); + auto absolutized_offset_y = offset_y()->absolutized(computation_context); + auto absolutized_blur_radius = blur_radius()->absolutized(computation_context); + auto absolutized_spread_distance = spread_distance()->absolutized(computation_context); return create(m_properties.shadow_type, color(), absolutized_offset_x, absolutized_offset_y, absolutized_blur_radius, absolutized_spread_distance, placement()); } diff --git a/Libraries/LibWeb/CSS/StyleValues/ShadowStyleValue.h b/Libraries/LibWeb/CSS/StyleValues/ShadowStyleValue.h index e5938cebaa2..c98e2f46c8a 100644 --- a/Libraries/LibWeb/CSS/StyleValues/ShadowStyleValue.h +++ b/Libraries/LibWeb/CSS/StyleValues/ShadowStyleValue.h @@ -76,7 +76,7 @@ private: { } - virtual ValueComparingNonnullRefPtr absolutized(ComputationContext const&, PropertyComputationDependencies&) const override; + virtual ValueComparingNonnullRefPtr absolutized(ComputationContext const&) const override; struct Properties { ShadowType shadow_type; ValueComparingRefPtr color; diff --git a/Libraries/LibWeb/CSS/StyleValues/StyleValue.cpp b/Libraries/LibWeb/CSS/StyleValues/StyleValue.cpp index ebb237ce814..1c8ad466cff 100644 --- a/Libraries/LibWeb/CSS/StyleValues/StyleValue.cpp +++ b/Libraries/LibWeb/CSS/StyleValues/StyleValue.cpp @@ -130,7 +130,7 @@ DimensionStyleValue const& StyleValue::as_dimension() const ENUMERATE_CSS_STYLE_VALUE_TYPES #undef __ENUMERATE_CSS_STYLE_VALUE_TYPE -ValueComparingNonnullRefPtr StyleValue::absolutized(ComputationContext const&, PropertyComputationDependencies&) const +ValueComparingNonnullRefPtr StyleValue::absolutized(ComputationContext const&) const { return *this; } diff --git a/Libraries/LibWeb/CSS/StyleValues/StyleValue.h b/Libraries/LibWeb/CSS/StyleValues/StyleValue.h index 77cbfaaddcd..fa28326743e 100644 --- a/Libraries/LibWeb/CSS/StyleValues/StyleValue.h +++ b/Libraries/LibWeb/CSS/StyleValues/StyleValue.h @@ -157,10 +157,6 @@ struct ColorResolutionContext { [[nodiscard]] static ColorResolutionContext for_layout_node_with_style(Layout::NodeWithStyle const&); }; -struct PropertyComputationDependencies { - bool tree_counting_function : 1 { false }; -}; - class WEB_API StyleValue : public RefCounted { public: virtual ~StyleValue() = default; @@ -208,7 +204,7 @@ public: bool has_auto() const; virtual bool has_color() const { return false; } - virtual ValueComparingNonnullRefPtr absolutized(ComputationContext const&, PropertyComputationDependencies&) const; + virtual ValueComparingNonnullRefPtr absolutized(ComputationContext const&) const; virtual Optional to_color(ColorResolutionContext) const { return {}; } Keyword to_keyword() const; diff --git a/Libraries/LibWeb/CSS/StyleValues/StyleValueList.cpp b/Libraries/LibWeb/CSS/StyleValues/StyleValueList.cpp index 30f223cf2fc..0b9f5158a11 100644 --- a/Libraries/LibWeb/CSS/StyleValues/StyleValueList.cpp +++ b/Libraries/LibWeb/CSS/StyleValues/StyleValueList.cpp @@ -22,13 +22,13 @@ bool StyleValueList::Properties::operator==(Properties const& other) const return separator == other.separator && values.span() == other.values.span(); } -ValueComparingNonnullRefPtr StyleValueList::absolutized(ComputationContext const& computation_context, PropertyComputationDependencies& property_computation_dependencies) const +ValueComparingNonnullRefPtr StyleValueList::absolutized(ComputationContext const& computation_context) const { StyleValueVector absolutized_style_values; absolutized_style_values.ensure_capacity(m_properties.values.size()); for (auto const& value : m_properties.values) - absolutized_style_values.append(value->absolutized(computation_context, property_computation_dependencies)); + absolutized_style_values.append(value->absolutized(computation_context)); return StyleValueList::create(move(absolutized_style_values), m_properties.separator); } diff --git a/Libraries/LibWeb/CSS/StyleValues/StyleValueList.h b/Libraries/LibWeb/CSS/StyleValues/StyleValueList.h index 5df1dc95732..519dae4f7fb 100644 --- a/Libraries/LibWeb/CSS/StyleValues/StyleValueList.h +++ b/Libraries/LibWeb/CSS/StyleValues/StyleValueList.h @@ -37,7 +37,7 @@ public: virtual Vector tokenize() const override; virtual GC::Ref reify(JS::Realm&, FlyString const& associated_property) const override; - virtual ValueComparingNonnullRefPtr absolutized(ComputationContext const&, PropertyComputationDependencies&) const override; + virtual ValueComparingNonnullRefPtr absolutized(ComputationContext const&) const override; bool properties_equal(StyleValueList const& other) const { return m_properties == other.m_properties; } diff --git a/Libraries/LibWeb/CSS/StyleValues/SuperellipseStyleValue.cpp b/Libraries/LibWeb/CSS/StyleValues/SuperellipseStyleValue.cpp index 65da401cdd8..15bb6c94919 100644 --- a/Libraries/LibWeb/CSS/StyleValues/SuperellipseStyleValue.cpp +++ b/Libraries/LibWeb/CSS/StyleValues/SuperellipseStyleValue.cpp @@ -50,9 +50,9 @@ String SuperellipseStyleValue::to_string(SerializationMode mode) const return MUST(String::formatted("superellipse({})", stringified_parameter)); } -ValueComparingNonnullRefPtr SuperellipseStyleValue::absolutized(ComputationContext const& computation_context, PropertyComputationDependencies& property_computation_dependencies) const +ValueComparingNonnullRefPtr SuperellipseStyleValue::absolutized(ComputationContext const& computation_context) const { - auto const& absolutized_parameter = m_parameter->absolutized(computation_context, property_computation_dependencies); + auto const& absolutized_parameter = m_parameter->absolutized(computation_context); if (absolutized_parameter == m_parameter) return *this; diff --git a/Libraries/LibWeb/CSS/StyleValues/SuperellipseStyleValue.h b/Libraries/LibWeb/CSS/StyleValues/SuperellipseStyleValue.h index 12e53148d3e..f18283832b0 100644 --- a/Libraries/LibWeb/CSS/StyleValues/SuperellipseStyleValue.h +++ b/Libraries/LibWeb/CSS/StyleValues/SuperellipseStyleValue.h @@ -31,7 +31,7 @@ public: virtual String to_string(SerializationMode serialization_mode) const override; - virtual ValueComparingNonnullRefPtr absolutized(ComputationContext const&, PropertyComputationDependencies&) const override; + virtual ValueComparingNonnullRefPtr absolutized(ComputationContext const&) const override; bool properties_equal(SuperellipseStyleValue const& other) const { return m_parameter == other.m_parameter; } diff --git a/Libraries/LibWeb/CSS/StyleValues/TransformationStyleValue.cpp b/Libraries/LibWeb/CSS/StyleValues/TransformationStyleValue.cpp index 109c5fc61a1..de722211528 100644 --- a/Libraries/LibWeb/CSS/StyleValues/TransformationStyleValue.cpp +++ b/Libraries/LibWeb/CSS/StyleValues/TransformationStyleValue.cpp @@ -375,14 +375,14 @@ GC::Ref TransformationStyleValue::reify_a_transform_funct VERIFY_NOT_REACHED(); } -ValueComparingNonnullRefPtr TransformationStyleValue::absolutized(ComputationContext const& computation_context, PropertyComputationDependencies& property_computation_dependencies) const +ValueComparingNonnullRefPtr TransformationStyleValue::absolutized(ComputationContext const& computation_context) const { StyleValueVector absolutized_values; bool absolutized_values_different = false; for (auto const& value : m_properties.values) { - auto const& absolutized_value = value->absolutized(computation_context, property_computation_dependencies); + auto const& absolutized_value = value->absolutized(computation_context); if (absolutized_value != value) absolutized_values_different = true; diff --git a/Libraries/LibWeb/CSS/StyleValues/TransformationStyleValue.h b/Libraries/LibWeb/CSS/StyleValues/TransformationStyleValue.h index e27fe229111..7a26378b9d1 100644 --- a/Libraries/LibWeb/CSS/StyleValues/TransformationStyleValue.h +++ b/Libraries/LibWeb/CSS/StyleValues/TransformationStyleValue.h @@ -30,7 +30,7 @@ public: virtual String to_string(SerializationMode) const override; GC::Ref reify_a_transform_function(JS::Realm&) const; - virtual ValueComparingNonnullRefPtr absolutized(ComputationContext const&, PropertyComputationDependencies&) const override; + virtual ValueComparingNonnullRefPtr absolutized(ComputationContext const&) const override; bool properties_equal(TransformationStyleValue const& other) const { return m_properties == other.m_properties; } diff --git a/Libraries/LibWeb/CSS/StyleValues/TreeCountingFunctionStyleValue.cpp b/Libraries/LibWeb/CSS/StyleValues/TreeCountingFunctionStyleValue.cpp index 408aa3093b1..c3e0a39a13c 100644 --- a/Libraries/LibWeb/CSS/StyleValues/TreeCountingFunctionStyleValue.cpp +++ b/Libraries/LibWeb/CSS/StyleValues/TreeCountingFunctionStyleValue.cpp @@ -8,6 +8,7 @@ #include #include #include +#include namespace Web::CSS { @@ -23,9 +24,9 @@ String TreeCountingFunctionStyleValue::to_string(SerializationMode) const VERIFY_NOT_REACHED(); } -size_t TreeCountingFunctionStyleValue::resolve(DOM::AbstractElement const& abstract_element, PropertyComputationDependencies& property_computation_dependencies) const +size_t TreeCountingFunctionStyleValue::resolve(DOM::AbstractElement const& abstract_element) const { - property_computation_dependencies.tree_counting_function = true; + const_cast(abstract_element.element()).set_style_uses_tree_counting_function(); auto tree_counting_function_resolution_context = abstract_element.tree_counting_function_resolution_context(); @@ -39,22 +40,20 @@ size_t TreeCountingFunctionStyleValue::resolve(DOM::AbstractElement const& abstr VERIFY_NOT_REACHED(); } -RefPtr TreeCountingFunctionStyleValue::resolve_to_calculation_node(CalculationContext const& calculation_context, CalculationResolutionContext const& calculation_resolution_context, PropertyComputationDependencies* property_computation_dependencies) const +RefPtr TreeCountingFunctionStyleValue::resolve_to_calculation_node(CalculationContext const& calculation_context, CalculationResolutionContext const& calculation_resolution_context) const { if (!calculation_resolution_context.abstract_element.has_value()) return nullptr; - VERIFY(property_computation_dependencies); - - return NumericCalculationNode::create(Number { Number::Type::Number, static_cast(resolve(calculation_resolution_context.abstract_element.value(), *property_computation_dependencies)) }, calculation_context); + return NumericCalculationNode::create(Number { Number::Type::Number, static_cast(resolve(calculation_resolution_context.abstract_element.value())) }, calculation_context); } -ValueComparingNonnullRefPtr TreeCountingFunctionStyleValue::absolutized(ComputationContext const& computation_context, PropertyComputationDependencies& property_computation_dependencies) const +ValueComparingNonnullRefPtr TreeCountingFunctionStyleValue::absolutized(ComputationContext const& computation_context) const { // FIXME: We should clamp this value in case it falls outside the valid range for the context it is in VERIFY(computation_context.abstract_element.has_value()); - size_t value = resolve(computation_context.abstract_element.value(), property_computation_dependencies); + size_t value = resolve(computation_context.abstract_element.value()); switch (m_computed_type) { case ComputedType::Integer: diff --git a/Libraries/LibWeb/CSS/StyleValues/TreeCountingFunctionStyleValue.h b/Libraries/LibWeb/CSS/StyleValues/TreeCountingFunctionStyleValue.h index 75d31014748..8fcc30bee74 100644 --- a/Libraries/LibWeb/CSS/StyleValues/TreeCountingFunctionStyleValue.h +++ b/Libraries/LibWeb/CSS/StyleValues/TreeCountingFunctionStyleValue.h @@ -30,10 +30,10 @@ public: virtual String to_string(SerializationMode) const override; - size_t resolve(DOM::AbstractElement const&, PropertyComputationDependencies&) const; + size_t resolve(DOM::AbstractElement const&) const; - virtual RefPtr resolve_to_calculation_node(CalculationContext const&, CalculationResolutionContext const&, PropertyComputationDependencies*) const override; - virtual ValueComparingNonnullRefPtr absolutized(ComputationContext const&, PropertyComputationDependencies&) const override; + virtual RefPtr resolve_to_calculation_node(CalculationContext const&, CalculationResolutionContext const&) const override; + virtual ValueComparingNonnullRefPtr absolutized(ComputationContext const&) const override; virtual bool equals(StyleValue const& other) const override; diff --git a/Libraries/LibWeb/DOM/Element.h b/Libraries/LibWeb/DOM/Element.h index a6fbf866a01..f2755e87409 100644 --- a/Libraries/LibWeb/DOM/Element.h +++ b/Libraries/LibWeb/DOM/Element.h @@ -262,6 +262,8 @@ public: void set_custom_properties(Optional, OrderedHashMap custom_properties); [[nodiscard]] OrderedHashMap const& custom_properties(Optional) const; + // FIXME: None of these flags ever get unset should this element's style change so that it no longer relies on these + // things - doing so would potentially improve performance by avoiding unnecessary style invalidations. bool style_uses_attr_css_function() const { return m_style_uses_attr_css_function; } void set_style_uses_attr_css_function() { m_style_uses_attr_css_function = true; } bool style_uses_var_css_function() const { return m_style_uses_var_css_function; } diff --git a/Libraries/LibWeb/HTML/Canvas/CanvasTextDrawingStyles.h b/Libraries/LibWeb/HTML/Canvas/CanvasTextDrawingStyles.h index 5e6fd77b7d3..9ef1fada1cc 100644 --- a/Libraries/LibWeb/HTML/Canvas/CanvasTextDrawingStyles.h +++ b/Libraries/LibWeb/HTML/Canvas/CanvasTextDrawingStyles.h @@ -139,11 +139,10 @@ public: }; // FIXME: Should font be recomputed on canvas element style change? - CSS::PropertyComputationDependencies property_computation_dependencies; - auto const& computed_font_size = CSS::StyleComputer::compute_font_size(font_size, computed_math_depth, inherited_font_size, inherited_math_depth, computation_context, property_computation_dependencies); - auto const& computed_font_weight = CSS::StyleComputer::compute_font_weight(font_weight, inherited_font_weight, computation_context, property_computation_dependencies); - auto const& computed_font_width = CSS::StyleComputer::compute_font_width(font_width, computation_context, property_computation_dependencies); - auto const& computed_font_style = CSS::StyleComputer::compute_font_style(font_style, computation_context, property_computation_dependencies); + auto const& computed_font_size = CSS::StyleComputer::compute_font_size(font_size, computed_math_depth, inherited_font_size, inherited_math_depth, computation_context); + auto const& computed_font_weight = CSS::StyleComputer::compute_font_weight(font_weight, inherited_font_weight, computation_context); + auto const& computed_font_width = CSS::StyleComputer::compute_font_width(font_width, computation_context); + auto const& computed_font_style = CSS::StyleComputer::compute_font_style(font_style, computation_context); return document->style_computer().compute_font_for_style_values( font_family,