mirrors/ladybird
0
0
Fork 0
mirror of https://github.com/LadybirdBrowser/ladybird.git synced 2025-10-22 16:09:23 +00:00
Code Issues Projects Releases Packages Wiki Activity Actions 10

LibWeb: Don't pass unnecessary PropertyComputationDependencies struct

Browse source 
Since we now have access to the `AbstractElement` through the
`ComputationContext` we can just set the flag that this element relies
on tree counting functions directly, no need to pass this struct around.
This commit is contained in:
Callum Law 2025-10-22 00:48:32 +13:00 • committed by Jelle Raaijmakers
commit f49cf75d44
Notes: github-actions[bot] 2025-10-21 23:01:59 +00:00
40 changed files with 200 additions and 249 deletions
Download patch file Download diff file Expand all files Collapse all files

2
Libraries/LibWeb/CSS/Interpolation.cpp
View file

@ -1294,7 +1294,7 @@ static RefPtr<StyleValue const> interpolate_mixed_value(CalculationContext const
}); });
return CalculatedStyleValue::create( 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()), *from_node->numeric_type()->added_to(*to_node->numeric_type()),
calculation_context); calculation_context);
} }

12
Libraries/LibWeb/CSS/ParsedFontFace.cpp
View file

@ -89,10 +89,8 @@ ParsedFontFace ParsedFontFace::from_descriptors(CSSFontFaceDescriptors const& de
if (value->to_keyword() == Keyword::Auto) { if (value->to_keyword() == Keyword::Auto) {
weight = 400; weight = 400;
} else { } 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 // 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) { if (value->to_keyword() == Keyword::Auto) {
slope = 0; slope = 0;
} else { } else {
// NOTE: We can disregard the dependencies here because they won't change slope = StyleComputer::compute_font_style(*value, computation_context)->as_font_style().to_font_slope();
PropertyComputationDependencies property_computation_dependencies;
slope = StyleComputer::compute_font_style(*value, computation_context, property_computation_dependencies)->as_font_style().to_font_slope();
} }
} }
@ -120,9 +116,7 @@ ParsedFontFace ParsedFontFace::from_descriptors(CSSFontFaceDescriptors const& de
if (value->to_keyword() == Keyword::Auto) { if (value->to_keyword() == Keyword::Auto) {
width = 100; width = 100;
} else { } else {
// NOTE: We can disregard the dependencies here because they won't change width = StyleComputer::compute_font_width(*value, computation_context)->as_percentage().raw_value();
PropertyComputationDependencies property_computation_dependencies;
width = StyleComputer::compute_font_width(*value, computation_context, property_computation_dependencies)->as_percentage().raw_value();
} }
} }

4
Libraries/LibWeb/CSS/Parser/ValueParsing.cpp
View file

