mirrors/ladybird
0
0
Fork 0
mirror of https://github.com/LadybirdBrowser/ladybird.git synced 2025-07-28 11:49:44 +00:00
Code Issues Projects Releases Packages Wiki Activity Actions 10

LibWeb/CSS: Make CalculationNodes ref-counted

Browse source 
Calc simplification (which I'm working towards) involves repeatedly
deriving a new calculation tree from an existing one, and in many
cases, either the whole result or a portion of it will be identical to
that of the original. Using RefPtr lets us avoid making unnecessary
copies. As a bonus it will also make it easier to return either `this`
or a new node.

In future we could also cache commonly-used nodes, similar to how we do
so for 1px and 0px LengthStyleValues and various keywords.
This commit is contained in:
Sam Atkins 2025-01-22 16:50:54 +00:00 • committed by Andreas Kling
commit c3d61020e7
Notes: github-actions[bot] 2025-01-30 18:33:46 +00:00
7 changed files with 185 additions and 185 deletions
Download patch file Download diff file Expand all files Collapse all files

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

@ -536,7 +536,7 @@ NonnullRefPtr<CSSStyleValue const> interpolate_value(DOM::Element& element, Calc
} }
}; };
static auto to_calculation_node = [calculation_context](CSSStyleValue const& value) -> NonnullOwnPtr<CalculationNode> { static auto to_calculation_node = [calculation_context](CSSStyleValue const& value) -> NonnullRefPtr<CalculationNode> {
switch (value.type()) { switch (value.type()) {
case CSSStyleValue::Type::Angle: case CSSStyleValue::Type::Angle:
return NumericCalculationNode::create(value.as_angle().angle(), calculation_context); return NumericCalculationNode::create(value.as_angle().angle(), calculation_context);
@ -565,7 +565,7 @@ NonnullRefPtr<CSSStyleValue const> interpolate_value(DOM::Element& element, Calc
auto interpolated_from = interpolate_value(element, calculation_context, from, from_base_type_and_default->default_value, delta); auto interpolated_from = interpolate_value(element, calculation_context, from, from_base_type_and_default->default_value, delta);
auto interpolated_to = interpolate_value(element, calculation_context, to_base_type_and_default->default_value, to, delta); auto interpolated_to = interpolate_value(element, calculation_context, to_base_type_and_default->default_value, to, delta);
Vector<NonnullOwnPtr<CalculationNode>> values; Vector<NonnullRefPtr<CalculationNode>> values;
values.ensure_capacity(2); values.ensure_capacity(2);
values.unchecked_append(to_calculation_node(interpolated_from)); values.unchecked_append(to_calculation_node(interpolated_from));
values.unchecked_append(to_calculation_node(interpolated_to)); values.unchecked_append(to_calculation_node(interpolated_to));

22
Libraries/LibWeb/CSS/Parser/Parser.cpp
View file

@ -1953,7 +1953,7 @@ RefPtr<CalculatedStyleValue> Parser::parse_calculated_value(ComponentValue const
return CalculatedStyleValue::create(function_node.release_nonnull(), function_type.release_value(), context); return CalculatedStyleValue::create(function_node.release_nonnull(), function_type.release_value(), context);
} }
OwnPtr<CalculationNode> Parser::parse_a_calc_function_node(Function const& function, CalculationContext const& context) RefPtr<CalculationNode> Parser::parse_a_calc_function_node(Function const& function, CalculationContext const& context)
{ {
auto context_guard = push_temporary_value_parsing_context(FunctionContext { function.name }); auto context_guard = push_temporary_value_parsing_context(FunctionContext { function.name });
@ -9257,11 +9257,11 @@ LengthOrCalculated Parser::Parser::parse_as_sizes_attribute(DOM::Element const&
return Length(100, Length::Type::Vw); return Length(100, Length::Type::Vw);
} }
OwnPtr<CalculationNode> Parser::convert_to_calculation_node(CalcParsing::Node const& node, CalculationContext const& context) RefPtr<CalculationNode> Parser::convert_to_calculation_node(CalcParsing::Node const& node, CalculationContext const& context)
{ {
return node.visit( return node.visit(
[this, &context](NonnullOwnPtr<CalcParsing::ProductNode> const& product_node) -> OwnPtr<CalculationNode> { [this, &context](NonnullOwnPtr<CalcParsing::ProductNode> const& product_node) -> RefPtr<CalculationNode> {
Vector<NonnullOwnPtr<CalculationNode>> children; Vector<NonnullRefPtr<CalculationNode>> children;
children.ensure_capacity(product_node->children.size()); children.ensure_capacity(product_node->children.size());
for (auto const& child : product_node->children) { for (auto const& child : product_node->children) {
@ -9274,8 +9274,8 @@ OwnPtr<CalculationNode> Parser::convert_to_calculation_node(CalcParsing::Node co
return ProductCalculationNode::create(move(children)); return ProductCalculationNode::create(move(children));
}, },
[this, &context](NonnullOwnPtr<CalcParsing::SumNode> const& sum_node) -> OwnPtr<CalculationNode> { [this, &context](NonnullOwnPtr<CalcParsing::SumNode> const& sum_node) -> RefPtr<CalculationNode> {
Vector<NonnullOwnPtr<CalculationNode>> children; Vector<NonnullRefPtr<CalculationNode>> children;
children.ensure_capacity(sum_node->children.size()); children.ensure_capacity(sum_node->children.size());
for (auto const& child : sum_node->children) { for (auto const& child : sum_node->children) {
@ -9288,17 +9288,17 @@ OwnPtr<CalculationNode> Parser::convert_to_calculation_node(CalcParsing::Node co
return SumCalculationNode::create(move(children)); return SumCalculationNode::create(move(children));
}, },
[this, &context](NonnullOwnPtr<CalcParsing::InvertNode> const& invert_node) -> OwnPtr<CalculationNode> { [this, &context](NonnullOwnPtr<CalcParsing::InvertNode> const& invert_node) -> RefPtr<CalculationNode> {
if (auto child_as_node = convert_to_calculation_node(invert_node->child, context)) if (auto child_as_node = convert_to_calculation_node(invert_node->child, context))
return InvertCalculationNode::create(child_as_node.release_nonnull()); return InvertCalculationNode::create(child_as_node.release_nonnull());
return nullptr; return nullptr;
}, },
[this, &context](NonnullOwnPtr<CalcParsing::NegateNode> const& negate_node) -> OwnPtr<CalculationNode> { [this, &context](NonnullOwnPtr<CalcParsing::NegateNode> const& negate_node) -> RefPtr<CalculationNode> {
if (auto child_as_node = convert_to_calculation_node(negate_node->child, context)) if (auto child_as_node = convert_to_calculation_node(negate_node->child, context))
return NegateCalculationNode::create(child_as_node.release_nonnull()); return NegateCalculationNode::create(child_as_node.release_nonnull());
return nullptr; return nullptr;
}, },
[this, &context](NonnullRawPtr<ComponentValue const> const& component_value) -> OwnPtr<CalculationNode> { [this, &context](NonnullRawPtr<ComponentValue const> const& component_value) -> RefPtr<CalculationNode> {
// NOTE: This is the "process the leaf nodes" part of step 5 of https://drafts.csswg.org/css-values-4/#parse-a-calculation // NOTE: This is the "process the leaf nodes" part of step 5 of https://drafts.csswg.org/css-values-4/#parse-a-calculation
// We divert a little from the spec: Rather than modify an existing tree of values, we construct a new one from that source tree. // We divert a little from the spec: Rather than modify an existing tree of values, we construct a new one from that source tree.
// This lets us make CalculationNodes immutable. // This lets us make CalculationNodes immutable.
@ -9375,14 +9375,14 @@ OwnPtr<CalculationNode> Parser::convert_to_calculation_node(CalcParsing::Node co
dbgln_if(CSS_PARSER_DEBUG, "Leftover ComponentValue in calc tree! That probably means the syntax is invalid, but maybe we just didn't implement `{}` yet.", component_value->to_debug_string()); dbgln_if(CSS_PARSER_DEBUG, "Leftover ComponentValue in calc tree! That probably means the syntax is invalid, but maybe we just didn't implement `{}` yet.", component_value->to_debug_string());
return nullptr; return nullptr;
}, },
[](CalcParsing::Operator const& op) -> OwnPtr<CalculationNode> { [](CalcParsing::Operator const& op) -> RefPtr<CalculationNode> {
dbgln_if(CSS_PARSER_DEBUG, "Leftover Operator {} in calc tree!", op.delim); dbgln_if(CSS_PARSER_DEBUG, "Leftover Operator {} in calc tree!", op.delim);
return nullptr; return nullptr;
}); });
} }
// https://drafts.csswg.org/css-values-4/#parse-a-calculation // https://drafts.csswg.org/css-values-4/#parse-a-calculation
OwnPtr<CalculationNode> Parser::parse_a_calculation(Vector<ComponentValue> const& original_values, CalculationContext const& context) RefPtr<CalculationNode> Parser::parse_a_calculation(Vector<ComponentValue> const& original_values, CalculationContext const& context)
{ {
// 1. Discard any <whitespace-token>s from values. // 1. Discard any <whitespace-token>s from values.
// 2. An item in values is an “operator” if it’s a <delim-token> with the value "+", "-", "*", or "/". Otherwise, it’s a “value”. // 2. An item in values is an “operator” if it’s a <delim-token> with the value "+", "-", "*", or "/". Otherwise, it’s a “value”.

8
Libraries/LibWeb/CSS/Parser/Parser.h
View file

@ -276,8 +276,8 @@ private:
RefPtr<CalculatedStyleValue> parse_calculated_value(ComponentValue const&); RefPtr<CalculatedStyleValue> parse_calculated_value(ComponentValue const&);
RefPtr<CustomIdentStyleValue> parse_custom_ident_value(TokenStream<ComponentValue>&, std::initializer_list<StringView> blacklist); RefPtr<CustomIdentStyleValue> parse_custom_ident_value(TokenStream<ComponentValue>&, std::initializer_list<StringView> blacklist);
// NOTE: Implemented in generated code. (GenerateCSSMathFunctions.cpp) // NOTE: Implemented in generated code. (GenerateCSSMathFunctions.cpp)
OwnPtr<CalculationNode> parse_math_function(Function const&, CalculationContext const&); RefPtr<CalculationNode> parse_math_function(Function const&, CalculationContext const&);
OwnPtr<CalculationNode> parse_a_calc_function_node(Function const&, CalculationContext const&); RefPtr<CalculationNode> parse_a_calc_function_node(Function const&, CalculationContext const&);
RefPtr<CSSStyleValue> parse_keyword_value(TokenStream<ComponentValue>&); RefPtr<CSSStyleValue> parse_keyword_value(TokenStream<ComponentValue>&);
RefPtr<CSSStyleValue> parse_hue_none_value(TokenStream<ComponentValue>&); RefPtr<CSSStyleValue> parse_hue_none_value(TokenStream<ComponentValue>&);
RefPtr<CSSStyleValue> parse_solidus_and_alpha_value(TokenStream<ComponentValue>&); RefPtr<CSSStyleValue> parse_solidus_and_alpha_value(TokenStream<ComponentValue>&);
@ -396,8 +396,8 @@ private:
RefPtr<CSSStyleValue> parse_grid_area_shorthand_value(TokenStream<ComponentValue>&); RefPtr<CSSStyleValue> parse_grid_area_shorthand_value(TokenStream<ComponentValue>&);
RefPtr<CSSStyleValue> parse_grid_shorthand_value(TokenStream<ComponentValue>&); RefPtr<CSSStyleValue> parse_grid_shorthand_value(TokenStream<ComponentValue>&);
OwnPtr<CalculationNode> convert_to_calculation_node(CalcParsing::Node const&, CalculationContext const&); RefPtr<CalculationNode> convert_to_calculation_node(CalcParsing::Node const&, CalculationContext const&);
OwnPtr<CalculationNode> parse_a_calculation(Vector<ComponentValue> const&, CalculationContext const&); RefPtr<CalculationNode> parse_a_calculation(Vector<ComponentValue> const&, CalculationContext const&);
ParseErrorOr<NonnullRefPtr<Selector>> parse_complex_selector(TokenStream<ComponentValue>&, SelectorType); ParseErrorOr<NonnullRefPtr<Selector>> parse_complex_selector(TokenStream<ComponentValue>&, SelectorType);
ParseErrorOr<Optional<Selector::CompoundSelector>> parse_compound_selector(TokenStream<ComponentValue>&); ParseErrorOr<Optional<Selector::CompoundSelector>> parse_compound_selector(TokenStream<ComponentValue>&);

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

@ -13,7 +13,7 @@
namespace Web::CSS { namespace Web::CSS {
static Optional<CSSNumericType> add_the_types(Vector<NonnullOwnPtr<CalculationNode>> const& nodes) static Optional<CSSNumericType> add_the_types(Vector<NonnullRefPtr<CalculationNode>> const& nodes)
{ {
Optional<CSSNumericType> left_type; Optional<CSSNumericType> left_type;
for (auto const& value : nodes) { for (auto const& value : nodes) {
@ -58,7 +58,7 @@ static Optional<CSSNumericType> add_the_types(CalculationNode const& a, Calculat
return a_and_b_type->added_to(*c_type); return a_and_b_type->added_to(*c_type);
} }
static Optional<CSSNumericType> multiply_the_types(Vector<NonnullOwnPtr<CalculationNode>> const& nodes) static Optional<CSSNumericType> multiply_the_types(Vector<NonnullRefPtr<CalculationNode>> const& nodes)
{ {
// At a * sub-expression, multiply the types of the left and right arguments. // At a * sub-expression, multiply the types of the left and right arguments.
// The sub-expression’s type is the returned result. // The sub-expression’s type is the returned result.
@ -174,10 +174,10 @@ static CSSNumericType numeric_type_from_calculated_style_value(CalculatedStyleVa
}); });
} }
NonnullOwnPtr<NumericCalculationNode> NumericCalculationNode::create(NumericValue value, CalculationContext const& context) NonnullRefPtr<NumericCalculationNode> NumericCalculationNode::create(NumericValue value, CalculationContext const& context)
{ {
auto numeric_type = numeric_type_from_calculated_style_value(value, context); auto numeric_type = numeric_type_from_calculated_style_value(value, context);
return adopt_own(*new (nothrow) NumericCalculationNode(move(value), numeric_type)); return adopt_ref(*new (nothrow) NumericCalculationNode(move(value), numeric_type));
} }
NumericCalculationNode::NumericCalculationNode(NumericValue value, CSSNumericType numeric_type) NumericCalculationNode::NumericCalculationNode(NumericValue value, CSSNumericType numeric_type)
@ -231,17 +231,17 @@ bool NumericCalculationNode::equals(CalculationNode const& other) const
return m_value == static_cast<NumericCalculationNode const&>(other).m_value; return m_value == static_cast<NumericCalculationNode const&>(other).m_value;
} }
NonnullOwnPtr<SumCalculationNode> SumCalculationNode::create(Vector<NonnullOwnPtr<CalculationNode>> values) NonnullRefPtr<SumCalculationNode> SumCalculationNode::create(Vector<NonnullRefPtr<CalculationNode>> values)
{ {
// https://www.w3.org/TR/css-values-4/#determine-the-type-of-a-calculation // https://www.w3.org/TR/css-values-4/#determine-the-type-of-a-calculation
// At a + or - sub-expression, attempt to add the types of the left and right arguments. // At a + or - sub-expression, attempt to add the types of the left and right arguments.
// If this returns failure, the entire calculation’s type is failure. // If this returns failure, the entire calculation’s type is failure.
// Otherwise, the sub-expression’s type is the returned type. // Otherwise, the sub-expression’s type is the returned type.
auto numeric_type = add_the_types(values); auto numeric_type = add_the_types(values);
return adopt_own(*new (nothrow) SumCalculationNode(move(values), move(numeric_type))); return adopt_ref(*new (nothrow) SumCalculationNode(move(values), move(numeric_type)));
} }
SumCalculationNode::SumCalculationNode(Vector<NonnullOwnPtr<CalculationNode>> values, Optional<CSSNumericType> numeric_type) SumCalculationNode::SumCalculationNode(Vector<NonnullRefPtr<CalculationNode>> values, Optional<CSSNumericType> numeric_type)
: CalculationNode(Type::Sum, move(numeric_type)) : CalculationNode(Type::Sum, move(numeric_type))
, m_values(move(values)) , m_values(move(values))
{ {
@ -310,16 +310,16 @@ bool SumCalculationNode::equals(CalculationNode const& other) const
return true; return true;
} }
NonnullOwnPtr<ProductCalculationNode> ProductCalculationNode::create(Vector<NonnullOwnPtr<CalculationNode>> values) NonnullRefPtr<ProductCalculationNode> ProductCalculationNode::create(Vector<NonnullRefPtr<CalculationNode>> values)
{ {
// https://drafts.csswg.org/css-values-4/#determine-the-type-of-a-calculation // https://drafts.csswg.org/css-values-4/#determine-the-type-of-a-calculation
// At a * sub-expression, multiply the types of the left and right arguments. // At a * sub-expression, multiply the types of the left and right arguments.
// The sub-expression’s type is the returned result. // The sub-expression’s type is the returned result.
auto numeric_type = multiply_the_types(values); auto numeric_type = multiply_the_types(values);
return adopt_own(*new (nothrow) ProductCalculationNode(move(values), move(numeric_type))); return adopt_ref(*new (nothrow) ProductCalculationNode(move(values), move(numeric_type)));
} }
ProductCalculationNode::ProductCalculationNode(Vector<NonnullOwnPtr<CalculationNode>> values, Optional<CSSNumericType> numeric_type) ProductCalculationNode::ProductCalculationNode(Vector<NonnullRefPtr<CalculationNode>> values, Optional<CSSNumericType> numeric_type)
: CalculationNode(Type::Product, move(numeric_type)) : CalculationNode(Type::Product, move(numeric_type))
, m_values(move(values)) , m_values(move(values))
{ {
@ -388,12 +388,12 @@ bool ProductCalculationNode::equals(CalculationNode const& other) const
return true; return true;
} }
NonnullOwnPtr<NegateCalculationNode> NegateCalculationNode::create(NonnullOwnPtr<CalculationNode> value) NonnullRefPtr<NegateCalculationNode> NegateCalculationNode::create(NonnullRefPtr<CalculationNode> value)
{ {
return adopt_own(*new (nothrow) NegateCalculationNode(move(value))); return adopt_ref(*new (nothrow) NegateCalculationNode(move(value)));
} }
NegateCalculationNode::NegateCalculationNode(NonnullOwnPtr<CalculationNode> value) NegateCalculationNode::NegateCalculationNode(NonnullRefPtr<CalculationNode> value)
// NOTE: `- foo` doesn't change the type // NOTE: `- foo` doesn't change the type
: CalculationNode(Type::Negate, value->numeric_type()) : CalculationNode(Type::Negate, value->numeric_type())
, m_value(move(value)) , m_value(move(value))
@ -434,7 +434,7 @@ bool NegateCalculationNode::equals(CalculationNode const& other) const
return m_value->equals(*static_cast<NegateCalculationNode const&>(other).m_value); return m_value->equals(*static_cast<NegateCalculationNode const&>(other).m_value);
} }
NonnullOwnPtr<InvertCalculationNode> InvertCalculationNode::create(NonnullOwnPtr<CalculationNode> value) NonnullRefPtr<InvertCalculationNode> InvertCalculationNode::create(NonnullRefPtr<CalculationNode> value)
{ {
// https://drafts.csswg.org/css-values-4/#determine-the-type-of-a-calculation // https://drafts.csswg.org/css-values-4/#determine-the-type-of-a-calculation
// At a / sub-expression, let left type be the result of finding the types of its left argument, // At a / sub-expression, let left type be the result of finding the types of its left argument,
@ -443,10 +443,10 @@ NonnullOwnPtr<InvertCalculationNode> InvertCalculationNode::create(NonnullOwnPtr
// NOTE: An InvertCalculationNode only represents the right argument here, and the multiplication // NOTE: An InvertCalculationNode only represents the right argument here, and the multiplication
// is handled in the parent ProductCalculationNode. // is handled in the parent ProductCalculationNode.
auto numeric_type = value->numeric_type().map([](auto& it) { return it.inverted(); }); auto numeric_type = value->numeric_type().map([](auto& it) { return it.inverted(); });
return adopt_own(*new (nothrow) InvertCalculationNode(move(value), move(numeric_type))); return adopt_ref(*new (nothrow) InvertCalculationNode(move(value), move(numeric_type)));
} }
InvertCalculationNode::InvertCalculationNode(NonnullOwnPtr<CalculationNode> value, Optional<CSSNumericType> numeric_type) InvertCalculationNode::InvertCalculationNode(NonnullRefPtr<CalculationNode> value, Optional<CSSNumericType> numeric_type)
: CalculationNode(Type::Invert, move(numeric_type)) : CalculationNode(Type::Invert, move(numeric_type))
, m_value(move(value)) , m_value(move(value))
{ {
@ -486,15 +486,15 @@ bool InvertCalculationNode::equals(CalculationNode const& other) const
return m_value->equals(*static_cast<InvertCalculationNode const&>(other).m_value); return m_value->equals(*static_cast<InvertCalculationNode const&>(other).m_value);
} }
NonnullOwnPtr<MinCalculationNode> MinCalculationNode::create(Vector<NonnullOwnPtr<CalculationNode>> values) NonnullRefPtr<MinCalculationNode> MinCalculationNode::create(Vector<NonnullRefPtr<CalculationNode>> values)
{ {
// https://drafts.csswg.org/css-values-4/#determine-the-type-of-a-calculation // https://drafts.csswg.org/css-values-4/#determine-the-type-of-a-calculation
// The result of adding the types of its comma-separated calculations. // The result of adding the types of its comma-separated calculations.
auto numeric_type = add_the_types(values); auto numeric_type = add_the_types(values);
return adopt_own(*new (nothrow) MinCalculationNode(move(values), move(numeric_type))); return adopt_ref(*new (nothrow) MinCalculationNode(move(values), move(numeric_type)));
} }
MinCalculationNode::MinCalculationNode(Vector<NonnullOwnPtr<CalculationNode>> values, Optional<CSSNumericType> numeric_type) MinCalculationNode::MinCalculationNode(Vector<NonnullRefPtr<CalculationNode>> values, Optional<CSSNumericType> numeric_type)
: CalculationNode(Type::Min, move(numeric_type)) : CalculationNode(Type::Min, move(numeric_type))
, m_values(move(values)) , m_values(move(values))
{ {
@ -565,15 +565,15 @@ bool MinCalculationNode::equals(CalculationNode const& other) const
return true; return true;
} }
NonnullOwnPtr<MaxCalculationNode> MaxCalculationNode::create(Vector<NonnullOwnPtr<CalculationNode>> values) NonnullRefPtr<MaxCalculationNode> MaxCalculationNode::create(Vector<NonnullRefPtr<CalculationNode>> values)
{ {
// https://drafts.csswg.org/css-values-4/#determine-the-type-of-a-calculation // https://drafts.csswg.org/css-values-4/#determine-the-type-of-a-calculation
// The result of adding the types of its comma-separated calculations. // The result of adding the types of its comma-separated calculations.
auto numeric_type = add_the_types(values); auto numeric_type = add_the_types(values);
return adopt_own(*new (nothrow) MaxCalculationNode(move(values), move(numeric_type))); return adopt_ref(*new (nothrow) MaxCalculationNode(move(values), move(numeric_type)));
} }
MaxCalculationNode::MaxCalculationNode(Vector<NonnullOwnPtr<CalculationNode>> values, Optional<CSSNumericType> numeric_type) MaxCalculationNode::MaxCalculationNode(Vector<NonnullRefPtr<CalculationNode>> values, Optional<CSSNumericType> numeric_type)
: CalculationNode(Type::Max, move(numeric_type)) : CalculationNode(Type::Max, move(numeric_type))
, m_values(move(values)) , m_values(move(values))
{ {
@ -644,15 +644,15 @@ bool MaxCalculationNode::equals(CalculationNode const& other) const
return true; return true;
} }
NonnullOwnPtr<ClampCalculationNode> ClampCalculationNode::create(NonnullOwnPtr<CalculationNode> min, NonnullOwnPtr<CalculationNode> center, NonnullOwnPtr<CalculationNode> max) NonnullRefPtr<ClampCalculationNode> ClampCalculationNode::create(NonnullRefPtr<CalculationNode> min, NonnullRefPtr<CalculationNode> center, NonnullRefPtr<CalculationNode> max)
{ {
// https://drafts.csswg.org/css-values-4/#determine-the-type-of-a-calculation // https://drafts.csswg.org/css-values-4/#determine-the-type-of-a-calculation
// The result of adding the types of its comma-separated calculations. // The result of adding the types of its comma-separated calculations.
auto numeric_type = add_the_types(*min, *center, *max); auto numeric_type = add_the_types(*min, *center, *max);
return adopt_own(*new (nothrow) ClampCalculationNode(move(min), move(center), move(max), move(numeric_type))); return adopt_ref(*new (nothrow) ClampCalculationNode(move(min), move(center), move(max), move(numeric_type)));
} }
ClampCalculationNode::ClampCalculationNode(NonnullOwnPtr<CalculationNode> min, NonnullOwnPtr<CalculationNode> center, NonnullOwnPtr<CalculationNode> max, Optional<CSSNumericType> numeric_type) ClampCalculationNode::ClampCalculationNode(NonnullRefPtr<CalculationNode> min, NonnullRefPtr<CalculationNode> center, NonnullRefPtr<CalculationNode> max, Optional<CSSNumericType> numeric_type)
: CalculationNode(Type::Clamp, move(numeric_type)) : CalculationNode(Type::Clamp, move(numeric_type))
, m_min_value(move(min)) , m_min_value(move(min))
, m_center_value(move(center)) , m_center_value(move(center))
@ -721,12 +721,12 @@ bool ClampCalculationNode::equals(CalculationNode const& other) const
&& m_max_value->equals(*static_cast<ClampCalculationNode const&>(other).m_max_value); && m_max_value->equals(*static_cast<ClampCalculationNode const&>(other).m_max_value);
} }
NonnullOwnPtr<AbsCalculationNode> AbsCalculationNode::create(NonnullOwnPtr<CalculationNode> value) NonnullRefPtr<AbsCalculationNode> AbsCalculationNode::create(NonnullRefPtr<CalculationNode> value)
{ {
return adopt_own(*new (nothrow) AbsCalculationNode(move(value))); return adopt_ref(*new (nothrow) AbsCalculationNode(move(value)));
} }
AbsCalculationNode::AbsCalculationNode(NonnullOwnPtr<CalculationNode> value) AbsCalculationNode::AbsCalculationNode(NonnullRefPtr<CalculationNode> value)
// https://www.w3.org/TR/css-values-4/#determine-the-type-of-a-calculation // https://www.w3.org/TR/css-values-4/#determine-the-type-of-a-calculation
// The type of its contained calculation. // The type of its contained calculation.
: CalculationNode(Type::Abs, value->numeric_type()) : CalculationNode(Type::Abs, value->numeric_type())
@ -772,12 +772,12 @@ bool AbsCalculationNode::equals(CalculationNode const& other) const
return m_value->equals(*static_cast<AbsCalculationNode const&>(other).m_value); return m_value->equals(*static_cast<AbsCalculationNode const&>(other).m_value);
} }
NonnullOwnPtr<SignCalculationNode> SignCalculationNode::create(NonnullOwnPtr<CalculationNode> value) NonnullRefPtr<SignCalculationNode> SignCalculationNode::create(NonnullRefPtr<CalculationNode> value)
{ {
return adopt_own(*new (nothrow) SignCalculationNode(move(value))); return adopt_ref(*new (nothrow) SignCalculationNode(move(value)));
} }
SignCalculationNode::SignCalculationNode(NonnullOwnPtr<CalculationNode> value) SignCalculationNode::SignCalculationNode(NonnullRefPtr<CalculationNode> value)
// https://www.w3.org/TR/css-values-4/#determine-the-type-of-a-calculation // https://www.w3.org/TR/css-values-4/#determine-the-type-of-a-calculation
// «[ ]» (empty map). // «[ ]» (empty map).
: CalculationNode(Type::Sign, CSSNumericType {}) : CalculationNode(Type::Sign, CSSNumericType {})
@ -829,9 +829,9 @@ bool SignCalculationNode::equals(CalculationNode const& other) const
return m_value->equals(*static_cast<SignCalculationNode const&>(other).m_value); return m_value->equals(*static_cast<SignCalculationNode const&>(other).m_value);
} }
NonnullOwnPtr<ConstantCalculationNode> ConstantCalculationNode::create(ConstantType constant) NonnullRefPtr<ConstantCalculationNode> ConstantCalculationNode::create(ConstantType constant)
{ {
return adopt_own(*new (nothrow) ConstantCalculationNode(constant)); return adopt_ref(*new (nothrow) ConstantCalculationNode(constant));
} }
ConstantCalculationNode::ConstantCalculationNode(ConstantType constant) ConstantCalculationNode::ConstantCalculationNode(ConstantType constant)
@ -897,12 +897,12 @@ bool ConstantCalculationNode::equals(CalculationNode const& other) const
return m_constant == static_cast<ConstantCalculationNode const&>(other).m_constant; return m_constant == static_cast<ConstantCalculationNode const&>(other).m_constant;
} }
NonnullOwnPtr<SinCalculationNode> SinCalculationNode::create(NonnullOwnPtr<CalculationNode> value) NonnullRefPtr<SinCalculationNode> SinCalculationNode::create(NonnullRefPtr<CalculationNode> value)
{ {
return adopt_own(*new (nothrow) SinCalculationNode(move(value))); return adopt_ref(*new (nothrow) SinCalculationNode(move(value)));
} }
SinCalculationNode::SinCalculationNode(NonnullOwnPtr<CalculationNode> value) SinCalculationNode::SinCalculationNode(NonnullRefPtr<CalculationNode> value)
// «[ ]» (empty map). // «[ ]» (empty map).
: CalculationNode(Type::Sin, CSSNumericType {}) : CalculationNode(Type::Sin, CSSNumericType {})
, m_value(move(value)) , m_value(move(value))
@ -948,12 +948,12 @@ bool SinCalculationNode::equals(CalculationNode const& other) const
return m_value->equals(*static_cast<SinCalculationNode const&>(other).m_value); return m_value->equals(*static_cast<SinCalculationNode const&>(other).m_value);
} }
NonnullOwnPtr<CosCalculationNode> CosCalculationNode::create(NonnullOwnPtr<CalculationNode> value) NonnullRefPtr<CosCalculationNode> CosCalculationNode::create(NonnullRefPtr<CalculationNode> value)
{ {
return adopt_own(*new (nothrow) CosCalculationNode(move(value))); return adopt_ref(*new (nothrow) CosCalculationNode(move(value)));
} }
CosCalculationNode::CosCalculationNode(NonnullOwnPtr<CalculationNode> value) CosCalculationNode::CosCalculationNode(NonnullRefPtr<CalculationNode> value)
// https://www.w3.org/TR/css-values-4/#determine-the-type-of-a-calculation // https://www.w3.org/TR/css-values-4/#determine-the-type-of-a-calculation
// «[ ]» (empty map). // «[ ]» (empty map).
: CalculationNode(Type::Cos, CSSNumericType {}) : CalculationNode(Type::Cos, CSSNumericType {})
@ -1000,12 +1000,12 @@ bool CosCalculationNode::equals(CalculationNode const& other) const
return m_value->equals(*static_cast<CosCalculationNode const&>(other).m_value); return m_value->equals(*static_cast<CosCalculationNode const&>(other).m_value);
} }
NonnullOwnPtr<TanCalculationNode> TanCalculationNode::create(NonnullOwnPtr<CalculationNode> value) NonnullRefPtr<TanCalculationNode> TanCalculationNode::create(NonnullRefPtr<CalculationNode> value)
{ {
return adopt_own(*new (nothrow) TanCalculationNode(move(value))); return adopt_ref(*new (nothrow) TanCalculationNode(move(value)));
} }
TanCalculationNode::TanCalculationNode(NonnullOwnPtr<CalculationNode> value) TanCalculationNode::TanCalculationNode(NonnullRefPtr<CalculationNode> value)
// https://www.w3.org/TR/css-values-4/#determine-the-type-of-a-calculation // https://www.w3.org/TR/css-values-4/#determine-the-type-of-a-calculation
// «[ ]» (empty map). // «[ ]» (empty map).
: CalculationNode(Type::Tan, CSSNumericType {}) : CalculationNode(Type::Tan, CSSNumericType {})
@ -1052,12 +1052,12 @@ bool TanCalculationNode::equals(CalculationNode const& other) const
return m_value->equals(*static_cast<TanCalculationNode const&>(other).m_value); return m_value->equals(*static_cast<TanCalculationNode const&>(other).m_value);
} }
NonnullOwnPtr<AsinCalculationNode> AsinCalculationNode::create(NonnullOwnPtr<CalculationNode> value) NonnullRefPtr<AsinCalculationNode> AsinCalculationNode::create(NonnullRefPtr<CalculationNode> value)
{ {
return adopt_own(*new (nothrow) AsinCalculationNode(move(value))); return adopt_ref(*new (nothrow) AsinCalculationNode(move(value)));
} }
AsinCalculationNode::AsinCalculationNode(NonnullOwnPtr<CalculationNode> value) AsinCalculationNode::AsinCalculationNode(NonnullRefPtr<CalculationNode> value)
// https://www.w3.org/TR/css-values-4/#determine-the-type-of-a-calculation // https://www.w3.org/TR/css-values-4/#determine-the-type-of-a-calculation
// «[ "angle" → 1 ]». // «[ "angle" → 1 ]».
: CalculationNode(Type::Asin, CSSNumericType { CSSNumericType::BaseType::Angle, 1 }) : CalculationNode(Type::Asin, CSSNumericType { CSSNumericType::BaseType::Angle, 1 })
@ -1102,12 +1102,12 @@ bool AsinCalculationNode::equals(CalculationNode const& other) const
return m_value->equals(*static_cast<AsinCalculationNode const&>(other).m_value); return m_value->equals(*static_cast<AsinCalculationNode const&>(other).m_value);
} }
NonnullOwnPtr<AcosCalculationNode> AcosCalculationNode::create(NonnullOwnPtr<CalculationNode> value) NonnullRefPtr<AcosCalculationNode> AcosCalculationNode::create(NonnullRefPtr<CalculationNode> value)
{ {
return adopt_own(*new (nothrow) AcosCalculationNode(move(value))); return adopt_ref(*new (nothrow) AcosCalculationNode(move(value)));
} }
AcosCalculationNode::AcosCalculationNode(NonnullOwnPtr<CalculationNode> value) AcosCalculationNode::AcosCalculationNode(NonnullRefPtr<CalculationNode> value)
// https://www.w3.org/TR/css-values-4/#determine-the-type-of-a-calculation // https://www.w3.org/TR/css-values-4/#determine-the-type-of-a-calculation
// «[ "angle" → 1 ]». // «[ "angle" → 1 ]».
: CalculationNode(Type::Acos, CSSNumericType { CSSNumericType::BaseType::Angle, 1 }) : CalculationNode(Type::Acos, CSSNumericType { CSSNumericType::BaseType::Angle, 1 })
@ -1152,12 +1152,12 @@ bool AcosCalculationNode::equals(CalculationNode const& other) const
return m_value->equals(*static_cast<AcosCalculationNode const&>(other).m_value); return m_value->equals(*static_cast<AcosCalculationNode const&>(other).m_value);
} }
NonnullOwnPtr<AtanCalculationNode> AtanCalculationNode::create(NonnullOwnPtr<CalculationNode> value) NonnullRefPtr<AtanCalculationNode> AtanCalculationNode::create(NonnullRefPtr<CalculationNode> value)
{ {
return adopt_own(*new (nothrow) AtanCalculationNode(move(value))); return adopt_ref(*new (nothrow) AtanCalculationNode(move(value)));
} }
AtanCalculationNode::AtanCalculationNode(NonnullOwnPtr<CalculationNode> value) AtanCalculationNode::AtanCalculationNode(NonnullRefPtr<CalculationNode> value)
// https://www.w3.org/TR/css-values-4/#determine-the-type-of-a-calculation // https://www.w3.org/TR/css-values-4/#determine-the-type-of-a-calculation
// «[ "angle" → 1 ]». // «[ "angle" → 1 ]».
: CalculationNode(Type::Atan, CSSNumericType { CSSNumericType::BaseType::Angle, 1 }) : CalculationNode(Type::Atan, CSSNumericType { CSSNumericType::BaseType::Angle, 1 })
@ -1202,12 +1202,12 @@ bool AtanCalculationNode::equals(CalculationNode const& other) const
return m_value->equals(*static_cast<AtanCalculationNode const&>(other).m_value); return m_value->equals(*static_cast<AtanCalculationNode const&>(other).m_value);
} }
NonnullOwnPtr<Atan2CalculationNode> Atan2CalculationNode::create(NonnullOwnPtr<CalculationNode> y, NonnullOwnPtr<CalculationNode> x) NonnullRefPtr<Atan2CalculationNode> Atan2CalculationNode::create(NonnullRefPtr<CalculationNode> y, NonnullRefPtr<CalculationNode> x)
{ {
return adopt_own(*new (nothrow) Atan2CalculationNode(move(y), move(x))); return adopt_ref(*new (nothrow) Atan2CalculationNode(move(y), move(x)));
} }
Atan2CalculationNode::Atan2CalculationNode(NonnullOwnPtr<CalculationNode> y, NonnullOwnPtr<CalculationNode> x) Atan2CalculationNode::Atan2CalculationNode(NonnullRefPtr<CalculationNode> y, NonnullRefPtr<CalculationNode> x)
// https://www.w3.org/TR/css-values-4/#determine-the-type-of-a-calculation // https://www.w3.org/TR/css-values-4/#determine-the-type-of-a-calculation
// «[ "angle" → 1 ]». // «[ "angle" → 1 ]».
: CalculationNode(Type::Atan2, CSSNumericType { CSSNumericType::BaseType::Angle, 1 }) : CalculationNode(Type::Atan2, CSSNumericType { CSSNumericType::BaseType::Angle, 1 })
@ -1257,12 +1257,12 @@ bool Atan2CalculationNode::equals(CalculationNode const& other) const
&& m_y->equals(*static_cast<Atan2CalculationNode const&>(other).m_y); && m_y->equals(*static_cast<Atan2CalculationNode const&>(other).m_y);
} }
NonnullOwnPtr<PowCalculationNode> PowCalculationNode::create(NonnullOwnPtr<CalculationNode> x, NonnullOwnPtr<CalculationNode> y) NonnullRefPtr<PowCalculationNode> PowCalculationNode::create(NonnullRefPtr<CalculationNode> x, NonnullRefPtr<CalculationNode> y)
{ {
return adopt_own(*new (nothrow) PowCalculationNode(move(x), move(y))); return adopt_ref(*new (nothrow) PowCalculationNode(move(x), move(y)));
} }
PowCalculationNode::PowCalculationNode(NonnullOwnPtr<CalculationNode> x, NonnullOwnPtr<CalculationNode> y) PowCalculationNode::PowCalculationNode(NonnullRefPtr<CalculationNode> x, NonnullRefPtr<CalculationNode> y)
// https://www.w3.org/TR/css-values-4/#determine-the-type-of-a-calculation // https://www.w3.org/TR/css-values-4/#determine-the-type-of-a-calculation
// «[ ]» (empty map). // «[ ]» (empty map).
: CalculationNode(Type::Pow, CSSNumericType {}) : CalculationNode(Type::Pow, CSSNumericType {})
@ -1307,12 +1307,12 @@ bool PowCalculationNode::equals(CalculationNode const& other) const
&& m_y->equals(*static_cast<PowCalculationNode const&>(other).m_y); && m_y->equals(*static_cast<PowCalculationNode const&>(other).m_y);
} }
NonnullOwnPtr<SqrtCalculationNode> SqrtCalculationNode::create(NonnullOwnPtr<CalculationNode> value) NonnullRefPtr<SqrtCalculationNode> SqrtCalculationNode::create(NonnullRefPtr<CalculationNode> value)
{ {
return adopt_own(*new (nothrow) SqrtCalculationNode(move(value))); return adopt_ref(*new (nothrow) SqrtCalculationNode(move(value)));
} }
SqrtCalculationNode::SqrtCalculationNode(NonnullOwnPtr<CalculationNode> value) SqrtCalculationNode::SqrtCalculationNode(NonnullRefPtr<CalculationNode> value)
// https://www.w3.org/TR/css-values-4/#determine-the-type-of-a-calculation // https://www.w3.org/TR/css-values-4/#determine-the-type-of-a-calculation
// «[ ]» (empty map). // «[ ]» (empty map).
: CalculationNode(Type::Sqrt, CSSNumericType {}) : CalculationNode(Type::Sqrt, CSSNumericType {})
@ -1352,15 +1352,15 @@ bool SqrtCalculationNode::equals(CalculationNode const& other) const
return m_value->equals(*static_cast<SqrtCalculationNode const&>(other).m_value); return m_value->equals(*static_cast<SqrtCalculationNode const&>(other).m_value);
} }
NonnullOwnPtr<HypotCalculationNode> HypotCalculationNode::create(Vector<NonnullOwnPtr<CalculationNode>> values) NonnullRefPtr<HypotCalculationNode> HypotCalculationNode::create(Vector<NonnullRefPtr<CalculationNode>> values)
{ {
// https://drafts.csswg.org/css-values-4/#determine-the-type-of-a-calculation // https://drafts.csswg.org/css-values-4/#determine-the-type-of-a-calculation
// The result of adding the types of its comma-separated calculations. // The result of adding the types of its comma-separated calculations.
auto numeric_type = add_the_types(values); auto numeric_type = add_the_types(values);
return adopt_own(*new (nothrow) HypotCalculationNode(move(values), move(numeric_type))); return adopt_ref(*new (nothrow) HypotCalculationNode(move(values), move(numeric_type)));
} }
HypotCalculationNode::HypotCalculationNode(Vector<NonnullOwnPtr<CalculationNode>> values, Optional<CSSNumericType> numeric_type) HypotCalculationNode::HypotCalculationNode(Vector<NonnullRefPtr<CalculationNode>> values, Optional<CSSNumericType> numeric_type)
: CalculationNode(Type::Hypot, move(numeric_type)) : CalculationNode(Type::Hypot, move(numeric_type))
, m_values(move(values)) , m_values(move(values))
{ {
@ -1432,12 +1432,12 @@ bool HypotCalculationNode::equals(CalculationNode const& other) const
return true; return true;
} }
NonnullOwnPtr<LogCalculationNode> LogCalculationNode::create(NonnullOwnPtr<CalculationNode> x, NonnullOwnPtr<CalculationNode> y) NonnullRefPtr<LogCalculationNode> LogCalculationNode::create(NonnullRefPtr<CalculationNode> x, NonnullRefPtr<CalculationNode> y)
{ {
return adopt_own(*new (nothrow) LogCalculationNode(move(x), move(y))); return adopt_ref(*new (nothrow) LogCalculationNode(move(x), move(y)));
} }
LogCalculationNode::LogCalculationNode(NonnullOwnPtr<CalculationNode> x, NonnullOwnPtr<CalculationNode> y) LogCalculationNode::LogCalculationNode(NonnullRefPtr<CalculationNode> x, NonnullRefPtr<CalculationNode> y)
// https://www.w3.org/TR/css-values-4/#determine-the-type-of-a-calculation // https://www.w3.org/TR/css-values-4/#determine-the-type-of-a-calculation
// «[ ]» (empty map). // «[ ]» (empty map).
: CalculationNode(Type::Log, CSSNumericType {}) : CalculationNode(Type::Log, CSSNumericType {})
@ -1482,12 +1482,12 @@ bool LogCalculationNode::equals(CalculationNode const& other) const
&& m_y->equals(*static_cast<LogCalculationNode const&>(other).m_y); && m_y->equals(*static_cast<LogCalculationNode const&>(other).m_y);
} }
NonnullOwnPtr<ExpCalculationNode> ExpCalculationNode::create(NonnullOwnPtr<CalculationNode> value) NonnullRefPtr<ExpCalculationNode> ExpCalculationNode::create(NonnullRefPtr<CalculationNode> value)
{ {
return adopt_own(*new (nothrow) ExpCalculationNode(move(value))); return adopt_ref(*new (nothrow) ExpCalculationNode(move(value)));
} }
ExpCalculationNode::ExpCalculationNode(NonnullOwnPtr<CalculationNode> value) ExpCalculationNode::ExpCalculationNode(NonnullRefPtr<CalculationNode> value)
// https://www.w3.org/TR/css-values-4/#determine-the-type-of-a-calculation // https://www.w3.org/TR/css-values-4/#determine-the-type-of-a-calculation
// «[ ]» (empty map). // «[ ]» (empty map).
: CalculationNode(Type::Exp, CSSNumericType {}) : CalculationNode(Type::Exp, CSSNumericType {})
@ -1527,15 +1527,15 @@ bool ExpCalculationNode::equals(CalculationNode const& other) const
return m_value->equals(*static_cast<ExpCalculationNode const&>(other).m_value); return m_value->equals(*static_cast<ExpCalculationNode const&>(other).m_value);
} }
NonnullOwnPtr<RoundCalculationNode> RoundCalculationNode::create(RoundingStrategy strategy, NonnullOwnPtr<CalculationNode> x, NonnullOwnPtr<CalculationNode> y) NonnullRefPtr<RoundCalculationNode> RoundCalculationNode::create(RoundingStrategy strategy, NonnullRefPtr<CalculationNode> x, NonnullRefPtr<CalculationNode> y)
{ {
// https://www.w3.org/TR/css-values-4/#determine-the-type-of-a-calculation // https://www.w3.org/TR/css-values-4/#determine-the-type-of-a-calculation
// The result of adding the types of its comma-separated calculations. // The result of adding the types of its comma-separated calculations.
auto numeric_type = add_the_types(*x, *y); auto numeric_type = add_the_types(*x, *y);
return adopt_own(*new (nothrow) RoundCalculationNode(strategy, move(x), move(y), move(numeric_type))); return adopt_ref(*new (nothrow) RoundCalculationNode(strategy, move(x), move(y), move(numeric_type)));
} }
RoundCalculationNode::RoundCalculationNode(RoundingStrategy mode, NonnullOwnPtr<CalculationNode> x, NonnullOwnPtr<CalculationNode> y, Optional<CSSNumericType> numeric_type) RoundCalculationNode::RoundCalculationNode(RoundingStrategy mode, NonnullRefPtr<CalculationNode> x, NonnullRefPtr<CalculationNode> y, Optional<CSSNumericType> numeric_type)
: CalculationNode(Type::Round, move(numeric_type)) : CalculationNode(Type::Round, move(numeric_type))
, m_strategy(mode) , m_strategy(mode)
, m_x(move(x)) , m_x(move(x))
@ -1617,15 +1617,15 @@ bool RoundCalculationNode::equals(CalculationNode const& other) const
&& m_y->equals(*static_cast<RoundCalculationNode const&>(other).m_y); && m_y->equals(*static_cast<RoundCalculationNode const&>(other).m_y);
} }
NonnullOwnPtr<ModCalculationNode> ModCalculationNode::create(NonnullOwnPtr<CalculationNode> x, NonnullOwnPtr<CalculationNode> y) NonnullRefPtr<ModCalculationNode> ModCalculationNode::create(NonnullRefPtr<CalculationNode> x, NonnullRefPtr<CalculationNode> y)
{ {
// https://www.w3.org/TR/css-values-4/#determine-the-type-of-a-calculation // https://www.w3.org/TR/css-values-4/#determine-the-type-of-a-calculation
// The result of adding the types of its comma-separated calculations. // The result of adding the types of its comma-separated calculations.
auto numeric_type = add_the_types(*x, *y); auto numeric_type = add_the_types(*x, *y);
return adopt_own(*new (nothrow) ModCalculationNode(move(x), move(y), move(numeric_type))); return adopt_ref(*new (nothrow) ModCalculationNode(move(x), move(y), move(numeric_type)));
} }
ModCalculationNode::ModCalculationNode(NonnullOwnPtr<CalculationNode> x, NonnullOwnPtr<CalculationNode> y, Optional<CSSNumericType> numeric_type) ModCalculationNode::ModCalculationNode(NonnullRefPtr<CalculationNode> x, NonnullRefPtr<CalculationNode> y, Optional<CSSNumericType> numeric_type)
: CalculationNode(Type::Mod, move(numeric_type)) : CalculationNode(Type::Mod, move(numeric_type))
, m_x(move(x)) , m_x(move(x))
, m_y(move(y)) , m_y(move(y))
@ -1678,15 +1678,15 @@ bool ModCalculationNode::equals(CalculationNode const& other) const
&& m_y->equals(*static_cast<ModCalculationNode const&>(other).m_y); && m_y->equals(*static_cast<ModCalculationNode const&>(other).m_y);
} }
NonnullOwnPtr<RemCalculationNode> RemCalculationNode::create(NonnullOwnPtr<CalculationNode> x, NonnullOwnPtr<CalculationNode> y) NonnullRefPtr<RemCalculationNode> RemCalculationNode::create(NonnullRefPtr<CalculationNode> x, NonnullRefPtr<CalculationNode> y)
{ {
// https://www.w3.org/TR/css-values-4/#determine-the-type-of-a-calculation // https://www.w3.org/TR/css-values-4/#determine-the-type-of-a-calculation
// The result of adding the types of its comma-separated calculations. // The result of adding the types of its comma-separated calculations.
auto numeric_type = add_the_types(*x, *y); auto numeric_type = add_the_types(*x, *y);
return adopt_own(*new (nothrow) RemCalculationNode(move(x), move(y), move(numeric_type))); return adopt_ref(*new (nothrow) RemCalculationNode(move(x), move(y), move(numeric_type)));
} }
RemCalculationNode::RemCalculationNode(NonnullOwnPtr<CalculationNode> x, NonnullOwnPtr<CalculationNode> y, Optional<CSSNumericType> numeric_type) RemCalculationNode::RemCalculationNode(NonnullRefPtr<CalculationNode> x, NonnullRefPtr<CalculationNode> y, Optional<CSSNumericType> numeric_type)
: CalculationNode(Type::Rem, move(numeric_type)) : CalculationNode(Type::Rem, move(numeric_type))
, m_x(move(x)) , m_x(move(x))
, m_y(move(y)) , m_y(move(y))

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