@ -4188,7 +4188,7 @@ RefPtr<CalculationNode const> Parser::parse_a_calc_function_node(Function const&
if (auto maybe_function = parse_math_function(function, context)) { 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 // 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. // 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; return nullptr;
@ -4468,7 +4468,7 @@ RefPtr<CalculationNode const> Parser::parse_a_calculation(Vector<ComponentValue>
return nullptr; return nullptr;
// 6. Return the result of simplifying a calculation tree from values. // 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 // https://drafts.csswg.org/css-values-5/#tree-counting

91
Libraries/LibWeb/CSS/StyleComputer.cpp
View file

@ -895,16 +895,6 @@ static void cascade_custom_properties(DOM::AbstractElement abstract_element, Vec
custom_properties.update(important_custom_properties); 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<DOM::AbstractElement> 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<Animations::KeyframeEffect> effect, ComputedProperties& computed_properties) const void StyleComputer::collect_animation_into(DOM::AbstractElement abstract_element, GC::Ref<Animations::KeyframeEffect> effect, ComputedProperties& computed_properties) const
{ {
auto animation = effect->associated_animation(); 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_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(); 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( auto const& font_size_in_computed_form = compute_font_size(
*font_size_specified_value.value(), *font_size_specified_value.value(),
computed_math_depth, computed_math_depth,
inherited_font_size, inherited_font_size,
inherited_math_depth, inherited_math_depth,
font_computation_context, font_computation_context);
property_computation_dependencies);
result.set(PropertyID::FontSize, font_size_in_computed_form); 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()) { 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(); 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( auto const& font_weight_in_computed_form = compute_font_weight(
*font_weight_specified_value.value(), *font_weight_specified_value.value(),
inherited_font_weight, inherited_font_weight,
font_computation_context, font_computation_context);
property_computation_dependencies);
result.set(PropertyID::FontWeight, font_weight_in_computed_form); 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()) { 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));
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_style_specified_value = specified_values.get(PropertyID::FontStyle); font_style_specified_value.has_value()) { 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));
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& line_height_specified_value = specified_values.get(PropertyID::LineHeight); line_height_specified_value.has_value()) { if (auto const& line_height_specified_value = specified_values.get(PropertyID::LineHeight); line_height_specified_value.has_value()) {
ComputationContext line_height_computation_context { ComputationContext line_height_computation_context {
@ -1142,9 +1120,7 @@ void StyleComputer::collect_animation_into(DOM::AbstractElement abstract_element
.abstract_element = 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));
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);
} }
ComputationContext 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)) if (first_is_one_of(property_id, PropertyID::FontSize, PropertyID::FontWeight, PropertyID::FontWidth, PropertyID::FontStyle, PropertyID::LineHeight))
continue; 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()));
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);
} }
return result; return result;
@ -2068,41 +2042,33 @@ void StyleComputer::compute_font(ComputedProperties& style, Optional<DOM::Abstra
auto const& font_size_specified_value = style.property(PropertyID::FontSize, ComputedProperties::WithAnimationsApplied::No); auto const& font_size_specified_value = style.property(PropertyID::FontSize, ComputedProperties::WithAnimationsApplied::No);
PropertyComputationDependencies font_size_property_computation_dependencies;
style.set_property( style.set_property(
PropertyID::FontSize, PropertyID::FontSize,
compute_font_size(font_size_specified_value, style.math_depth(), inherited_font_size, inherited_math_depth, font_computation_context, font_size_property_computation_dependencies), compute_font_size(font_size_specified_value, style.math_depth(), inherited_font_size, inherited_math_depth, font_computation_context),
style.is_property_inherited(PropertyID::FontSize) ? ComputedProperties::Inherited::Yes : ComputedProperties::Inherited::No); style.is_property_inherited(PropertyID::FontSize) ? ComputedProperties::Inherited::Yes : ComputedProperties::Inherited::No);
mark_property_computation_dependencies(abstract_element, font_size_property_computation_dependencies);
auto inherited_font_weight = inheritance_parent_has_computed_properties ? inheritance_parent->computed_properties()->font_weight() : InitialValues::font_weight(); auto inherited_font_weight = inheritance_parent_has_computed_properties ? inheritance_parent->computed_properties()->font_weight() : InitialValues::font_weight();
auto const& font_weight_specified_value = style.property(PropertyID::FontWeight, ComputedProperties::WithAnimationsApplied::No); auto const& font_weight_specified_value = style.property(PropertyID::FontWeight, ComputedProperties::WithAnimationsApplied::No);
PropertyComputationDependencies font_weight_property_computation_dependencies;
style.set_property( style.set_property(
PropertyID::FontWeight, 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); 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); auto const& font_width_specified_value = style.property(PropertyID::FontWidth, ComputedProperties::WithAnimationsApplied::No);
PropertyComputationDependencies font_width_property_computation_dependencies;
style.set_property( style.set_property(
PropertyID::FontWidth, 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); 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); auto const& font_style_specified_value = style.property(PropertyID::FontStyle, ComputedProperties::WithAnimationsApplied::No);
PropertyComputationDependencies font_style_property_computation_dependencies;
style.set_property( style.set_property(
PropertyID::FontStyle, 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); 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); auto const& font_family = style.property(CSS::PropertyID::FontFamily);
@ -2131,12 +2097,10 @@ void StyleComputer::compute_font(ComputedProperties& style, Optional<DOM::Abstra
auto const& line_height_specified_value = style.property(CSS::PropertyID::LineHeight, ComputedProperties::WithAnimationsApplied::No); auto const& line_height_specified_value = style.property(CSS::PropertyID::LineHeight, ComputedProperties::WithAnimationsApplied::No);
PropertyComputationDependencies line_height_property_computation_dependencies;
style.set_property( style.set_property(
PropertyID::LineHeight, PropertyID::LineHeight,
compute_line_height(line_height_specified_value, line_height_computation_context, line_height_property_computation_dependencies), compute_line_height(line_height_specified_value, line_height_computation_context),
style.is_property_inherited(PropertyID::LineHeight) ? ComputedProperties::Inherited::Yes : ComputedProperties::Inherited::No); style.is_property_inherited(PropertyID::LineHeight) ? ComputedProperties::Inherited::Yes : ComputedProperties::Inherited::No);
mark_property_computation_dependencies(abstract_element, line_height_property_computation_dependencies);
if (abstract_element.has_value() && is<HTML::HTMLHtmlElement>(abstract_element->element())) { if (abstract_element.has_value() && is<HTML::HTMLHtmlElement>(abstract_element->element())) {
const_cast<StyleComputer&>(*this).m_root_element_font_metrics = calculate_root_element_font_metrics(style); const_cast<StyleComputer&>(*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) { 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());
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& is_inherited = style.is_property_inherited(property_id) ? ComputedProperties::Inherited::Yes : ComputedProperties::Inherited::No; auto const& is_inherited = style.is_property_inherited(property_id) ? ComputedProperties::Inherited::Yes : ComputedProperties::Inherited::No;
@ -3279,10 +3241,9 @@ NonnullRefPtr<StyleValue const> StyleComputer::compute_value_of_property(
NonnullRefPtr<StyleValue const> const& specified_value, NonnullRefPtr<StyleValue const> const& specified_value,
Function<NonnullRefPtr<StyleValue const>(PropertyID)> const& get_property_specified_value, Function<NonnullRefPtr<StyleValue const>(PropertyID)> const& get_property_specified_value,
ComputationContext const& computation_context, ComputationContext const& computation_context,
double device_pixels_per_css_pixel, double device_pixels_per_css_pixel)
PropertyComputationDependencies& property_computation_dependencies)
{ {
auto const& absolutized_value = specified_value->absolutized(computation_context, property_computation_dependencies); auto const& absolutized_value = specified_value->absolutized(computation_context);
switch (property_id) { switch (property_id) {
case PropertyID::AnimationName: case PropertyID::AnimationName:
@ -3436,12 +3397,12 @@ NonnullRefPtr<StyleValue const> StyleComputer::compute_corner_shape(NonnullRefPt
VERIFY_NOT_REACHED(); VERIFY_NOT_REACHED();
} }
NonnullRefPtr<StyleValue const> StyleComputer::compute_font_size(NonnullRefPtr<StyleValue const> const& specified_value, int computed_math_depth, CSSPixels inherited_font_size, int inherited_math_depth, ComputationContext const& computation_context, PropertyComputationDependencies& property_computation_dependencies) NonnullRefPtr<StyleValue const> StyleComputer::compute_font_size(NonnullRefPtr<StyleValue const> 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 // https://drafts.csswg.org/css-fonts/#font-size-prop
// an absolute length // an absolute length
auto const& absolutized_value = specified_value->absolutized(computation_context, property_computation_dependencies); auto const& absolutized_value = specified_value->absolutized(computation_context);
// <absolute-size> // <absolute-size>
if (auto absolute_size = keyword_to_absolute_size(absolutized_value->to_keyword()); absolute_size.has_value()) if (auto absolute_size = keyword_to_absolute_size(absolutized_value->to_keyword()); absolute_size.has_value())
@ -3507,7 +3468,7 @@ NonnullRefPtr<StyleValue const> StyleComputer::compute_font_size(NonnullRefPtr<S
VERIFY_NOT_REACHED(); VERIFY_NOT_REACHED();
} }
NonnullRefPtr<StyleValue const> StyleComputer::compute_font_style(NonnullRefPtr<StyleValue const> const& specified_value, ComputationContext const& computation_context, PropertyComputationDependencies& property_computation_dependencies) NonnullRefPtr<StyleValue const> StyleComputer::compute_font_style(NonnullRefPtr<StyleValue const> const& specified_value, ComputationContext const& computation_context)
{ {
// https://drafts.csswg.org/css-fonts-4/#font-style-prop // https://drafts.csswg.org/css-fonts-4/#font-style-prop
// the keyword specified, plus angle in degrees if specified // the keyword specified, plus angle in degrees if specified
@ -3516,15 +3477,15 @@ NonnullRefPtr<StyleValue const> StyleComputer::compute_font_style(NonnullRefPtr<
if (specified_value->is_keyword()) if (specified_value->is_keyword())
return FontStyleStyleValue::create(*keyword_to_font_style(specified_value->to_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<StyleValue const> StyleComputer::compute_font_weight(NonnullRefPtr<StyleValue const> const& specified_value, double inherited_font_weight, ComputationContext const& computation_context, PropertyComputationDependencies& property_computation_dependencies) NonnullRefPtr<StyleValue const> StyleComputer::compute_font_weight(NonnullRefPtr<StyleValue const> const& specified_value, double inherited_font_weight, ComputationContext const& computation_context)
{ {
// https://drafts.csswg.org/css-fonts-4/#font-weight-prop // https://drafts.csswg.org/css-fonts-4/#font-weight-prop
// a number, see below // 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);
// <number [1,1000]> // <number [1,1000]>
if (absolutized_value->is_number()) if (absolutized_value->is_number())
@ -3588,12 +3549,12 @@ NonnullRefPtr<StyleValue const> StyleComputer::compute_font_weight(NonnullRefPtr
VERIFY_NOT_REACHED(); VERIFY_NOT_REACHED();
} }
NonnullRefPtr<StyleValue const> StyleComputer::compute_font_width(NonnullRefPtr<StyleValue const> const& specified_value, ComputationContext const& computation_context, PropertyComputationDependencies& property_computation_dependencies) NonnullRefPtr<StyleValue const> StyleComputer::compute_font_width(NonnullRefPtr<StyleValue const> const& specified_value, ComputationContext const& computation_context)
{ {
// https://drafts.csswg.org/css-fonts-4/#font-width-prop // https://drafts.csswg.org/css-fonts-4/#font-width-prop
// a percentage, see below // a percentage, see below
auto absolutized_value = specified_value->absolutized(computation_context, property_computation_dependencies); auto absolutized_value = specified_value->absolutized(computation_context);
// <percentage [0,∞]> // <percentage [0,∞]>
if (absolutized_value->is_percentage()) if (absolutized_value->is_percentage())
@ -3636,11 +3597,11 @@ NonnullRefPtr<StyleValue const> StyleComputer::compute_font_width(NonnullRefPtr<
} }
} }
NonnullRefPtr<StyleValue const> StyleComputer::compute_line_height(NonnullRefPtr<StyleValue const> const& specified_value, ComputationContext const& computation_context, PropertyComputationDependencies& property_computation_dependencies) NonnullRefPtr<StyleValue const> StyleComputer::compute_line_height(NonnullRefPtr<StyleValue const> const& specified_value, ComputationContext const& computation_context)
{ {
// https://drafts.csswg.org/css-inline-3/#line-height-property // 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 // normal
// <length [0,∞]> // <length [0,∞]>

12
Libraries/LibWeb/CSS/StyleComputer.h
View file

@ -198,16 +198,16 @@ public:
static NonnullRefPtr<StyleValue const> compute_value_of_custom_property(DOM::AbstractElement, FlyString const& custom_property, Optional<Parser::GuardedSubstitutionContexts&> = {}); static NonnullRefPtr<StyleValue const> compute_value_of_custom_property(DOM::AbstractElement, FlyString const& custom_property, Optional<Parser::GuardedSubstitutionContexts&> = {});
static NonnullRefPtr<StyleValue const> compute_value_of_property(PropertyID, NonnullRefPtr<StyleValue const> const& specified_value, Function<NonnullRefPtr<StyleValue const>(PropertyID)> const& get_property_specified_value, ComputationContext const&, double device_pixels_per_css_pixel, PropertyComputationDependencies& property_computation_dependencies); static NonnullRefPtr<StyleValue const> compute_value_of_property(PropertyID, NonnullRefPtr<StyleValue const> const& specified_value, Function<NonnullRefPtr<StyleValue const>(PropertyID)> const& get_property_specified_value, ComputationContext const&, double device_pixels_per_css_pixel);
static NonnullRefPtr<StyleValue const> compute_animation_name(NonnullRefPtr<StyleValue const> const& absolutized_value); static NonnullRefPtr<StyleValue const> compute_animation_name(NonnullRefPtr<StyleValue const> const& absolutized_value);
static NonnullRefPtr<StyleValue const> compute_border_or_outline_width(NonnullRefPtr<StyleValue const> const& absolutized_value, NonnullRefPtr<StyleValue const> const& style_specified_value, double device_pixels_per_css_pixel); static NonnullRefPtr<StyleValue const> compute_border_or_outline_width(NonnullRefPtr<StyleValue const> const& absolutized_value, NonnullRefPtr<StyleValue const> const& style_specified_value, double device_pixels_per_css_pixel);
static NonnullRefPtr<StyleValue const> compute_corner_shape(NonnullRefPtr<StyleValue const> const& absolutized_value); static NonnullRefPtr<StyleValue const> compute_corner_shape(NonnullRefPtr<StyleValue const> const& absolutized_value);
static NonnullRefPtr<StyleValue const> compute_font_size(NonnullRefPtr<StyleValue const> const& specified_value, int computed_math_depth, CSSPixels inherited_font_size, int inherited_math_depth, ComputationContext const&, PropertyComputationDependencies&); static NonnullRefPtr<StyleValue const> compute_font_size(NonnullRefPtr<StyleValue const> const& specified_value, int computed_math_depth, CSSPixels inherited_font_size, int inherited_math_depth, ComputationContext const&);
static NonnullRefPtr<StyleValue const> compute_font_style(NonnullRefPtr<StyleValue const> const& specified_value, ComputationContext const&, PropertyComputationDependencies&); static NonnullRefPtr<StyleValue const> compute_font_style(NonnullRefPtr<StyleValue const> const& specified_value, ComputationContext const&);
static NonnullRefPtr<StyleValue const> compute_font_weight(NonnullRefPtr<StyleValue const> const& specified_value, double inherited_font_weight, ComputationContext const&, PropertyComputationDependencies&); static NonnullRefPtr<StyleValue const> compute_font_weight(NonnullRefPtr<StyleValue const> const& specified_value, double inherited_font_weight, ComputationContext const&);
static NonnullRefPtr<StyleValue const> compute_font_width(NonnullRefPtr<StyleValue const> const& specified_value, ComputationContext const&, PropertyComputationDependencies&); static NonnullRefPtr<StyleValue const> compute_font_width(NonnullRefPtr<StyleValue const> const& specified_value, ComputationContext const&);
static NonnullRefPtr<StyleValue const> compute_font_variation_settings(NonnullRefPtr<StyleValue const> const& absolutized_value); static NonnullRefPtr<StyleValue const> compute_font_variation_settings(NonnullRefPtr<StyleValue const> const& absolutized_value);
static NonnullRefPtr<StyleValue const> compute_line_height(NonnullRefPtr<StyleValue const> const& specified_value, ComputationContext const&, PropertyComputationDependencies&); static NonnullRefPtr<StyleValue const> compute_line_height(NonnullRefPtr<StyleValue const> const& specified_value, ComputationContext const&);
static NonnullRefPtr<StyleValue const> compute_opacity(NonnullRefPtr<StyleValue const> const& absolutized_value); static NonnullRefPtr<StyleValue const> compute_opacity(NonnullRefPtr<StyleValue const> const& absolutized_value);
static NonnullRefPtr<StyleValue const> compute_position_area(NonnullRefPtr<StyleValue const> const& absolutized_value); static NonnullRefPtr<StyleValue const> compute_position_area(NonnullRefPtr<StyleValue const> const& absolutized_value);

2
Libraries/LibWeb/CSS/StyleValues/AbstractNonMathCalcFunctionStyleValue.h
View file

@ -14,7 +14,7 @@ class AbstractNonMathCalcFunctionStyleValue : public StyleValue {
using StyleValue::StyleValue; using StyleValue::StyleValue;
public: public:
virtual RefPtr<CalculationNode const> resolve_to_calculation_node(CalculationContext const&, CalculationResolutionContext const&, PropertyComputationDependencies*) const = 0; virtual RefPtr<CalculationNode const> resolve_to_calculation_node(CalculationContext const&, CalculationResolutionContext const&) const = 0;
}; };
} }

6
Libraries/LibWeb/CSS/StyleValues/BackgroundSizeStyleValue.cpp
View file

@ -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))); return MUST(String::formatted("{} {}", m_properties.size_x->to_string(mode), m_properties.size_y->to_string(mode)));
} }
ValueComparingNonnullRefPtr<StyleValue const> BackgroundSizeStyleValue::absolutized(ComputationContext const& computation_context, PropertyComputationDependencies& property_computation_dependencies) const ValueComparingNonnullRefPtr<StyleValue const> BackgroundSizeStyleValue::absolutized(ComputationContext const& computation_context) const
{ {
auto absolutized_size_x = m_properties.size_x->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, property_computation_dependencies); 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) if (absolutized_size_x == m_properties.size_x && absolutized_size_y == m_properties.size_y)
return *this; return *this;

2
Libraries/LibWeb/CSS/StyleValues/BackgroundSizeStyleValue.h
View file

@ -28,7 +28,7 @@ public:
ValueComparingNonnullRefPtr<StyleValue const> size_y() const { return m_properties.size_y; } ValueComparingNonnullRefPtr<StyleValue const> size_y() const { return m_properties.size_y; }
virtual String to_string(SerializationMode) const override; virtual String to_string(SerializationMode) const override;
virtual ValueComparingNonnullRefPtr<StyleValue const> absolutized(ComputationContext const&, PropertyComputationDependencies&) const override; virtual ValueComparingNonnullRefPtr<StyleValue const> absolutized(ComputationContext const&) const override;
bool properties_equal(BackgroundSizeStyleValue const& other) const { return m_properties == other.m_properties; } bool properties_equal(BackgroundSizeStyleValue const& other) const { return m_properties == other.m_properties; }

6
Libraries/LibWeb/CSS/StyleValues/BorderRadiusStyleValue.cpp
View file

@ -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))); return MUST(String::formatted("{} {}", m_properties.horizontal_radius->to_string(mode), m_properties.vertical_radius->to_string(mode)));
} }
ValueComparingNonnullRefPtr<StyleValue const> BorderRadiusStyleValue::absolutized(ComputationContext const& computation_context, PropertyComputationDependencies& property_computation_dependencies) const ValueComparingNonnullRefPtr<StyleValue const> BorderRadiusStyleValue::absolutized(ComputationContext const& computation_context) const
{ {
auto absolutized_horizontal_radius = m_properties.horizontal_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, property_computation_dependencies); 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) if (absolutized_vertical_radius == m_properties.vertical_radius && absolutized_horizontal_radius == m_properties.horizontal_radius)
return *this; return *this;

2
Libraries/LibWeb/CSS/StyleValues/BorderRadiusStyleValue.h
View file

@ -38,7 +38,7 @@ private:
{ {
} }
virtual ValueComparingNonnullRefPtr<StyleValue const> absolutized(ComputationContext const&, PropertyComputationDependencies&) const override; virtual ValueComparingNonnullRefPtr<StyleValue const> absolutized(ComputationContext const&) const override;
struct Properties { struct Properties {
bool is_elliptical; bool is_elliptical;
ValueComparingNonnullRefPtr<StyleValue const> horizontal_radius; ValueComparingNonnullRefPtr<StyleValue const> horizontal_radius;

128
Libraries/LibWeb/CSS/StyleValues/CalculatedStyleValue.cpp
View file

@ -115,14 +115,14 @@ static Optional<NumericType> multiply_the_types(Vector<NonnullRefPtr<Calculation
} }
template<typename T> template<typename T>
static NonnullRefPtr<CalculationNode const> simplify_children_vector(T const& original, CalculationContext const& context, CalculationResolutionContext const& resolution_context, PropertyComputationDependencies* property_computation_dependencies) static NonnullRefPtr<CalculationNode const> simplify_children_vector(T const& original, CalculationContext const& context, CalculationResolutionContext const& resolution_context)
{ {
Vector<NonnullRefPtr<CalculationNode const>> simplified_children; Vector<NonnullRefPtr<CalculationNode const>> simplified_children;
simplified_children.ensure_capacity(original.children().size()); simplified_children.ensure_capacity(original.children().size());
bool any_changed = false; bool any_changed = false;
for (auto const& child : original.children()) { 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) if (simplified != child)
any_changed = true; any_changed = true;
simplified_children.append(move(simplified)); simplified_children.append(move(simplified));
@ -134,19 +134,19 @@ static NonnullRefPtr<CalculationNode const> simplify_children_vector(T const& or
} }
template<typename T> template<typename T>
static NonnullRefPtr<CalculationNode const> simplify_child(T const& original, NonnullRefPtr<CalculationNode const> const& child, CalculationContext const& context, CalculationResolutionContext const& resolution_context, PropertyComputationDependencies* property_computation_dependencies) static NonnullRefPtr<CalculationNode const> simplify_child(T const& original, NonnullRefPtr<CalculationNode const> 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) if (simplified != child)
return T::create(move(simplified)); return T::create(move(simplified));
return original; return original;
} }
template<typename T> template<typename T>
static NonnullRefPtr<CalculationNode const> simplify_2_children(T const& original, NonnullRefPtr<CalculationNode const> const& child_1, NonnullRefPtr<CalculationNode const> const& child_2, CalculationContext const& context, CalculationResolutionContext const& resolution_context, PropertyComputationDependencies* property_computation_dependencies) static NonnullRefPtr<CalculationNode const> simplify_2_children(T const& original, NonnullRefPtr<CalculationNode const> const& child_1, NonnullRefPtr<CalculationNode const> 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_1 = simplify_a_calculation_tree(child_1, context, resolution_context);
auto simplified_2 = simplify_a_calculation_tree(child_2, context, resolution_context, property_computation_dependencies); auto simplified_2 = simplify_a_calculation_tree(child_2, context, resolution_context);
if (simplified_1 != child_1 || simplified_2 != child_2) if (simplified_1 != child_1 || simplified_2 != child_2)
return T::create(move(simplified_1), move(simplified_2)); return T::create(move(simplified_1), move(simplified_2));
return original; return original;
@ -833,9 +833,9 @@ bool SumCalculationNode::contains_percentage() const
return false; return false;
} }
NonnullRefPtr<CalculationNode const> SumCalculationNode::with_simplified_children(CalculationContext const& context, CalculationResolutionContext const& resolution_context, PropertyComputationDependencies* property_computation_dependencies) const NonnullRefPtr<CalculationNode const> 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 void SumCalculationNode::dump(StringBuilder& builder, int indent) const
@ -895,9 +895,9 @@ bool ProductCalculationNode::contains_percentage() const
return false; return false;
} }
NonnullRefPtr<CalculationNode const> ProductCalculationNode::with_simplified_children(CalculationContext const& context, CalculationResolutionContext const& resolution_context, PropertyComputationDependencies* property_computation_dependencies) const NonnullRefPtr<CalculationNode const> 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 void ProductCalculationNode::dump(StringBuilder& builder, int indent) const
@ -949,9 +949,9 @@ bool NegateCalculationNode::contains_percentage() const
return m_value->contains_percentage(); return m_value->contains_percentage();
} }
NonnullRefPtr<CalculationNode const> NegateCalculationNode::with_simplified_children(CalculationContext const& context, CalculationResolutionContext const& resolution_context, PropertyComputationDependencies* property_computation_dependencies) const NonnullRefPtr<CalculationNode const> 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 void NegateCalculationNode::dump(StringBuilder& builder, int indent) const
@ -1002,9 +1002,9 @@ bool InvertCalculationNode::contains_percentage() const
return m_value->contains_percentage(); return m_value->contains_percentage();
} }
NonnullRefPtr<CalculationNode const> InvertCalculationNode::with_simplified_children(CalculationContext const& context, CalculationResolutionContext const& resolution_context, PropertyComputationDependencies* property_computation_dependencies) const NonnullRefPtr<CalculationNode const> 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 void InvertCalculationNode::dump(StringBuilder& builder, int indent) const
@ -1056,9 +1056,9 @@ bool MinCalculationNode::contains_percentage() const
return false; return false;
} }
NonnullRefPtr<CalculationNode const> MinCalculationNode::with_simplified_children(CalculationContext const& context, CalculationResolutionContext const& resolution_context, PropertyComputationDependencies* property_computation_dependencies) const NonnullRefPtr<CalculationNode const> 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 // https://drafts.csswg.org/css-values-4/#funcdef-min
@ -1170,9 +1170,9 @@ bool MaxCalculationNode::contains_percentage() const
return false; return false;
} }
NonnullRefPtr<CalculationNode const> MaxCalculationNode::with_simplified_children(CalculationContext const& context, CalculationResolutionContext const& resolution_context, PropertyComputationDependencies* property_computation_dependencies) const NonnullRefPtr<CalculationNode const> 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 // 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(); return m_min_value->contains_percentage() || m_center_value->contains_percentage() || m_max_value->contains_percentage();
} }
NonnullRefPtr<CalculationNode const> ClampCalculationNode::with_simplified_children(CalculationContext const& context, CalculationResolutionContext const& resolution_context, PropertyComputationDependencies* property_computation_dependencies) const NonnullRefPtr<CalculationNode const> 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_min = simplify_a_calculation_tree(m_min_value, context, resolution_context);
auto simplified_center = simplify_a_calculation_tree(m_center_value, context, resolution_context, property_computation_dependencies); 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, property_computation_dependencies); 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) 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 create(move(simplified_min), move(simplified_center), move(simplified_max));
return *this; return *this;
@ -1334,9 +1334,9 @@ bool AbsCalculationNode::contains_percentage() const
return m_value->contains_percentage(); return m_value->contains_percentage();
} }
NonnullRefPtr<CalculationNode const> AbsCalculationNode::with_simplified_children(CalculationContext const& context, CalculationResolutionContext const& resolution_context, PropertyComputationDependencies* property_computation_dependencies) const NonnullRefPtr<CalculationNode const> 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 // https://drafts.csswg.org/css-values-4/#funcdef-abs
@ -1385,9 +1385,9 @@ bool SignCalculationNode::contains_percentage() const
return m_value->contains_percentage(); return m_value->contains_percentage();
} }
NonnullRefPtr<CalculationNode const> SignCalculationNode::with_simplified_children(CalculationContext const& context, CalculationResolutionContext const& resolution_context, PropertyComputationDependencies* property_computation_dependencies) const NonnullRefPtr<CalculationNode const> 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 // https://drafts.csswg.org/css-values-4/#funcdef-sign
@ -1452,9 +1452,9 @@ bool SinCalculationNode::contains_percentage() const
return m_value->contains_percentage(); return m_value->contains_percentage();
} }
NonnullRefPtr<CalculationNode const> SinCalculationNode::with_simplified_children(CalculationContext const& context, CalculationResolutionContext const& resolution_context, PropertyComputationDependencies* property_computation_dependencies) const NonnullRefPtr<CalculationNode const> 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 { enum class SinCosOrTan {
@ -1537,9 +1537,9 @@ bool CosCalculationNode::contains_percentage() const
return m_value->contains_percentage(); return m_value->contains_percentage();
} }
NonnullRefPtr<CalculationNode const> CosCalculationNode::with_simplified_children(CalculationContext const& context, CalculationResolutionContext const& resolution_context, PropertyComputationDependencies* property_computation_dependencies) const NonnullRefPtr<CalculationNode const> 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 // https://drafts.csswg.org/css-values-4/#funcdef-cos
@ -1583,9 +1583,9 @@ bool TanCalculationNode::contains_percentage() const
return m_value->contains_percentage(); return m_value->contains_percentage();
} }
NonnullRefPtr<CalculationNode const> TanCalculationNode::with_simplified_children(CalculationContext const& context, CalculationResolutionContext const& resolution_context, PropertyComputationDependencies* property_computation_dependencies) const NonnullRefPtr<CalculationNode const> 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 // https://drafts.csswg.org/css-values-4/#funcdef-tan
@ -1629,9 +1629,9 @@ bool AsinCalculationNode::contains_percentage() const
return m_value->contains_percentage(); return m_value->contains_percentage();
} }
NonnullRefPtr<CalculationNode const> AsinCalculationNode::with_simplified_children(CalculationContext const& context, CalculationResolutionContext const& resolution_context, PropertyComputationDependencies* property_computation_dependencies) const NonnullRefPtr<CalculationNode const> 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 { enum class AsinAcosOrAtan {
@ -1719,9 +1719,9 @@ bool AcosCalculationNode::contains_percentage() const
return m_value->contains_percentage(); return m_value->contains_percentage();
} }
NonnullRefPtr<CalculationNode const> AcosCalculationNode::with_simplified_children(CalculationContext const& context, CalculationResolutionContext const& resolution_context, PropertyComputationDependencies* property_computation_dependencies) const NonnullRefPtr<CalculationNode const> 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 // https://drafts.csswg.org/css-values-4/#funcdef-acos
@ -1765,9 +1765,9 @@ bool AtanCalculationNode::contains_percentage() const
return m_value->contains_percentage(); return m_value->contains_percentage();
} }
NonnullRefPtr<CalculationNode const> AtanCalculationNode::with_simplified_children(CalculationContext const& context, CalculationResolutionContext const& resolution_context, PropertyComputationDependencies* property_computation_dependencies) const NonnullRefPtr<CalculationNode const> 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 // 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(); return m_y->contains_percentage() || m_x->contains_percentage();
} }
NonnullRefPtr<CalculationNode const> Atan2CalculationNode::with_simplified_children(CalculationContext const& context, CalculationResolutionContext const& resolution_context, PropertyComputationDependencies* property_computation_dependencies) const NonnullRefPtr<CalculationNode const> 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 // https://drafts.csswg.org/css-values-4/#funcdef-atan2
@ -1878,9 +1878,9 @@ PowCalculationNode::PowCalculationNode(NonnullRefPtr<CalculationNode const> x, N
PowCalculationNode::~PowCalculationNode() = default; PowCalculationNode::~PowCalculationNode() = default;
NonnullRefPtr<CalculationNode const> PowCalculationNode::with_simplified_children(CalculationContext const& context, CalculationResolutionContext const& resolution_context, PropertyComputationDependencies* property_computation_dependencies) const NonnullRefPtr<CalculationNode const> 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 // https://drafts.csswg.org/css-values-4/#funcdef-pow
@ -1933,9 +1933,9 @@ SqrtCalculationNode::SqrtCalculationNode(NonnullRefPtr<CalculationNode const> va
SqrtCalculationNode::~SqrtCalculationNode() = default; SqrtCalculationNode::~SqrtCalculationNode() = default;
NonnullRefPtr<CalculationNode const> SqrtCalculationNode::with_simplified_children(CalculationContext const& context, CalculationResolutionContext const& resolution_context, PropertyComputationDependencies* property_computation_dependencies) const NonnullRefPtr<CalculationNode const> 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 // https://drafts.csswg.org/css-values-4/#funcdef-sqrt
@ -1997,9 +1997,9 @@ bool HypotCalculationNode::contains_percentage() const
return false; return false;
} }
NonnullRefPtr<CalculationNode const> HypotCalculationNode::with_simplified_children(CalculationContext const& context, CalculationResolutionContext const& resolution_context, PropertyComputationDependencies* property_computation_dependencies) const NonnullRefPtr<CalculationNode const> 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 // https://drafts.csswg.org/css-values-4/#funcdef-hypot
@ -2072,9 +2072,9 @@ LogCalculationNode::LogCalculationNode(NonnullRefPtr<CalculationNode const> x, N
LogCalculationNode::~LogCalculationNode() = default; LogCalculationNode::~LogCalculationNode() = default;
NonnullRefPtr<CalculationNode const> LogCalculationNode::with_simplified_children(CalculationContext const& context, CalculationResolutionContext const& resolution_context, PropertyComputationDependencies* property_computation_dependencies) const NonnullRefPtr<CalculationNode const> 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 // https://drafts.csswg.org/css-values-4/#funcdef-log
@ -2128,9 +2128,9 @@ ExpCalculationNode::ExpCalculationNode(NonnullRefPtr<CalculationNode const> valu
ExpCalculationNode::~ExpCalculationNode() = default; ExpCalculationNode::~ExpCalculationNode() = default;
NonnullRefPtr<CalculationNode const> ExpCalculationNode::with_simplified_children(CalculationContext const& context, CalculationResolutionContext const& resolution_context, PropertyComputationDependencies* property_computation_dependencies) const NonnullRefPtr<CalculationNode const> 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 // 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(); return m_x->contains_percentage() || m_y->contains_percentage();
} }
NonnullRefPtr<CalculationNode const> RoundCalculationNode::with_simplified_children(CalculationContext const& context, CalculationResolutionContext const& resolution_context, PropertyComputationDependencies* property_computation_dependencies) const NonnullRefPtr<CalculationNode const> 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_x = simplify_a_calculation_tree(m_x, context, resolution_context);
auto simplified_y = simplify_a_calculation_tree(m_y, context, resolution_context, property_computation_dependencies); auto simplified_y = simplify_a_calculation_tree(m_y, context, resolution_context);
if (simplified_x != m_x || simplified_y != m_y) if (simplified_x != m_x || simplified_y != m_y)
return create(m_strategy, move(simplified_x), move(simplified_y)); return create(m_strategy, move(simplified_x), move(simplified_y));
return *this; return *this;
@ -2359,9 +2359,9 @@ bool ModCalculationNode::contains_percentage() const
return m_x->contains_percentage() || m_y->contains_percentage(); return m_x->contains_percentage() || m_y->contains_percentage();
} }
NonnullRefPtr<CalculationNode const> ModCalculationNode::with_simplified_children(CalculationContext const& context, CalculationResolutionContext const& resolution_context, PropertyComputationDependencies* property_computation_dependencies) const NonnullRefPtr<CalculationNode const> 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 { enum class ModOrRem {
@ -2449,9 +2449,9 @@ bool RemCalculationNode::contains_percentage() const
return m_x->contains_percentage() || m_y->contains_percentage(); return m_x->contains_percentage() || m_y->contains_percentage();
} }
NonnullRefPtr<CalculationNode const> RemCalculationNode::with_simplified_children(CalculationContext const& context, CalculationResolutionContext const& resolution_context, PropertyComputationDependencies* property_computation_dependencies) const NonnullRefPtr<CalculationNode const> 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 // 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); return serialize_a_math_function(m_calculation, m_context, serialization_mode);
} }
ValueComparingNonnullRefPtr<StyleValue const> CalculatedStyleValue::absolutized(ComputationContext const& computation_context, PropertyComputationDependencies& property_computation_dependencies) const ValueComparingNonnullRefPtr<StyleValue const> 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<ValueComparingNonnullRefPtr<StyleValue const>> { auto const simplified_percentage_dimension_mix = [&]() -> Optional<ValueComparingNonnullRefPtr<StyleValue const>> {
// NOTE: A percentage dimension mix is a SumCalculationNode with two NumericCalculationNode children which have // NOTE: A percentage dimension mix is a SumCalculationNode with two NumericCalculationNode children which have
@ -2634,7 +2634,7 @@ Optional<CalculatedStyleValue::ResolvedValue> CalculatedStyleValue::resolve_valu
{ {
// The calculation tree is again simplified at used value time; with used value time information. // 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 // 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<NumericCalculationNode>(*simplified_tree)) if (!is<NumericCalculationNode>(*simplified_tree))
return {}; return {};
@ -2857,7 +2857,7 @@ static RefPtr<NumericCalculationNode const> make_calculation_node(CalculatedStyl
} }
// https://drafts.csswg.org/css-values-4/#calc-simplification // https://drafts.csswg.org/css-values-4/#calc-simplification
NonnullRefPtr<CalculationNode const> simplify_a_calculation_tree(CalculationNode const& original_root, CalculationContext const& context, CalculationResolutionContext const& resolution_context, PropertyComputationDependencies* property_computation_dependencies) NonnullRefPtr<CalculationNode const> simplify_a_calculation_tree(CalculationNode const& original_root, CalculationContext const& context, CalculationResolutionContext const& resolution_context)
{ {
// To simplify a calculation tree root: // 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. // FIXME: If needed, we could detect that nothing has changed and then return the original `root`, in more places.
@ -2968,7 +2968,7 @@ NonnullRefPtr<CalculationNode const> simplify_a_calculation_tree(CalculationNode
if (root->type() == CalculationNode::Type::NonMathFunction) { if (root->type() == CalculationNode::Type::NonMathFunction) {
// 1. If there is enough information available to determine its numeric value, return its value, expressed in // 1. If there is enough information available to determine its numeric value, return its value, expressed in
// the value’s canonical unit. // the value’s canonical unit.
if (auto resolved_calculation_node = as<NonMathFunctionCalculationNode>(*root).function()->resolve_to_calculation_node(context, resolution_context, property_computation_dependencies)) if (auto resolved_calculation_node = as<NonMathFunctionCalculationNode>(*root).function()->resolve_to_calculation_node(context, resolution_context))
return resolved_calculation_node.release_nonnull(); return resolved_calculation_node.release_nonnull();
// 2. Otherwise, return root. // 2. Otherwise, return root.
@ -2976,7 +2976,7 @@ NonnullRefPtr<CalculationNode const> simplify_a_calculation_tree(CalculationNode
} }
// 3. At this point, root is an operator node. Simplify all the calculation children of root. // 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 // 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 // are numeric values with enough information to compute the operation root represents, return the result of

58
Libraries/LibWeb/CSS/StyleValues/CalculatedStyleValue.h
View file

@ -71,7 +71,7 @@ public:
} }
virtual String to_string(SerializationMode) const override; virtual String to_string(SerializationMode) const override;
virtual ValueComparingNonnullRefPtr<StyleValue const> absolutized(ComputationContext const&, PropertyComputationDependencies&) const override; virtual ValueComparingNonnullRefPtr<StyleValue const> absolutized(ComputationContext const&) const override;
virtual bool equals(StyleValue const& other) const override; virtual bool equals(StyleValue const& other) const override;
NonnullRefPtr<CalculationNode const> calculation() const { return m_calculation; } NonnullRefPtr<CalculationNode const> calculation() const { return m_calculation; }
@ -245,7 +245,7 @@ public:
Optional<NumericType> const& numeric_type() const { return m_numeric_type; } Optional<NumericType> const& numeric_type() const { return m_numeric_type; }
virtual bool contains_percentage() const = 0; virtual bool contains_percentage() const = 0;
virtual NonnullRefPtr<CalculationNode const> with_simplified_children(CalculationContext const&, CalculationResolutionContext const&, PropertyComputationDependencies*) const = 0; virtual NonnullRefPtr<CalculationNode const> with_simplified_children(CalculationContext const&, CalculationResolutionContext const&) const = 0;
// Step 4 of simpliRfy_a_calculation_tree(). Only valid for math-function nodes. // Step 4 of simpliRfy_a_calculation_tree(). Only valid for math-function nodes.
virtual Optional<CalculatedStyleValue::CalculationResult> run_operation_if_possible(CalculationContext const&, CalculationResolutionContext const&) const { VERIFY_NOT_REACHED(); } virtual Optional<CalculatedStyleValue::CalculationResult> run_operation_if_possible(CalculationContext const&, CalculationResolutionContext const&) const { VERIFY_NOT_REACHED(); }
@ -275,7 +275,7 @@ public:
virtual bool contains_percentage() const override; virtual bool contains_percentage() const override;
bool is_in_canonical_unit() const; bool is_in_canonical_unit() const;
virtual NonnullRefPtr<CalculationNode const> with_simplified_children(CalculationContext const&, CalculationResolutionContext const&, PropertyComputationDependencies*) const override { return *this; } virtual NonnullRefPtr<CalculationNode const> with_simplified_children(CalculationContext const&, CalculationResolutionContext const&) const override { return *this; }
virtual Vector<NonnullRefPtr<CalculationNode const>> children() const override { return {}; } virtual Vector<NonnullRefPtr<CalculationNode const>> children() const override { return {}; }
NumericValue const& value() const { return m_value; } NumericValue const& value() const { return m_value; }
@ -300,7 +300,7 @@ public:
~SumCalculationNode(); ~SumCalculationNode();
virtual bool contains_percentage() const override; virtual bool contains_percentage() const override;
virtual NonnullRefPtr<CalculationNode const> with_simplified_children(CalculationContext const&, CalculationResolutionContext const&, PropertyComputationDependencies*) const override; virtual NonnullRefPtr<CalculationNode const> with_simplified_children(CalculationContext const&, CalculationResolutionContext const&) const override;
virtual Vector<NonnullRefPtr<CalculationNode const>> children() const override { return m_values; } virtual Vector<NonnullRefPtr<CalculationNode const>> children() const override { return m_values; }
@ -319,7 +319,7 @@ public:
~ProductCalculationNode(); ~ProductCalculationNode();
virtual bool contains_percentage() const override; virtual bool contains_percentage() const override;
virtual NonnullRefPtr<CalculationNode const> with_simplified_children(CalculationContext const&, CalculationResolutionContext const&, PropertyComputationDependencies*) const override; virtual NonnullRefPtr<CalculationNode const> with_simplified_children(CalculationContext const&, CalculationResolutionContext const&) const override;
virtual Vector<NonnullRefPtr<CalculationNode const>> children() const override { return m_values; } virtual Vector<NonnullRefPtr<CalculationNode const>> children() const override { return m_values; }
@ -338,7 +338,7 @@ public:
~NegateCalculationNode(); ~NegateCalculationNode();
virtual bool contains_percentage() const override; virtual bool contains_percentage() const override;
virtual NonnullRefPtr<CalculationNode const> with_simplified_children(CalculationContext const&, CalculationResolutionContext const&, PropertyComputationDependencies*) const override; virtual NonnullRefPtr<CalculationNode const> with_simplified_children(CalculationContext const&, CalculationResolutionContext const&) const override;
virtual Vector<NonnullRefPtr<CalculationNode const>> children() const override { return { { m_value } }; } virtual Vector<NonnullRefPtr<CalculationNode const>> children() const override { return { { m_value } }; }
CalculationNode const& child() const { return m_value; } CalculationNode const& child() const { return m_value; }
@ -358,7 +358,7 @@ public:
~InvertCalculationNode(); ~InvertCalculationNode();
virtual bool contains_percentage() const override; virtual bool contains_percentage() const override;
virtual NonnullRefPtr<CalculationNode const> with_simplified_children(CalculationContext const&, CalculationResolutionContext const&, PropertyComputationDependencies*) const override; virtual NonnullRefPtr<CalculationNode const> with_simplified_children(CalculationContext const&, CalculationResolutionContext const&) const override;
virtual Vector<NonnullRefPtr<CalculationNode const>> children() const override { return { { m_value } }; } virtual Vector<NonnullRefPtr<CalculationNode const>> children() const override { return { { m_value } }; }
CalculationNode const& child() const { return m_value; } CalculationNode const& child() const { return m_value; }
@ -378,7 +378,7 @@ public:
~MinCalculationNode(); ~MinCalculationNode();
virtual bool contains_percentage() const override; virtual bool contains_percentage() const override;
virtual NonnullRefPtr<CalculationNode const> with_simplified_children(CalculationContext const&, CalculationResolutionContext const&, PropertyComputationDependencies*) const override; virtual NonnullRefPtr<CalculationNode const> with_simplified_children(CalculationContext const&, CalculationResolutionContext const&) const override;
virtual Optional<CalculatedStyleValue::CalculationResult> run_operation_if_possible(CalculationContext const&, CalculationResolutionContext const&) const override; virtual Optional<CalculatedStyleValue::CalculationResult> run_operation_if_possible(CalculationContext const&, CalculationResolutionContext const&) const override;
virtual Vector<NonnullRefPtr<CalculationNode const>> children() const override { return m_values; } virtual Vector<NonnullRefPtr<CalculationNode const>> children() const override { return m_values; }
@ -398,7 +398,7 @@ public:
~MaxCalculationNode(); ~MaxCalculationNode();
virtual bool contains_percentage() const override; virtual bool contains_percentage() const override;
virtual NonnullRefPtr<CalculationNode const> with_simplified_children(CalculationContext const&, CalculationResolutionContext const&, PropertyComputationDependencies*) const override; virtual NonnullRefPtr<CalculationNode const> with_simplified_children(CalculationContext const&, CalculationResolutionContext const&) const override;
virtual Optional<CalculatedStyleValue::CalculationResult> run_operation_if_possible(CalculationContext const&, CalculationResolutionContext const&) const override; virtual Optional<CalculatedStyleValue::CalculationResult> run_operation_if_possible(CalculationContext const&, CalculationResolutionContext const&) const override;
virtual Vector<NonnullRefPtr<CalculationNode const>> children() const override { return m_values; } virtual Vector<NonnullRefPtr<CalculationNode const>> children() const override { return m_values; }
@ -418,7 +418,7 @@ public:
~ClampCalculationNode(); ~ClampCalculationNode();
virtual bool contains_percentage() const override; virtual bool contains_percentage() const override;
virtual NonnullRefPtr<CalculationNode const> with_simplified_children(CalculationContext const&, CalculationResolutionContext const&, PropertyComputationDependencies*) const override; virtual NonnullRefPtr<CalculationNode const> with_simplified_children(CalculationContext const&, CalculationResolutionContext const&) const override;
virtual Optional<CalculatedStyleValue::CalculationResult> run_operation_if_possible(CalculationContext const&, CalculationResolutionContext const&) const override; virtual Optional<CalculatedStyleValue::CalculationResult> run_operation_if_possible(CalculationContext const&, CalculationResolutionContext const&) const override;
virtual Vector<NonnullRefPtr<CalculationNode const>> children() const override { return { { m_min_value, m_center_value, m_max_value } }; } virtual Vector<NonnullRefPtr<CalculationNode const>> children() const override { return { { m_min_value, m_center_value, m_max_value } }; }
@ -440,7 +440,7 @@ public:
~AbsCalculationNode(); ~AbsCalculationNode();
virtual bool contains_percentage() const override; virtual bool contains_percentage() const override;
virtual NonnullRefPtr<CalculationNode const> with_simplified_children(CalculationContext const&, CalculationResolutionContext const&, PropertyComputationDependencies*) const override; virtual NonnullRefPtr<CalculationNode const> with_simplified_children(CalculationContext const&, CalculationResolutionContext const&) const override;
virtual Optional<CalculatedStyleValue::CalculationResult> run_operation_if_possible(CalculationContext const&, CalculationResolutionContext const&) const override; virtual Optional<CalculatedStyleValue::CalculationResult> run_operation_if_possible(CalculationContext const&, CalculationResolutionContext const&) const override;
virtual Vector<NonnullRefPtr<CalculationNode const>> children() const override { return { { m_value } }; } virtual Vector<NonnullRefPtr<CalculationNode const>> children() const override { return { { m_value } }; }
@ -459,7 +459,7 @@ public:
~SignCalculationNode(); ~SignCalculationNode();
virtual bool contains_percentage() const override; virtual bool contains_percentage() const override;
virtual NonnullRefPtr<CalculationNode const> with_simplified_children(CalculationContext const&, CalculationResolutionContext const&, PropertyComputationDependencies*) const override; virtual NonnullRefPtr<CalculationNode const> with_simplified_children(CalculationContext const&, CalculationResolutionContext const&) const override;
virtual Optional<CalculatedStyleValue::CalculationResult> run_operation_if_possible(CalculationContext const&, CalculationResolutionContext const&) const override; virtual Optional<CalculatedStyleValue::CalculationResult> run_operation_if_possible(CalculationContext const&, CalculationResolutionContext const&) const override;
virtual Vector<NonnullRefPtr<CalculationNode const>> children() const override { return { { m_value } }; } virtual Vector<NonnullRefPtr<CalculationNode const>> children() const override { return { { m_value } }; }
@ -478,7 +478,7 @@ public:
~SinCalculationNode(); ~SinCalculationNode();
virtual bool contains_percentage() const override; virtual bool contains_percentage() const override;
virtual NonnullRefPtr<CalculationNode const> with_simplified_children(CalculationContext const&, CalculationResolutionContext const&, PropertyComputationDependencies*) const override; virtual NonnullRefPtr<CalculationNode const> with_simplified_children(CalculationContext const&, CalculationResolutionContext const&) const override;
virtual Optional<CalculatedStyleValue::CalculationResult> run_operation_if_possible(CalculationContext const&, CalculationResolutionContext const&) const override; virtual Optional<CalculatedStyleValue::CalculationResult> run_operation_if_possible(CalculationContext const&, CalculationResolutionContext const&) const override;
virtual Vector<NonnullRefPtr<CalculationNode const>> children() const override { return { { m_value } }; } virtual Vector<NonnullRefPtr<CalculationNode const>> children() const override { return { { m_value } }; }
@ -497,7 +497,7 @@ public:
~CosCalculationNode(); ~CosCalculationNode();
virtual bool contains_percentage() const override; virtual bool contains_percentage() const override;
virtual NonnullRefPtr<CalculationNode const> with_simplified_children(CalculationContext const&, CalculationResolutionContext const&, PropertyComputationDependencies*) const override; virtual NonnullRefPtr<CalculationNode const> with_simplified_children(CalculationContext const&, CalculationResolutionContext const&) const override;
virtual Optional<CalculatedStyleValue::CalculationResult> run_operation_if_possible(CalculationContext const&, CalculationResolutionContext const&) const override; virtual Optional<CalculatedStyleValue::CalculationResult> run_operation_if_possible(CalculationContext const&, CalculationResolutionContext const&) const override;
virtual Vector<NonnullRefPtr<CalculationNode const>> children() const override { return { { m_value } }; } virtual Vector<NonnullRefPtr<CalculationNode const>> children() const override { return { { m_value } }; }
@ -516,7 +516,7 @@ public:
~TanCalculationNode(); ~TanCalculationNode();
virtual bool contains_percentage() const override; virtual bool contains_percentage() const override;
virtual NonnullRefPtr<CalculationNode const> with_simplified_children(CalculationContext const&, CalculationResolutionContext const&, PropertyComputationDependencies*) const override; virtual NonnullRefPtr<CalculationNode const> with_simplified_children(CalculationContext const&, CalculationResolutionContext const&) const override;
virtual Optional<CalculatedStyleValue::CalculationResult> run_operation_if_possible(CalculationContext const&, CalculationResolutionContext const&) const override; virtual Optional<CalculatedStyleValue::CalculationResult> run_operation_if_possible(CalculationContext const&, CalculationResolutionContext const&) const override;
virtual Vector<NonnullRefPtr<CalculationNode const>> children() const override { return { { m_value } }; } virtual Vector<NonnullRefPtr<CalculationNode const>> children() const override { return { { m_value } }; }
@ -535,7 +535,7 @@ public:
~AsinCalculationNode(); ~AsinCalculationNode();
virtual bool contains_percentage() const override; virtual bool contains_percentage() const override;
virtual NonnullRefPtr<CalculationNode const> with_simplified_children(CalculationContext const&, CalculationResolutionContext const&, PropertyComputationDependencies*) const override; virtual NonnullRefPtr<CalculationNode const> with_simplified_children(CalculationContext const&, CalculationResolutionContext const&) const override;
virtual Optional<CalculatedStyleValue::CalculationResult> run_operation_if_possible(CalculationContext const&, CalculationResolutionContext const&) const override; virtual Optional<CalculatedStyleValue::CalculationResult> run_operation_if_possible(CalculationContext const&, CalculationResolutionContext const&) const override;
virtual Vector<NonnullRefPtr<CalculationNode const>> children() const override { return { { m_value } }; } virtual Vector<NonnullRefPtr<CalculationNode const>> children() const override { return { { m_value } }; }
@ -554,7 +554,7 @@ public:
~AcosCalculationNode(); ~AcosCalculationNode();
virtual bool contains_percentage() const override; virtual bool contains_percentage() const override;
virtual NonnullRefPtr<CalculationNode const> with_simplified_children(CalculationContext const&, CalculationResolutionContext const&, PropertyComputationDependencies*) const override; virtual NonnullRefPtr<CalculationNode const> with_simplified_children(CalculationContext const&, CalculationResolutionContext const&) const override;
virtual Optional<CalculatedStyleValue::CalculationResult> run_operation_if_possible(CalculationContext const&, CalculationResolutionContext const&) const override; virtual Optional<CalculatedStyleValue::CalculationResult> run_operation_if_possible(CalculationContext const&, CalculationResolutionContext const&) const override;
virtual Vector<NonnullRefPtr<CalculationNode const>> children() const override { return { { m_value } }; } virtual Vector<NonnullRefPtr<CalculationNode const>> children() const override { return { { m_value } }; }
@ -573,7 +573,7 @@ public:
~AtanCalculationNode(); ~AtanCalculationNode();
virtual bool contains_percentage() const override; virtual bool contains_percentage() const override;
virtual NonnullRefPtr<CalculationNode const> with_simplified_children(CalculationContext const&, CalculationResolutionContext const&, PropertyComputationDependencies*) const override; virtual NonnullRefPtr<CalculationNode const> with_simplified_children(CalculationContext const&, CalculationResolutionContext const&) const override;
virtual Optional<CalculatedStyleValue::CalculationResult> run_operation_if_possible(CalculationContext const&, CalculationResolutionContext const&) const override; virtual Optional<CalculatedStyleValue::CalculationResult> run_operation_if_possible(CalculationContext const&, CalculationResolutionContext const&) const override;
virtual Vector<NonnullRefPtr<CalculationNode const>> children() const override { return { { m_value } }; } virtual Vector<NonnullRefPtr<CalculationNode const>> children() const override { return { { m_value } }; }
@ -592,7 +592,7 @@ public:
~Atan2CalculationNode(); ~Atan2CalculationNode();
virtual bool contains_percentage() const override; virtual bool contains_percentage() const override;
virtual NonnullRefPtr<CalculationNode const> with_simplified_children(CalculationContext const&, CalculationResolutionContext const&, PropertyComputationDependencies*) const override; virtual NonnullRefPtr<CalculationNode const> with_simplified_children(CalculationContext const&, CalculationResolutionContext const&) const override;
virtual Optional<CalculatedStyleValue::CalculationResult> run_operation_if_possible(CalculationContext const&, CalculationResolutionContext const&) const override; virtual Optional<CalculatedStyleValue::CalculationResult> run_operation_if_possible(CalculationContext const&, CalculationResolutionContext const&) const override;
virtual Vector<NonnullRefPtr<CalculationNode const>> children() const override { return { { m_y, m_x } }; } virtual Vector<NonnullRefPtr<CalculationNode const>> children() const override { return { { m_y, m_x } }; }
@ -612,7 +612,7 @@ public:
~PowCalculationNode(); ~PowCalculationNode();
virtual bool contains_percentage() const override { return false; } virtual bool contains_percentage() const override { return false; }
virtual NonnullRefPtr<CalculationNode const> with_simplified_children(CalculationContext const&, CalculationResolutionContext const&, PropertyComputationDependencies*) const override; virtual NonnullRefPtr<CalculationNode const> with_simplified_children(CalculationContext const&, CalculationResolutionContext const&) const override;
virtual Optional<CalculatedStyleValue::CalculationResult> run_operation_if_possible(CalculationContext const&, CalculationResolutionContext const&) const override; virtual Optional<CalculatedStyleValue::CalculationResult> run_operation_if_possible(CalculationContext const&, CalculationResolutionContext const&) const override;
virtual Vector<NonnullRefPtr<CalculationNode const>> children() const override { return { { m_x, m_y } }; } virtual Vector<NonnullRefPtr<CalculationNode const>> children() const override { return { { m_x, m_y } }; }
@ -632,7 +632,7 @@ public:
~SqrtCalculationNode(); ~SqrtCalculationNode();
virtual bool contains_percentage() const override { return false; } virtual bool contains_percentage() const override { return false; }
virtual NonnullRefPtr<CalculationNode const> with_simplified_children(CalculationContext const&, CalculationResolutionContext const&, PropertyComputationDependencies*) const override; virtual NonnullRefPtr<CalculationNode const> with_simplified_children(CalculationContext const&, CalculationResolutionContext const&) const override;
virtual Optional<CalculatedStyleValue::CalculationResult> run_operation_if_possible(CalculationContext const&, CalculationResolutionContext const&) const override; virtual Optional<CalculatedStyleValue::CalculationResult> run_operation_if_possible(CalculationContext const&, CalculationResolutionContext const&) const override;
virtual Vector<NonnullRefPtr<CalculationNode const>> children() const override { return { { m_value } }; } virtual Vector<NonnullRefPtr<CalculationNode const>> children() const override { return { { m_value } }; }
@ -651,7 +651,7 @@ public:
~HypotCalculationNode(); ~HypotCalculationNode();
virtual bool contains_percentage() const override; virtual bool contains_percentage() const override;
virtual NonnullRefPtr<CalculationNode const> with_simplified_children(CalculationContext const&, CalculationResolutionContext const&, PropertyComputationDependencies*) const override; virtual NonnullRefPtr<CalculationNode const> with_simplified_children(CalculationContext const&, CalculationResolutionContext const&) const override;
virtual Optional<CalculatedStyleValue::CalculationResult> run_operation_if_possible(CalculationContext const&, CalculationResolutionContext const&) const override; virtual Optional<CalculatedStyleValue::CalculationResult> run_operation_if_possible(CalculationContext const&, CalculationResolutionContext const&) const override;
virtual Vector<NonnullRefPtr<CalculationNode const>> children() const override { return m_values; } virtual Vector<NonnullRefPtr<CalculationNode const>> children() const override { return m_values; }
@ -670,7 +670,7 @@ public:
~LogCalculationNode(); ~LogCalculationNode();
virtual bool contains_percentage() const override { return false; } virtual bool contains_percentage() const override { return false; }
virtual NonnullRefPtr<CalculationNode const> with_simplified_children(CalculationContext const&, CalculationResolutionContext const&, PropertyComputationDependencies*) const override; virtual NonnullRefPtr<CalculationNode const> with_simplified_children(CalculationContext const&, CalculationResolutionContext const&) const override;
virtual Optional<CalculatedStyleValue::CalculationResult> run_operation_if_possible(CalculationContext const&, CalculationResolutionContext const&) const override; virtual Optional<CalculatedStyleValue::CalculationResult> run_operation_if_possible(CalculationContext const&, CalculationResolutionContext const&) const override;
virtual Vector<NonnullRefPtr<CalculationNode const>> children() const override { return { { m_x, m_y } }; } virtual Vector<NonnullRefPtr<CalculationNode const>> children() const override { return { { m_x, m_y } }; }
@ -690,7 +690,7 @@ public:
~ExpCalculationNode(); ~ExpCalculationNode();
virtual bool contains_percentage() const override { return false; } virtual bool contains_percentage() const override { return false; }
virtual NonnullRefPtr<CalculationNode const> with_simplified_children(CalculationContext const&, CalculationResolutionContext const&, PropertyComputationDependencies*) const override; virtual NonnullRefPtr<CalculationNode const> with_simplified_children(CalculationContext const&, CalculationResolutionContext const&) const override;
virtual Optional<CalculatedStyleValue::CalculationResult> run_operation_if_possible(CalculationContext const&, CalculationResolutionContext const&) const override; virtual Optional<CalculatedStyleValue::CalculationResult> run_operation_if_possible(CalculationContext const&, CalculationResolutionContext const&) const override;
virtual Vector<NonnullRefPtr<CalculationNode const>> children() const override { return { { m_value } }; } virtual Vector<NonnullRefPtr<CalculationNode const>> children() const override { return { { m_value } }; }
@ -709,7 +709,7 @@ public:
~RoundCalculationNode(); ~RoundCalculationNode();
virtual bool contains_percentage() const override; virtual bool contains_percentage() const override;
virtual NonnullRefPtr<CalculationNode const> with_simplified_children(CalculationContext const&, CalculationResolutionContext const&, PropertyComputationDependencies*) const override; virtual NonnullRefPtr<CalculationNode const> with_simplified_children(CalculationContext const&, CalculationResolutionContext const&) const override;
virtual Optional<CalculatedStyleValue::CalculationResult> run_operation_if_possible(CalculationContext const&, CalculationResolutionContext const&) const override; virtual Optional<CalculatedStyleValue::CalculationResult> run_operation_if_possible(CalculationContext const&, CalculationResolutionContext const&) const override;
// NOTE: This excludes the rounding strategy! // NOTE: This excludes the rounding strategy!
@ -732,7 +732,7 @@ public:
~ModCalculationNode(); ~ModCalculationNode();
virtual bool contains_percentage() const override; virtual bool contains_percentage() const override;
virtual NonnullRefPtr<CalculationNode const> with_simplified_children(CalculationContext const&, CalculationResolutionContext const&, PropertyComputationDependencies*) const override; virtual NonnullRefPtr<CalculationNode const> with_simplified_children(CalculationContext const&, CalculationResolutionContext const&) const override;
virtual Optional<CalculatedStyleValue::CalculationResult> run_operation_if_possible(CalculationContext const&, CalculationResolutionContext const&) const override; virtual Optional<CalculatedStyleValue::CalculationResult> run_operation_if_possible(CalculationContext const&, CalculationResolutionContext const&) const override;
virtual Vector<NonnullRefPtr<CalculationNode const>> children() const override { return { { m_x, m_y } }; } virtual Vector<NonnullRefPtr<CalculationNode const>> children() const override { return { { m_x, m_y } }; }
@ -752,7 +752,7 @@ public:
~RemCalculationNode(); ~RemCalculationNode();
virtual bool contains_percentage() const override; virtual bool contains_percentage() const override;
virtual NonnullRefPtr<CalculationNode const> with_simplified_children(CalculationContext const&, CalculationResolutionContext const&, PropertyComputationDependencies*) const override; virtual NonnullRefPtr<CalculationNode const> with_simplified_children(CalculationContext const&, CalculationResolutionContext const&) const override;
virtual Optional<CalculatedStyleValue::CalculationResult> run_operation_if_possible(CalculationContext const&, CalculationResolutionContext const&) const override; virtual Optional<CalculatedStyleValue::CalculationResult> run_operation_if_possible(CalculationContext const&, CalculationResolutionContext const&) const override;
virtual Vector<NonnullRefPtr<CalculationNode const>> children() const override { return { { m_x, m_y } }; } virtual Vector<NonnullRefPtr<CalculationNode const>> children() const override { return { { m_x, m_y } }; }
@ -772,7 +772,7 @@ public:
~NonMathFunctionCalculationNode(); ~NonMathFunctionCalculationNode();
virtual bool contains_percentage() const override { return false; } virtual bool contains_percentage() const override { return false; }
virtual NonnullRefPtr<CalculationNode const> with_simplified_children(CalculationContext const&, CalculationResolutionContext const&, PropertyComputationDependencies*) const override { return *this; } virtual NonnullRefPtr<CalculationNode const> with_simplified_children(CalculationContext const&, CalculationResolutionContext const&) const override { return *this; }
virtual Vector<NonnullRefPtr<CalculationNode const>> children() const override { return {}; } virtual Vector<NonnullRefPtr<CalculationNode const>> children() const override { return {}; }
virtual void dump(StringBuilder&, int indent) const override; virtual void dump(StringBuilder&, int indent) const override;
@ -786,6 +786,6 @@ private:
}; };
// https://drafts.csswg.org/css-values-4/#calc-simplification // https://drafts.csswg.org/css-values-4/#calc-simplification
NonnullRefPtr<CalculationNode const> simplify_a_calculation_tree(CalculationNode const& root, CalculationContext const& context, CalculationResolutionContext const& resolution_context, PropertyComputationDependencies* property_computation_dependencies); NonnullRefPtr<CalculationNode const> simplify_a_calculation_tree(CalculationNode const& root, CalculationContext const& context, CalculationResolutionContext const& resolution_context);
} }

4
Libraries/LibWeb/CSS/StyleValues/CounterDefinitionsStyleValue.cpp
View file

@ -29,7 +29,7 @@ String CounterDefinitionsStyleValue::to_string(SerializationMode mode) const
return stb.to_string_without_validation(); return stb.to_string_without_validation();
} }
ValueComparingNonnullRefPtr<StyleValue const> CounterDefinitionsStyleValue::absolutized(ComputationContext const& computation_context, PropertyComputationDependencies& property_computation_dependencies) const ValueComparingNonnullRefPtr<StyleValue const> CounterDefinitionsStyleValue::absolutized(ComputationContext const& computation_context) const
{ {
Vector<CounterDefinition> computed_definitions; Vector<CounterDefinition> computed_definitions;
@ -41,7 +41,7 @@ ValueComparingNonnullRefPtr<StyleValue const> CounterDefinitionsStyleValue::abso
}; };
if (specified_definition.value) 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); computed_definitions.append(computed_definition);
} }