@ -65,7 +65,7 @@ public:
Optional<CSSNumericType> m_type; Optional<CSSNumericType> m_type;
}; };
static ValueComparingNonnullRefPtr<CalculatedStyleValue> create(NonnullOwnPtr<CalculationNode> calculation, CSSNumericType resolved_type, CalculationContext context) static ValueComparingNonnullRefPtr<CalculatedStyleValue> create(NonnullRefPtr<CalculationNode> calculation, CSSNumericType resolved_type, CalculationContext context)
{ {
return adopt_ref(*new (nothrow) CalculatedStyleValue(move(calculation), move(resolved_type), move(context))); return adopt_ref(*new (nothrow) CalculatedStyleValue(move(calculation), move(resolved_type), move(context)));
} }
@ -109,7 +109,7 @@ public:
String dump() const; String dump() const;
private: private:
explicit CalculatedStyleValue(NonnullOwnPtr<CalculationNode> calculation, CSSNumericType resolved_type, CalculationContext context) explicit CalculatedStyleValue(NonnullRefPtr<CalculationNode> calculation, CSSNumericType resolved_type, CalculationContext context)
: CSSStyleValue(Type::Calculated) : CSSStyleValue(Type::Calculated)
, m_resolved_type(move(resolved_type)) , m_resolved_type(move(resolved_type))
, m_calculation(move(calculation)) , m_calculation(move(calculation))
@ -120,12 +120,12 @@ private:
Optional<ValueType> percentage_resolved_type() const; Optional<ValueType> percentage_resolved_type() const;
CSSNumericType m_resolved_type; CSSNumericType m_resolved_type;
NonnullOwnPtr<CalculationNode> m_calculation; NonnullRefPtr<CalculationNode> m_calculation;
CalculationContext m_context; CalculationContext m_context;
}; };
// https://www.w3.org/TR/css-values-4/#calculation-tree // https://www.w3.org/TR/css-values-4/#calculation-tree
class CalculationNode { class CalculationNode : public RefCounted<CalculationNode> {
public: public:
// https://drafts.csswg.org/css-values-4/#calc-constants // https://drafts.csswg.org/css-values-4/#calc-constants
// https://drafts.csswg.org/css-values-4/#calc-error-constants // https://drafts.csswg.org/css-values-4/#calc-error-constants
@ -255,7 +255,7 @@ private:
class NumericCalculationNode final : public CalculationNode { class NumericCalculationNode final : public CalculationNode {
public: public:
static NonnullOwnPtr<NumericCalculationNode> create(NumericValue, CalculationContext const&); static NonnullRefPtr<NumericCalculationNode> create(NumericValue, CalculationContext const&);
~NumericCalculationNode(); ~NumericCalculationNode();
virtual String to_string() const override; virtual String to_string() const override;
@ -272,7 +272,7 @@ private:
class SumCalculationNode final : public CalculationNode { class SumCalculationNode final : public CalculationNode {
public: public:
static NonnullOwnPtr<SumCalculationNode> create(Vector<NonnullOwnPtr<CalculationNode>>); static NonnullRefPtr<SumCalculationNode> create(Vector<NonnullRefPtr<CalculationNode>>);
~SumCalculationNode(); ~SumCalculationNode();
virtual String to_string() const override; virtual String to_string() const override;
@ -283,13 +283,13 @@ public:
virtual bool equals(CalculationNode const&) const override; virtual bool equals(CalculationNode const&) const override;
private: private:
SumCalculationNode(Vector<NonnullOwnPtr<CalculationNode>>, Optional<CSSNumericType>); SumCalculationNode(Vector<NonnullRefPtr<CalculationNode>>, Optional<CSSNumericType>);
Vector<NonnullOwnPtr<CalculationNode>> m_values; Vector<NonnullRefPtr<CalculationNode>> m_values;
}; };
class ProductCalculationNode final : public CalculationNode { class ProductCalculationNode final : public CalculationNode {
public: public:
static NonnullOwnPtr<ProductCalculationNode> create(Vector<NonnullOwnPtr<CalculationNode>>); static NonnullRefPtr<ProductCalculationNode> create(Vector<NonnullRefPtr<CalculationNode>>);
~ProductCalculationNode(); ~ProductCalculationNode();
virtual String to_string() const override; virtual String to_string() const override;
@ -300,13 +300,13 @@ public:
virtual bool equals(CalculationNode const&) const override; virtual bool equals(CalculationNode const&) const override;
private: private:
ProductCalculationNode(Vector<NonnullOwnPtr<CalculationNode>>, Optional<CSSNumericType>); ProductCalculationNode(Vector<NonnullRefPtr<CalculationNode>>, Optional<CSSNumericType>);
Vector<NonnullOwnPtr<CalculationNode>> m_values; Vector<NonnullRefPtr<CalculationNode>> m_values;
}; };
class NegateCalculationNode final : public CalculationNode { class NegateCalculationNode final : public CalculationNode {
public: public:
static NonnullOwnPtr<NegateCalculationNode> create(NonnullOwnPtr<CalculationNode>); static NonnullRefPtr<NegateCalculationNode> create(NonnullRefPtr<CalculationNode>);
~NegateCalculationNode(); ~NegateCalculationNode();
virtual String to_string() const override; virtual String to_string() const override;
@ -317,13 +317,13 @@ public:
virtual bool equals(CalculationNode const&) const override; virtual bool equals(CalculationNode const&) const override;
private: private:
NegateCalculationNode(NonnullOwnPtr<CalculationNode>); NegateCalculationNode(NonnullRefPtr<CalculationNode>);
NonnullOwnPtr<CalculationNode> m_value; NonnullRefPtr<CalculationNode> m_value;
}; };
class InvertCalculationNode final : public CalculationNode { class InvertCalculationNode final : public CalculationNode {
public: public:
static NonnullOwnPtr<InvertCalculationNode> create(NonnullOwnPtr<CalculationNode>); static NonnullRefPtr<InvertCalculationNode> create(NonnullRefPtr<CalculationNode>);
~InvertCalculationNode(); ~InvertCalculationNode();
virtual String to_string() const override; virtual String to_string() const override;
@ -334,13 +334,13 @@ public:
virtual bool equals(CalculationNode const&) const override; virtual bool equals(CalculationNode const&) const override;
private: private:
InvertCalculationNode(NonnullOwnPtr<CalculationNode>, Optional<CSSNumericType>); InvertCalculationNode(NonnullRefPtr<CalculationNode>, Optional<CSSNumericType>);
NonnullOwnPtr<CalculationNode> m_value; NonnullRefPtr<CalculationNode> m_value;
}; };
class MinCalculationNode final : public CalculationNode { class MinCalculationNode final : public CalculationNode {
public: public:
static NonnullOwnPtr<MinCalculationNode> create(Vector<NonnullOwnPtr<CalculationNode>>); static NonnullRefPtr<MinCalculationNode> create(Vector<NonnullRefPtr<CalculationNode>>);
~MinCalculationNode(); ~MinCalculationNode();
virtual String to_string() const override; virtual String to_string() const override;
@ -351,13 +351,13 @@ public:
virtual bool equals(CalculationNode const&) const override; virtual bool equals(CalculationNode const&) const override;
private: private:
MinCalculationNode(Vector<NonnullOwnPtr<CalculationNode>>, Optional<CSSNumericType>); MinCalculationNode(Vector<NonnullRefPtr<CalculationNode>>, Optional<CSSNumericType>);
Vector<NonnullOwnPtr<CalculationNode>> m_values; Vector<NonnullRefPtr<CalculationNode>> m_values;
}; };
class MaxCalculationNode final : public CalculationNode { class MaxCalculationNode final : public CalculationNode {
public: public:
static NonnullOwnPtr<MaxCalculationNode> create(Vector<NonnullOwnPtr<CalculationNode>>); static NonnullRefPtr<MaxCalculationNode> create(Vector<NonnullRefPtr<CalculationNode>>);
~MaxCalculationNode(); ~MaxCalculationNode();
virtual String to_string() const override; virtual String to_string() const override;
@ -368,13 +368,13 @@ public:
virtual bool equals(CalculationNode const&) const override; virtual bool equals(CalculationNode const&) const override;
private: private:
MaxCalculationNode(Vector<NonnullOwnPtr<CalculationNode>>, Optional<CSSNumericType>); MaxCalculationNode(Vector<NonnullRefPtr<CalculationNode>>, Optional<CSSNumericType>);
Vector<NonnullOwnPtr<CalculationNode>> m_values; Vector<NonnullRefPtr<CalculationNode>> m_values;
}; };
class ClampCalculationNode final : public CalculationNode { class ClampCalculationNode final : public CalculationNode {
public: public:
static NonnullOwnPtr<ClampCalculationNode> create(NonnullOwnPtr<CalculationNode>, NonnullOwnPtr<CalculationNode>, NonnullOwnPtr<CalculationNode>); static NonnullRefPtr<ClampCalculationNode> create(NonnullRefPtr<CalculationNode>, NonnullRefPtr<CalculationNode>, NonnullRefPtr<CalculationNode>);
~ClampCalculationNode(); ~ClampCalculationNode();
virtual String to_string() const override; virtual String to_string() const override;
@ -385,15 +385,15 @@ public:
virtual bool equals(CalculationNode const&) const override; virtual bool equals(CalculationNode const&) const override;
private: private:
ClampCalculationNode(NonnullOwnPtr<CalculationNode>, NonnullOwnPtr<CalculationNode>, NonnullOwnPtr<CalculationNode>, Optional<CSSNumericType>); ClampCalculationNode(NonnullRefPtr<CalculationNode>, NonnullRefPtr<CalculationNode>, NonnullRefPtr<CalculationNode>, Optional<CSSNumericType>);
NonnullOwnPtr<CalculationNode> m_min_value; NonnullRefPtr<CalculationNode> m_min_value;
NonnullOwnPtr<CalculationNode> m_center_value; NonnullRefPtr<CalculationNode> m_center_value;
NonnullOwnPtr<CalculationNode> m_max_value; NonnullRefPtr<CalculationNode> m_max_value;
}; };
class AbsCalculationNode final : public CalculationNode { class AbsCalculationNode final : public CalculationNode {
public: public:
static NonnullOwnPtr<AbsCalculationNode> create(NonnullOwnPtr<CalculationNode>); static NonnullRefPtr<AbsCalculationNode> create(NonnullRefPtr<CalculationNode>);
~AbsCalculationNode(); ~AbsCalculationNode();
virtual String to_string() const override; virtual String to_string() const override;
@ -404,13 +404,13 @@ public:
virtual bool equals(CalculationNode const&) const override; virtual bool equals(CalculationNode const&) const override;
private: private:
AbsCalculationNode(NonnullOwnPtr<CalculationNode>); AbsCalculationNode(NonnullRefPtr<CalculationNode>);
NonnullOwnPtr<CalculationNode> m_value; NonnullRefPtr<CalculationNode> m_value;
}; };
class SignCalculationNode final : public CalculationNode { class SignCalculationNode final : public CalculationNode {
public: public:
static NonnullOwnPtr<SignCalculationNode> create(NonnullOwnPtr<CalculationNode>); static NonnullRefPtr<SignCalculationNode> create(NonnullRefPtr<CalculationNode>);
~SignCalculationNode(); ~SignCalculationNode();
virtual String to_string() const override; virtual String to_string() const override;
@ -421,13 +421,13 @@ public:
virtual bool equals(CalculationNode const&) const override; virtual bool equals(CalculationNode const&) const override;
private: private:
SignCalculationNode(NonnullOwnPtr<CalculationNode>); SignCalculationNode(NonnullRefPtr<CalculationNode>);
NonnullOwnPtr<CalculationNode> m_value; NonnullRefPtr<CalculationNode> m_value;
}; };
class ConstantCalculationNode final : public CalculationNode { class ConstantCalculationNode final : public CalculationNode {
public: public:
static NonnullOwnPtr<ConstantCalculationNode> create(CalculationNode::ConstantType); static NonnullRefPtr<ConstantCalculationNode> create(CalculationNode::ConstantType);
~ConstantCalculationNode(); ~ConstantCalculationNode();
virtual String to_string() const override; virtual String to_string() const override;
@ -444,7 +444,7 @@ private:
class SinCalculationNode final : public CalculationNode { class SinCalculationNode final : public CalculationNode {
public: public:
static NonnullOwnPtr<SinCalculationNode> create(NonnullOwnPtr<CalculationNode>); static NonnullRefPtr<SinCalculationNode> create(NonnullRefPtr<CalculationNode>);
~SinCalculationNode(); ~SinCalculationNode();
virtual String to_string() const override; virtual String to_string() const override;
@ -455,13 +455,13 @@ public:
virtual bool equals(CalculationNode const&) const override; virtual bool equals(CalculationNode const&) const override;
private: private:
SinCalculationNode(NonnullOwnPtr<CalculationNode>); SinCalculationNode(NonnullRefPtr<CalculationNode>);
NonnullOwnPtr<CalculationNode> m_value; NonnullRefPtr<CalculationNode> m_value;
}; };
class CosCalculationNode final : public CalculationNode { class CosCalculationNode final : public CalculationNode {
public: public:
static NonnullOwnPtr<CosCalculationNode> create(NonnullOwnPtr<CalculationNode>); static NonnullRefPtr<CosCalculationNode> create(NonnullRefPtr<CalculationNode>);
~CosCalculationNode(); ~CosCalculationNode();
virtual String to_string() const override; virtual String to_string() const override;
@ -472,13 +472,13 @@ public:
virtual bool equals(CalculationNode const&) const override; virtual bool equals(CalculationNode const&) const override;
private: private:
CosCalculationNode(NonnullOwnPtr<CalculationNode>); CosCalculationNode(NonnullRefPtr<CalculationNode>);
NonnullOwnPtr<CalculationNode> m_value; NonnullRefPtr<CalculationNode> m_value;
}; };
class TanCalculationNode final : public CalculationNode { class TanCalculationNode final : public CalculationNode {
public: public:
static NonnullOwnPtr<TanCalculationNode> create(NonnullOwnPtr<CalculationNode>); static NonnullRefPtr<TanCalculationNode> create(NonnullRefPtr<CalculationNode>);
~TanCalculationNode(); ~TanCalculationNode();
virtual String to_string() const override; virtual String to_string() const override;
@ -489,13 +489,13 @@ public:
virtual bool equals(CalculationNode const&) const override; virtual bool equals(CalculationNode const&) const override;
private: private:
TanCalculationNode(NonnullOwnPtr<CalculationNode>); TanCalculationNode(NonnullRefPtr<CalculationNode>);
NonnullOwnPtr<CalculationNode> m_value; NonnullRefPtr<CalculationNode> m_value;
}; };
class AsinCalculationNode final : public CalculationNode { class AsinCalculationNode final : public CalculationNode {
public: public:
static NonnullOwnPtr<AsinCalculationNode> create(NonnullOwnPtr<CalculationNode>); static NonnullRefPtr<AsinCalculationNode> create(NonnullRefPtr<CalculationNode>);
~AsinCalculationNode(); ~AsinCalculationNode();
virtual String to_string() const override; virtual String to_string() const override;
@ -506,13 +506,13 @@ public:
virtual bool equals(CalculationNode const&) const override; virtual bool equals(CalculationNode const&) const override;
private: private:
AsinCalculationNode(NonnullOwnPtr<CalculationNode>); AsinCalculationNode(NonnullRefPtr<CalculationNode>);
NonnullOwnPtr<CalculationNode> m_value; NonnullRefPtr<CalculationNode> m_value;
}; };
class AcosCalculationNode final : public CalculationNode { class AcosCalculationNode final : public CalculationNode {
public: public:
static NonnullOwnPtr<AcosCalculationNode> create(NonnullOwnPtr<CalculationNode>); static NonnullRefPtr<AcosCalculationNode> create(NonnullRefPtr<CalculationNode>);
~AcosCalculationNode(); ~AcosCalculationNode();
virtual String to_string() const override; virtual String to_string() const override;
@ -523,13 +523,13 @@ public:
virtual bool equals(CalculationNode const&) const override; virtual bool equals(CalculationNode const&) const override;
private: private:
AcosCalculationNode(NonnullOwnPtr<CalculationNode>); AcosCalculationNode(NonnullRefPtr<CalculationNode>);
NonnullOwnPtr<CalculationNode> m_value; NonnullRefPtr<CalculationNode> m_value;
}; };
class AtanCalculationNode final : public CalculationNode { class AtanCalculationNode final : public CalculationNode {
public: public:
static NonnullOwnPtr<AtanCalculationNode> create(NonnullOwnPtr<CalculationNode>); static NonnullRefPtr<AtanCalculationNode> create(NonnullRefPtr<CalculationNode>);
~AtanCalculationNode(); ~AtanCalculationNode();
virtual String to_string() const override; virtual String to_string() const override;
@ -540,13 +540,13 @@ public:
virtual bool equals(CalculationNode const&) const override; virtual bool equals(CalculationNode const&) const override;
private: private:
AtanCalculationNode(NonnullOwnPtr<CalculationNode>); AtanCalculationNode(NonnullRefPtr<CalculationNode>);
NonnullOwnPtr<CalculationNode> m_value; NonnullRefPtr<CalculationNode> m_value;
}; };
class Atan2CalculationNode final : public CalculationNode { class Atan2CalculationNode final : public CalculationNode {
public: public:
static NonnullOwnPtr<Atan2CalculationNode> create(NonnullOwnPtr<CalculationNode>, NonnullOwnPtr<CalculationNode>); static NonnullRefPtr<Atan2CalculationNode> create(NonnullRefPtr<CalculationNode>, NonnullRefPtr<CalculationNode>);
~Atan2CalculationNode(); ~Atan2CalculationNode();
virtual String to_string() const override; virtual String to_string() const override;
@ -557,14 +557,14 @@ public:
virtual bool equals(CalculationNode const&) const override; virtual bool equals(CalculationNode const&) const override;
private: private:
Atan2CalculationNode(NonnullOwnPtr<CalculationNode>, NonnullOwnPtr<CalculationNode>); Atan2CalculationNode(NonnullRefPtr<CalculationNode>, NonnullRefPtr<CalculationNode>);
NonnullOwnPtr<CalculationNode> m_y; NonnullRefPtr<CalculationNode> m_y;
NonnullOwnPtr<CalculationNode> m_x; NonnullRefPtr<CalculationNode> m_x;
}; };
class PowCalculationNode final : public CalculationNode { class PowCalculationNode final : public CalculationNode {
public: public:
static NonnullOwnPtr<PowCalculationNode> create(NonnullOwnPtr<CalculationNode>, NonnullOwnPtr<CalculationNode>); static NonnullRefPtr<PowCalculationNode> create(NonnullRefPtr<CalculationNode>, NonnullRefPtr<CalculationNode>);
~PowCalculationNode(); ~PowCalculationNode();
virtual String to_string() const override; virtual String to_string() const override;
@ -575,14 +575,14 @@ public:
virtual bool equals(CalculationNode const&) const override; virtual bool equals(CalculationNode const&) const override;
private: private:
PowCalculationNode(NonnullOwnPtr<CalculationNode>, NonnullOwnPtr<CalculationNode>); PowCalculationNode(NonnullRefPtr<CalculationNode>, NonnullRefPtr<CalculationNode>);
NonnullOwnPtr<CalculationNode> m_x; NonnullRefPtr<CalculationNode> m_x;
NonnullOwnPtr<CalculationNode> m_y; NonnullRefPtr<CalculationNode> m_y;
}; };
class SqrtCalculationNode final : public CalculationNode { class SqrtCalculationNode final : public CalculationNode {
public: public:
static NonnullOwnPtr<SqrtCalculationNode> create(NonnullOwnPtr<CalculationNode>); static NonnullRefPtr<SqrtCalculationNode> create(NonnullRefPtr<CalculationNode>);
~SqrtCalculationNode(); ~SqrtCalculationNode();
virtual String to_string() const override; virtual String to_string() const override;
@ -593,13 +593,13 @@ public:
virtual bool equals(CalculationNode const&) const override; virtual bool equals(CalculationNode const&) const override;
private: private:
SqrtCalculationNode(NonnullOwnPtr<CalculationNode>); SqrtCalculationNode(NonnullRefPtr<CalculationNode>);
NonnullOwnPtr<CalculationNode> m_value; NonnullRefPtr<CalculationNode> m_value;
}; };
class HypotCalculationNode final : public CalculationNode { class HypotCalculationNode final : public CalculationNode {
public: public:
static NonnullOwnPtr<HypotCalculationNode> create(Vector<NonnullOwnPtr<CalculationNode>>); static NonnullRefPtr<HypotCalculationNode> create(Vector<NonnullRefPtr<CalculationNode>>);
~HypotCalculationNode(); ~HypotCalculationNode();
virtual String to_string() const override; virtual String to_string() const override;
@ -610,13 +610,13 @@ public:
virtual bool equals(CalculationNode const&) const override; virtual bool equals(CalculationNode const&) const override;
private: private:
HypotCalculationNode(Vector<NonnullOwnPtr<CalculationNode>>, Optional<CSSNumericType>); HypotCalculationNode(Vector<NonnullRefPtr<CalculationNode>>, Optional<CSSNumericType>);
Vector<NonnullOwnPtr<CalculationNode>> m_values; Vector<NonnullRefPtr<CalculationNode>> m_values;
}; };
class LogCalculationNode final : public CalculationNode { class LogCalculationNode final : public CalculationNode {
public: public:
static NonnullOwnPtr<LogCalculationNode> create(NonnullOwnPtr<CalculationNode>, NonnullOwnPtr<CalculationNode>); static NonnullRefPtr<LogCalculationNode> create(NonnullRefPtr<CalculationNode>, NonnullRefPtr<CalculationNode>);
~LogCalculationNode(); ~LogCalculationNode();
virtual String to_string() const override; virtual String to_string() const override;
@ -627,14 +627,14 @@ public:
virtual bool equals(CalculationNode const&) const override; virtual bool equals(CalculationNode const&) const override;
private: private:
LogCalculationNode(NonnullOwnPtr<CalculationNode>, NonnullOwnPtr<CalculationNode>); LogCalculationNode(NonnullRefPtr<CalculationNode>, NonnullRefPtr<CalculationNode>);
NonnullOwnPtr<CalculationNode> m_x; NonnullRefPtr<CalculationNode> m_x;
NonnullOwnPtr<CalculationNode> m_y; NonnullRefPtr<CalculationNode> m_y;
}; };
class ExpCalculationNode final : public CalculationNode { class ExpCalculationNode final : public CalculationNode {
public: public:
static NonnullOwnPtr<ExpCalculationNode> create(NonnullOwnPtr<CalculationNode>); static NonnullRefPtr<ExpCalculationNode> create(NonnullRefPtr<CalculationNode>);
~ExpCalculationNode(); ~ExpCalculationNode();
virtual String to_string() const override; virtual String to_string() const override;
@ -645,13 +645,13 @@ public:
virtual bool equals(CalculationNode const&) const override; virtual bool equals(CalculationNode const&) const override;
private: private:
ExpCalculationNode(NonnullOwnPtr<CalculationNode>); ExpCalculationNode(NonnullRefPtr<CalculationNode>);
NonnullOwnPtr<CalculationNode> m_value; NonnullRefPtr<CalculationNode> m_value;
}; };
class RoundCalculationNode final : public CalculationNode { class RoundCalculationNode final : public CalculationNode {
public: public:
static NonnullOwnPtr<RoundCalculationNode> create(RoundingStrategy, NonnullOwnPtr<CalculationNode>, NonnullOwnPtr<CalculationNode>); static NonnullRefPtr<RoundCalculationNode> create(RoundingStrategy, NonnullRefPtr<CalculationNode>, NonnullRefPtr<CalculationNode>);
~RoundCalculationNode(); ~RoundCalculationNode();
virtual String to_string() const override; virtual String to_string() const override;
@ -662,15 +662,15 @@ public:
virtual bool equals(CalculationNode const&) const override; virtual bool equals(CalculationNode const&) const override;
private: private:
RoundCalculationNode(RoundingStrategy, NonnullOwnPtr<CalculationNode>, NonnullOwnPtr<CalculationNode>, Optional<CSSNumericType>); RoundCalculationNode(RoundingStrategy, NonnullRefPtr<CalculationNode>, NonnullRefPtr<CalculationNode>, Optional<CSSNumericType>);
RoundingStrategy m_strategy; RoundingStrategy m_strategy;
NonnullOwnPtr<CalculationNode> m_x; NonnullRefPtr<CalculationNode> m_x;
NonnullOwnPtr<CalculationNode> m_y; NonnullRefPtr<CalculationNode> m_y;
}; };
class ModCalculationNode final : public CalculationNode { class ModCalculationNode final : public CalculationNode {
public: public:
static NonnullOwnPtr<ModCalculationNode> create(NonnullOwnPtr<CalculationNode>, NonnullOwnPtr<CalculationNode>); static NonnullRefPtr<ModCalculationNode> create(NonnullRefPtr<CalculationNode>, NonnullRefPtr<CalculationNode>);
~ModCalculationNode(); ~ModCalculationNode();
virtual String to_string() const override; virtual String to_string() const override;
@ -681,14 +681,14 @@ public:
virtual bool equals(CalculationNode const&) const override; virtual bool equals(CalculationNode const&) const override;
private: private:
ModCalculationNode(NonnullOwnPtr<CalculationNode>, NonnullOwnPtr<CalculationNode>, Optional<CSSNumericType>); ModCalculationNode(NonnullRefPtr<CalculationNode>, NonnullRefPtr<CalculationNode>, Optional<CSSNumericType>);
NonnullOwnPtr<CalculationNode> m_x; NonnullRefPtr<CalculationNode> m_x;
NonnullOwnPtr<CalculationNode> m_y; NonnullRefPtr<CalculationNode> m_y;
}; };
class RemCalculationNode final : public CalculationNode { class RemCalculationNode final : public CalculationNode {
public: public:
static NonnullOwnPtr<RemCalculationNode> create(NonnullOwnPtr<CalculationNode>, NonnullOwnPtr<CalculationNode>); static NonnullRefPtr<RemCalculationNode> create(NonnullRefPtr<CalculationNode>, NonnullRefPtr<CalculationNode>);
~RemCalculationNode(); ~RemCalculationNode();
virtual String to_string() const override; virtual String to_string() const override;
@ -699,9 +699,9 @@ public:
virtual bool equals(CalculationNode const&) const override; virtual bool equals(CalculationNode const&) const override;
private: private:
RemCalculationNode(NonnullOwnPtr<CalculationNode>, NonnullOwnPtr<CalculationNode>, Optional<CSSNumericType>); RemCalculationNode(NonnullRefPtr<CalculationNode>, NonnullRefPtr<CalculationNode>, Optional<CSSNumericType>);
NonnullOwnPtr<CalculationNode> m_x; NonnullRefPtr<CalculationNode> m_x;
NonnullOwnPtr<CalculationNode> m_y; NonnullRefPtr<CalculationNode> m_y;
}; };
} }

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

@ -20,7 +20,7 @@ String EdgeStyleValue::to_string(SerializationMode mode) const
// FIXME: Figure out how to get the proper calculation context here // FIXME: Figure out how to get the proper calculation context here
CalculationContext context = {}; CalculationContext context = {};
Vector<NonnullOwnPtr<CalculationNode>> sum_parts; Vector<NonnullRefPtr<CalculationNode>> sum_parts;
sum_parts.append(NumericCalculationNode::create(Percentage(100), context)); sum_parts.append(NumericCalculationNode::create(Percentage(100), context));
if (offset().is_length()) { if (offset().is_length()) {
sum_parts.append(NegateCalculationNode::create(NumericCalculationNode::create(offset().length(), context))); sum_parts.append(NegateCalculationNode::create(NumericCalculationNode::create(offset().length(), context)));

6
Meta/Lagom/Tools/CodeGenerators/LibWeb/GenerateCSSMathFunctions.cpp
View file

@ -116,7 +116,7 @@ static Optional<RoundingStrategy> parse_rounding_strategy(Vector<ComponentValue>
return keyword_to_rounding_strategy(maybe_keyword.value()); return keyword_to_rounding_strategy(maybe_keyword.value());
} }
OwnPtr<CalculationNode> Parser::parse_math_function(Function const& function, CalculationContext const& context) RefPtr<CalculationNode> Parser::parse_math_function(Function const& function, CalculationContext const& context)
{ {
TokenStream stream { function.value }; TokenStream stream { function.value };
auto arguments = parse_a_comma_separated_list_of_component_values(stream); auto arguments = parse_a_comma_separated_list_of_component_values(stream);
@ -137,7 +137,7 @@ OwnPtr<CalculationNode> Parser::parse_math_function(Function const& function, Ca
// Variadic function // Variadic function
function_generator.append(R"~~~( function_generator.append(R"~~~(
Optional<CSSNumericType> determined_argument_type; Optional<CSSNumericType> determined_argument_type;
Vector<NonnullOwnPtr<CalculationNode>> parsed_arguments; Vector<NonnullRefPtr<CalculationNode>> parsed_arguments;
parsed_arguments.ensure_capacity(arguments.size()); parsed_arguments.ensure_capacity(arguments.size());
for (auto& argument : arguments) { for (auto& argument : arguments) {
@ -243,7 +243,7 @@ OwnPtr<CalculationNode> Parser::parse_math_function(Function const& function, Ca
} else { } else {
// NOTE: This assumes everything not handled above is a calculation node of some kind. // NOTE: This assumes everything not handled above is a calculation node of some kind.
parameter_is_calculation = true; parameter_is_calculation = true;
parameter_generator.set("parameter_type", "OwnPtr<CalculationNode>"_string); parameter_generator.set("parameter_type", "RefPtr<CalculationNode>"_string);
parameter_generator.set("parse_function", "parse_a_calculation(arguments[argument_index], context)"_string); parameter_generator.set("parse_function", "parse_a_calculation(arguments[argument_index], context)"_string);
parameter_generator.set("check_function", " != nullptr"_string); parameter_generator.set("check_function", " != nullptr"_string);
parameter_generator.set("release_function", ".release_nonnull()"_string); parameter_generator.set("release_function", ".release_nonnull()"_string);