2
Libraries/LibWeb/CSS/StyleValues/CounterDefinitionsStyleValue.h
View file

@ -31,7 +31,7 @@ public:
auto const& counter_definitions() const { return m_counter_definitions; } auto const& counter_definitions() const { return m_counter_definitions; }
virtual String to_string(SerializationMode) const override; virtual String to_string(SerializationMode) const override;
virtual ValueComparingNonnullRefPtr<StyleValue const> absolutized(ComputationContext const&, PropertyComputationDependencies&) const override; virtual ValueComparingNonnullRefPtr<StyleValue const> absolutized(ComputationContext const&) const override;
bool properties_equal(CounterDefinitionsStyleValue const& other) const; bool properties_equal(CounterDefinitionsStyleValue const& other) const;

8
Libraries/LibWeb/CSS/StyleValues/CursorStyleValue.cpp
View file

@ -30,18 +30,18 @@ String CursorStyleValue::to_string(SerializationMode mode) const
return builder.to_string_without_validation(); return builder.to_string_without_validation();
} }
ValueComparingNonnullRefPtr<StyleValue const> CursorStyleValue::absolutized(ComputationContext const& computation_context, PropertyComputationDependencies& property_computation_dependencies) const ValueComparingNonnullRefPtr<StyleValue const> CursorStyleValue::absolutized(ComputationContext const& computation_context) const
{ {
RefPtr<StyleValue const> absolutized_x; RefPtr<StyleValue const> absolutized_x;
RefPtr<StyleValue const> absolutized_y; RefPtr<StyleValue const> absolutized_y;
if (m_properties.x) 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) 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<Gfx::ImageCursor> CursorStyleValue::make_image_cursor(Layout::NodeWithStyle const& layout_node) const Optional<Gfx::ImageCursor> CursorStyleValue::make_image_cursor(Layout::NodeWithStyle const& layout_node) const

2
Libraries/LibWeb/CSS/StyleValues/CursorStyleValue.h
View file

@ -30,7 +30,7 @@ public:
virtual String to_string(SerializationMode) const override; virtual String to_string(SerializationMode) const override;
virtual ValueComparingNonnullRefPtr<StyleValue const> absolutized(ComputationContext const&, PropertyComputationDependencies&) const override; virtual ValueComparingNonnullRefPtr<StyleValue const> absolutized(ComputationContext const&) const override;
bool properties_equal(CursorStyleValue const& other) const { return m_properties == other.m_properties; } bool properties_equal(CursorStyleValue const& other) const { return m_properties == other.m_properties; }

16
Libraries/LibWeb/CSS/StyleValues/EasingStyleValue.cpp
View file

@ -84,7 +84,7 @@ String EasingStyleValue::Function::to_string(SerializationMode mode) const
}); });
} }
ValueComparingNonnullRefPtr<StyleValue const> EasingStyleValue::absolutized(ComputationContext const& computation_context, PropertyComputationDependencies& property_computation_dependencies) const ValueComparingNonnullRefPtr<StyleValue const> EasingStyleValue::absolutized(ComputationContext const& computation_context) const
{ {
auto const& absolutized_function = m_function.visit( auto const& absolutized_function = m_function.visit(
[&](Linear const& linear) -> Function { [&](Linear const& linear) -> Function {
@ -94,24 +94,24 @@ ValueComparingNonnullRefPtr<StyleValue const> EasingStyleValue::absolutized(Comp
RefPtr<StyleValue const> absolutized_input; RefPtr<StyleValue const> absolutized_input;
if (stop.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 }; return Linear { absolutized_stops };
}, },
[&](CubicBezier const& cubic_bezier) -> Function { [&](CubicBezier const& cubic_bezier) -> Function {
return CubicBezier { return CubicBezier {
cubic_bezier.x1->absolutized(computation_context, property_computation_dependencies), cubic_bezier.x1->absolutized(computation_context),
cubic_bezier.y1->absolutized(computation_context, property_computation_dependencies), cubic_bezier.y1->absolutized(computation_context),
cubic_bezier.x2->absolutized(computation_context, property_computation_dependencies), cubic_bezier.x2->absolutized(computation_context),
cubic_bezier.y2->absolutized(computation_context, property_computation_dependencies) cubic_bezier.y2->absolutized(computation_context)
}; };
}, },
[&](Steps const& steps) -> Function { [&](Steps const& steps) -> Function {
return Steps { return Steps {
steps.number_of_intervals->absolutized(computation_context, property_computation_dependencies), steps.number_of_intervals->absolutized(computation_context),
steps.position steps.position
}; };
}); });

2
Libraries/LibWeb/CSS/StyleValues/EasingStyleValue.h
View file

@ -80,7 +80,7 @@ public:
virtual String to_string(SerializationMode mode) const override { return m_function.to_string(mode); } virtual String to_string(SerializationMode mode) const override { return m_function.to_string(mode); }
virtual ValueComparingNonnullRefPtr<StyleValue const> absolutized(ComputationContext const&, PropertyComputationDependencies&) const override; virtual ValueComparingNonnullRefPtr<StyleValue const> absolutized(ComputationContext const&) const override;
bool properties_equal(EasingStyleValue const& other) const { return m_function == other.m_function; } bool properties_equal(EasingStyleValue const& other) const { return m_function == other.m_function; }

4
Libraries/LibWeb/CSS/StyleValues/FontStyleStyleValue.cpp
View file

@ -56,12 +56,12 @@ String FontStyleStyleValue::to_string(SerializationMode mode) const
return MUST(builder.to_string()); return MUST(builder.to_string());
} }
ValueComparingNonnullRefPtr<StyleValue const> FontStyleStyleValue::absolutized(ComputationContext const& computation_context, PropertyComputationDependencies& property_computation_dependencies) const ValueComparingNonnullRefPtr<StyleValue const> FontStyleStyleValue::absolutized(ComputationContext const& computation_context) const
{ {
ValueComparingRefPtr<StyleValue const> absolutized_angle; ValueComparingRefPtr<StyleValue const> absolutized_angle;
if (m_angle_value) 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) if (absolutized_angle == m_angle_value)
return *this; return *this;

2
Libraries/LibWeb/CSS/StyleValues/FontStyleStyleValue.h
View file

@ -26,7 +26,7 @@ public:
int to_font_slope() const; int to_font_slope() const;
virtual String to_string(SerializationMode) const override; virtual String to_string(SerializationMode) const override;
virtual ValueComparingNonnullRefPtr<StyleValue const> absolutized(ComputationContext const& computation_context, PropertyComputationDependencies&) const override; virtual ValueComparingNonnullRefPtr<StyleValue const> absolutized(ComputationContext const& computation_context) const override;
bool equals(StyleValue const& other) const override bool equals(StyleValue const& other) const override
{ {

2
Libraries/LibWeb/CSS/StyleValues/ImageStyleValue.cpp
View file

@ -186,7 +186,7 @@ void ImageStyleValue::set_style_sheet(GC::Ptr<CSSStyleSheet> style_sheet)
m_style_sheet = style_sheet; m_style_sheet = style_sheet;
} }
ValueComparingNonnullRefPtr<StyleValue const> ImageStyleValue::absolutized(ComputationContext const&, PropertyComputationDependencies&) const ValueComparingNonnullRefPtr<StyleValue const> ImageStyleValue::absolutized(ComputationContext const&) const
{ {
if (m_url.url().is_empty()) if (m_url.url().is_empty())
return *this; return *this;

2
Libraries/LibWeb/CSS/StyleValues/ImageStyleValue.h
View file

@ -72,7 +72,7 @@ private:
virtual void set_style_sheet(GC::Ptr<CSSStyleSheet>) override; virtual void set_style_sheet(GC::Ptr<CSSStyleSheet>) override;
virtual ValueComparingNonnullRefPtr<StyleValue const> absolutized(ComputationContext const&, PropertyComputationDependencies&) const override; virtual ValueComparingNonnullRefPtr<StyleValue const> absolutized(ComputationContext const&) const override;
void animate(); void animate();
Gfx::ImmutableBitmap const* bitmap(size_t frame_index, Gfx::IntSize = {}) const; Gfx::ImmutableBitmap const* bitmap(size_t frame_index, Gfx::IntSize = {}) const;

2
Libraries/LibWeb/CSS/StyleValues/LengthStyleValue.cpp
View file

@ -26,7 +26,7 @@ ValueComparingNonnullRefPtr<LengthStyleValue const> LengthStyleValue::create(Len
return adopt_ref(*new (nothrow) LengthStyleValue(length)); return adopt_ref(*new (nothrow) LengthStyleValue(length));
} }
ValueComparingNonnullRefPtr<StyleValue const> LengthStyleValue::absolutized(ComputationContext const& computation_context, PropertyComputationDependencies&) const ValueComparingNonnullRefPtr<StyleValue const> 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()) 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()); return LengthStyleValue::create(length.release_value());

2
Libraries/LibWeb/CSS/StyleValues/LengthStyleValue.h
View file

@ -25,7 +25,7 @@ public:
virtual FlyString unit_name() const override { return m_length.unit_name(); } 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 String to_string(SerializationMode serialization_mode) const override { return m_length.to_string(serialization_mode); }
virtual ValueComparingNonnullRefPtr<StyleValue const> absolutized(ComputationContext const&, PropertyComputationDependencies&) const override; virtual ValueComparingNonnullRefPtr<StyleValue const> absolutized(ComputationContext const&) const override;
bool equals(StyleValue const& other) const override; bool equals(StyleValue const& other) const override;

4
Libraries/LibWeb/CSS/StyleValues/OpenTypeTaggedStyleValue.cpp
View file

@ -9,9 +9,9 @@
namespace Web::CSS { namespace Web::CSS {
ValueComparingNonnullRefPtr<StyleValue const> OpenTypeTaggedStyleValue::absolutized(ComputationContext const& computation_context, PropertyComputationDependencies& property_computation_dependencies) const ValueComparingNonnullRefPtr<StyleValue const> 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) if (absolutized_value == m_value)
return *this; return *this;

2
Libraries/LibWeb/CSS/StyleValues/OpenTypeTaggedStyleValue.h
View file

@ -29,7 +29,7 @@ public:
FlyString const& tag() const { return m_tag; } FlyString const& tag() const { return m_tag; }
ValueComparingNonnullRefPtr<StyleValue const> const& value() const { return m_value; } ValueComparingNonnullRefPtr<StyleValue const> const& value() const { return m_value; }
virtual ValueComparingNonnullRefPtr<StyleValue const> absolutized(ComputationContext const&, PropertyComputationDependencies&) const override; virtual ValueComparingNonnullRefPtr<StyleValue const> absolutized(ComputationContext const&) const override;
virtual String to_string(SerializationMode) const override; virtual String to_string(SerializationMode) const override;

10
Libraries/LibWeb/CSS/StyleValues/ShadowStyleValue.cpp
View file

@ -56,12 +56,12 @@ ValueComparingNonnullRefPtr<StyleValue const> ShadowStyleValue::spread_distance(
return *m_properties.spread_distance; return *m_properties.spread_distance;
} }
ValueComparingNonnullRefPtr<StyleValue const> ShadowStyleValue::absolutized(ComputationContext const& computation_context, PropertyComputationDependencies& property_computation_dependencies) const ValueComparingNonnullRefPtr<StyleValue const> ShadowStyleValue::absolutized(ComputationContext const& computation_context) const
{ {
auto absolutized_offset_x = offset_x()->absolutized(computation_context, property_computation_dependencies); auto absolutized_offset_x = offset_x()->absolutized(computation_context);
auto absolutized_offset_y = offset_y()->absolutized(computation_context, property_computation_dependencies); auto absolutized_offset_y = offset_y()->absolutized(computation_context);
auto absolutized_blur_radius = blur_radius()->absolutized(computation_context, property_computation_dependencies); auto absolutized_blur_radius = blur_radius()->absolutized(computation_context);
auto absolutized_spread_distance = spread_distance()->absolutized(computation_context, property_computation_dependencies); 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()); return create(m_properties.shadow_type, color(), absolutized_offset_x, absolutized_offset_y, absolutized_blur_radius, absolutized_spread_distance, placement());
} }

2
Libraries/LibWeb/CSS/StyleValues/ShadowStyleValue.h
View file

@ -76,7 +76,7 @@ private:
{ {
} }
virtual ValueComparingNonnullRefPtr<StyleValue const> absolutized(ComputationContext const&, PropertyComputationDependencies&) const override; virtual ValueComparingNonnullRefPtr<StyleValue const> absolutized(ComputationContext const&) const override;
struct Properties { struct Properties {
ShadowType shadow_type; ShadowType shadow_type;
ValueComparingRefPtr<StyleValue const> color; ValueComparingRefPtr<StyleValue const> color;

2
Libraries/LibWeb/CSS/StyleValues/StyleValue.cpp
View file

@ -130,7 +130,7 @@ DimensionStyleValue const& StyleValue::as_dimension() const
ENUMERATE_CSS_STYLE_VALUE_TYPES ENUMERATE_CSS_STYLE_VALUE_TYPES
#undef __ENUMERATE_CSS_STYLE_VALUE_TYPE #undef __ENUMERATE_CSS_STYLE_VALUE_TYPE
ValueComparingNonnullRefPtr<StyleValue const> StyleValue::absolutized(ComputationContext const&, PropertyComputationDependencies&) const ValueComparingNonnullRefPtr<StyleValue const> StyleValue::absolutized(ComputationContext const&) const
{ {
return *this; return *this;
} }

6
Libraries/LibWeb/CSS/StyleValues/StyleValue.h
View file

@ -157,10 +157,6 @@ struct ColorResolutionContext {
[[nodiscard]] static ColorResolutionContext for_layout_node_with_style(Layout::NodeWithStyle const&); [[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<StyleValue> { class WEB_API StyleValue : public RefCounted<StyleValue> {
public: public:
virtual ~StyleValue() = default; virtual ~StyleValue() = default;
@ -208,7 +204,7 @@ public:
bool has_auto() const; bool has_auto() const;
virtual bool has_color() const { return false; } virtual bool has_color() const { return false; }
virtual ValueComparingNonnullRefPtr<StyleValue const> absolutized(ComputationContext const&, PropertyComputationDependencies&) const; virtual ValueComparingNonnullRefPtr<StyleValue const> absolutized(ComputationContext const&) const;
virtual Optional<Color> to_color(ColorResolutionContext) const { return {}; } virtual Optional<Color> to_color(ColorResolutionContext) const { return {}; }
Keyword to_keyword() const; Keyword to_keyword() const;

4
Libraries/LibWeb/CSS/StyleValues/StyleValueList.cpp
View file

@ -22,13 +22,13 @@ bool StyleValueList::Properties::operator==(Properties const& other) const
return separator == other.separator && values.span() == other.values.span(); return separator == other.separator && values.span() == other.values.span();
} }
ValueComparingNonnullRefPtr<StyleValue const> StyleValueList::absolutized(ComputationContext const& computation_context, PropertyComputationDependencies& property_computation_dependencies) const ValueComparingNonnullRefPtr<StyleValue const> StyleValueList::absolutized(ComputationContext const& computation_context) const
{ {
StyleValueVector absolutized_style_values; StyleValueVector absolutized_style_values;
absolutized_style_values.ensure_capacity(m_properties.values.size()); absolutized_style_values.ensure_capacity(m_properties.values.size());
for (auto const& value : m_properties.values) 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); return StyleValueList::create(move(absolutized_style_values), m_properties.separator);
} }

2
Libraries/LibWeb/CSS/StyleValues/StyleValueList.h
View file

@ -37,7 +37,7 @@ public:
virtual Vector<Parser::ComponentValue> tokenize() const override; virtual Vector<Parser::ComponentValue> tokenize() const override;
virtual GC::Ref<CSSStyleValue> reify(JS::Realm&, FlyString const& associated_property) const override; virtual GC::Ref<CSSStyleValue> reify(JS::Realm&, FlyString const& associated_property) const override;
virtual ValueComparingNonnullRefPtr<StyleValue const> absolutized(ComputationContext const&, PropertyComputationDependencies&) const override; virtual ValueComparingNonnullRefPtr<StyleValue const> absolutized(ComputationContext const&) const override;
bool properties_equal(StyleValueList const& other) const { return m_properties == other.m_properties; } bool properties_equal(StyleValueList const& other) const { return m_properties == other.m_properties; }

4
Libraries/LibWeb/CSS/StyleValues/SuperellipseStyleValue.cpp
View file

@ -50,9 +50,9 @@ String SuperellipseStyleValue::to_string(SerializationMode mode) const
return MUST(String::formatted("superellipse({})", stringified_parameter)); return MUST(String::formatted("superellipse({})", stringified_parameter));
} }
ValueComparingNonnullRefPtr<StyleValue const> SuperellipseStyleValue::absolutized(ComputationContext const& computation_context, PropertyComputationDependencies& property_computation_dependencies) const ValueComparingNonnullRefPtr<StyleValue const> 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) if (absolutized_parameter == m_parameter)
return *this; return *this;

2
Libraries/LibWeb/CSS/StyleValues/SuperellipseStyleValue.h
View file

@ -31,7 +31,7 @@ public:
virtual String to_string(SerializationMode serialization_mode) const override; virtual String to_string(SerializationMode serialization_mode) const override;
virtual ValueComparingNonnullRefPtr<StyleValue const> absolutized(ComputationContext const&, PropertyComputationDependencies&) const override; virtual ValueComparingNonnullRefPtr<StyleValue const> absolutized(ComputationContext const&) const override;
bool properties_equal(SuperellipseStyleValue const& other) const { return m_parameter == other.m_parameter; } bool properties_equal(SuperellipseStyleValue const& other) const { return m_parameter == other.m_parameter; }

4
Libraries/LibWeb/CSS/StyleValues/TransformationStyleValue.cpp
View file

@ -375,14 +375,14 @@ GC::Ref<CSSTransformComponent> TransformationStyleValue::reify_a_transform_funct
VERIFY_NOT_REACHED(); VERIFY_NOT_REACHED();
} }
ValueComparingNonnullRefPtr<StyleValue const> TransformationStyleValue::absolutized(ComputationContext const& computation_context, PropertyComputationDependencies& property_computation_dependencies) const ValueComparingNonnullRefPtr<StyleValue const> TransformationStyleValue::absolutized(ComputationContext const& computation_context) const
{ {
StyleValueVector absolutized_values; StyleValueVector absolutized_values;
bool absolutized_values_different = false; bool absolutized_values_different = false;
for (auto const& value : m_properties.values) { 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) if (absolutized_value != value)
absolutized_values_different = true; absolutized_values_different = true;

2
Libraries/LibWeb/CSS/StyleValues/TransformationStyleValue.h
View file

@ -30,7 +30,7 @@ public:
virtual String to_string(SerializationMode) const override; virtual String to_string(SerializationMode) const override;
GC::Ref<CSSTransformComponent> reify_a_transform_function(JS::Realm&) const; GC::Ref<CSSTransformComponent> reify_a_transform_function(JS::Realm&) const;
virtual ValueComparingNonnullRefPtr<StyleValue const> absolutized(ComputationContext const&, PropertyComputationDependencies&) const override; virtual ValueComparingNonnullRefPtr<StyleValue const> absolutized(ComputationContext const&) const override;
bool properties_equal(TransformationStyleValue const& other) const { return m_properties == other.m_properties; } bool properties_equal(TransformationStyleValue const& other) const { return m_properties == other.m_properties; }

15
Libraries/LibWeb/CSS/StyleValues/TreeCountingFunctionStyleValue.cpp
View file

@ -8,6 +8,7 @@
#include <LibWeb/CSS/StyleValues/CalculatedStyleValue.h> #include <LibWeb/CSS/StyleValues/CalculatedStyleValue.h>
#include <LibWeb/CSS/StyleValues/IntegerStyleValue.h> #include <LibWeb/CSS/StyleValues/IntegerStyleValue.h>
#include <LibWeb/CSS/StyleValues/NumberStyleValue.h> #include <LibWeb/CSS/StyleValues/NumberStyleValue.h>
#include <LibWeb/DOM/Element.h>
namespace Web::CSS { namespace Web::CSS {
@ -23,9 +24,9 @@ String TreeCountingFunctionStyleValue::to_string(SerializationMode) const
VERIFY_NOT_REACHED(); 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<DOM::Element&>(abstract_element.element()).set_style_uses_tree_counting_function();
auto tree_counting_function_resolution_context = abstract_element.tree_counting_function_resolution_context(); 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(); VERIFY_NOT_REACHED();
} }
RefPtr<CalculationNode const> TreeCountingFunctionStyleValue::resolve_to_calculation_node(CalculationContext const& calculation_context, CalculationResolutionContext const& calculation_resolution_context, PropertyComputationDependencies* property_computation_dependencies) const RefPtr<CalculationNode const> TreeCountingFunctionStyleValue::resolve_to_calculation_node(CalculationContext const& calculation_context, CalculationResolutionContext const& calculation_resolution_context) const
{ {
if (!calculation_resolution_context.abstract_element.has_value()) if (!calculation_resolution_context.abstract_element.has_value())
return nullptr; return nullptr;
VERIFY(property_computation_dependencies); return NumericCalculationNode::create(Number { Number::Type::Number, static_cast<double>(resolve(calculation_resolution_context.abstract_element.value())) }, calculation_context);
return NumericCalculationNode::create(Number { Number::Type::Number, static_cast<double>(resolve(calculation_resolution_context.abstract_element.value(), *property_computation_dependencies)) }, calculation_context);
} }
ValueComparingNonnullRefPtr<StyleValue const> TreeCountingFunctionStyleValue::absolutized(ComputationContext const& computation_context, PropertyComputationDependencies& property_computation_dependencies) const ValueComparingNonnullRefPtr<StyleValue const> 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 // 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()); 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) { switch (m_computed_type) {
case ComputedType::Integer: case ComputedType::Integer:

6
Libraries/LibWeb/CSS/StyleValues/TreeCountingFunctionStyleValue.h
View file

@ -30,10 +30,10 @@ public:
virtual String to_string(SerializationMode) const override; virtual String to_string(SerializationMode) const override;
size_t resolve(DOM::AbstractElement const&, PropertyComputationDependencies&) const; size_t resolve(DOM::AbstractElement const&) const;
virtual RefPtr<CalculationNode const> resolve_to_calculation_node(CalculationContext const&, CalculationResolutionContext const&, PropertyComputationDependencies*) const override; virtual RefPtr<CalculationNode const> resolve_to_calculation_node(CalculationContext const&, CalculationResolutionContext const&) const override;
virtual ValueComparingNonnullRefPtr<StyleValue const> absolutized(ComputationContext const&, PropertyComputationDependencies&) const override; virtual ValueComparingNonnullRefPtr<StyleValue const> absolutized(ComputationContext const&) const override;
virtual bool equals(StyleValue const& other) const override; virtual bool equals(StyleValue const& other) const override;

2
Libraries/LibWeb/DOM/Element.h
View file

@ -262,6 +262,8 @@ public:
void set_custom_properties(Optional<CSS::PseudoElement>, OrderedHashMap<FlyString, CSS::StyleProperty> custom_properties); void set_custom_properties(Optional<CSS::PseudoElement>, OrderedHashMap<FlyString, CSS::StyleProperty> custom_properties);
[[nodiscard]] OrderedHashMap<FlyString, CSS::StyleProperty> const& custom_properties(Optional<CSS::PseudoElement>) const; [[nodiscard]] OrderedHashMap<FlyString, CSS::StyleProperty> const& custom_properties(Optional<CSS::PseudoElement>) 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; } 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; } 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; } bool style_uses_var_css_function() const { return m_style_uses_var_css_function; }

9
Libraries/LibWeb/HTML/Canvas/CanvasTextDrawingStyles.h
View file

@ -139,11 +139,10 @@ public:
}; };
// FIXME: Should font be recomputed on canvas element style change? // 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);
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);
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);
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);
auto const& computed_font_style = CSS::StyleComputer::compute_font_style(font_style, computation_context, property_computation_dependencies);
return document->style_computer().compute_font_for_style_values( return document->style_computer().compute_font_for_style_values(
font_family, font_family,