From 2038cb3c81ad9cef5b926aeb373786603d1a2eb5 Mon Sep 17 00:00:00 2001 From: Sam Atkins Date: Sat, 19 Aug 2023 15:20:23 +0100 Subject: [PATCH] LibWeb: Make CSS math function parsing infallible --- .../LibWeb/GenerateCSSMathFunctions.cpp | 12 +- .../Libraries/LibWeb/CSS/Parser/Parser.cpp | 75 ++--- Userland/Libraries/LibWeb/CSS/Parser/Parser.h | 4 +- .../CSS/StyleValues/CalculatedStyleValue.cpp | 315 ++++++++---------- .../CSS/StyleValues/CalculatedStyleValue.h | 105 +++--- 5 files changed, 238 insertions(+), 273 deletions(-) diff --git a/Meta/Lagom/Tools/CodeGenerators/LibWeb/GenerateCSSMathFunctions.cpp b/Meta/Lagom/Tools/CodeGenerators/LibWeb/GenerateCSSMathFunctions.cpp index 1ec74baba7..08ba3f82f0 100644 --- a/Meta/Lagom/Tools/CodeGenerators/LibWeb/GenerateCSSMathFunctions.cpp +++ b/Meta/Lagom/Tools/CodeGenerators/LibWeb/GenerateCSSMathFunctions.cpp @@ -144,7 +144,7 @@ static Optional parse_rounding_strategy(Vector return value_id_to_rounding_strategy(maybe_identifier.value()); } -ErrorOr> Parser::parse_math_function(PropertyID property_id, Function const& function) +OwnPtr Parser::parse_math_function(PropertyID property_id, Function const& function) { TokenStream stream { function.values() }; auto arguments = parse_a_comma_separated_list_of_component_values(stream); @@ -163,10 +163,10 @@ ErrorOr> Parser::parse_math_function(PropertyID property TRY(function_generator.try_append(R"~~~( CSSNumericType determined_argument_type; Vector> parsed_arguments; - TRY(parsed_arguments.try_ensure_capacity(arguments.size())); + parsed_arguments.ensure_capacity(arguments.size()); for (auto& argument : arguments) { - auto calculation_node = TRY(parse_a_calculation(argument)); + auto calculation_node = parse_a_calculation(argument); if (!calculation_node) { dbgln_if(CSS_PARSER_DEBUG, "@name:lowercase@() argument #{} is not a valid calculation", parsed_arguments.size()); return nullptr; @@ -200,7 +200,7 @@ ErrorOr> Parser::parse_math_function(PropertyID property } } - TRY(parsed_arguments.try_append(calculation_node.release_nonnull())); + parsed_arguments.append(calculation_node.release_nonnull()); } return @name:titlecase@CalculationNode::create(move(parsed_arguments)); @@ -255,14 +255,14 @@ ErrorOr> Parser::parse_math_function(PropertyID property // NOTE: This assumes everything not handled above is a calculation node of some kind. parameter_is_calculation = true; TRY(parameter_generator.set("parameter_type", "OwnPtr"_string)); - TRY(parameter_generator.set("parse_function", "TRY(parse_a_calculation(arguments[argument_index]))"_string)); + TRY(parameter_generator.set("parse_function", "parse_a_calculation(arguments[argument_index])"_string)); TRY(parameter_generator.set("check_function", " != nullptr"_string)); TRY(parameter_generator.set("release_function", ".release_nonnull()"_string)); // NOTE: We have exactly one default value in the data right now, and it's a ``, // so that's all we handle. if (auto default_value = parameter.get_deprecated_string("default"sv); default_value.has_value()) { - TRY(parameter_generator.set("parameter_default", TRY(String::formatted(" = TRY(ConstantCalculationNode::create(CalculationNode::constant_type_from_string(\"{}\"sv).value()))", TRY(String::from_deprecated_string(default_value.value())))))); + TRY(parameter_generator.set("parameter_default", TRY(String::formatted(" = ConstantCalculationNode::create(CalculationNode::constant_type_from_string(\"{}\"sv).value())", TRY(String::from_deprecated_string(default_value.value())))))); } else { TRY(parameter_generator.set("parameter_default", ""_string)); } diff --git a/Userland/Libraries/LibWeb/CSS/Parser/Parser.cpp b/Userland/Libraries/LibWeb/CSS/Parser/Parser.cpp index 94f318e7a5..d8495e23e2 100644 --- a/Userland/Libraries/LibWeb/CSS/Parser/Parser.cpp +++ b/Userland/Libraries/LibWeb/CSS/Parser/Parser.cpp @@ -1744,9 +1744,9 @@ RefPtr Parser::parse_calculated_value(ComponentValue const OwnPtr Parser::parse_a_calc_function_node(Function const& function) { if (function.name().equals_ignoring_ascii_case("calc"sv)) - return MUST(parse_a_calculation(function.values())); + return parse_a_calculation(function.values()); - if (auto maybe_function = MUST(parse_math_function(m_context.current_property_id(), function)); maybe_function) + if (auto maybe_function = parse_math_function(m_context.current_property_id(), function)) return maybe_function; return nullptr; @@ -6172,9 +6172,9 @@ Parser::PropertyAndValue Parser::parse_css_value_for_properties(ReadonlySpan> create(ComponentValue component_value) + static NonnullOwnPtr create(ComponentValue component_value) { - return adopt_nonnull_own_or_enomem(new (nothrow) UnparsedCalculationNode(move(component_value))); + return adopt_own(*new (nothrow) UnparsedCalculationNode(move(component_value))); } virtual ~UnparsedCalculationNode() = default; @@ -6185,6 +6185,7 @@ public: virtual Optional determine_type(Web::CSS::PropertyID) const override { VERIFY_NOT_REACHED(); } virtual bool contains_percentage() const override { VERIFY_NOT_REACHED(); } virtual CalculatedStyleValue::CalculationResult resolve(Optional, CalculatedStyleValue::PercentageBasis const&) const override { VERIFY_NOT_REACHED(); } + virtual void for_each_child_node(AK::Function&)> const&) override { } virtual ErrorOr dump(StringBuilder& builder, int indent) const override { @@ -6263,7 +6264,7 @@ LengthOrCalculated Parser::Parser::parse_as_sizes_attribute() } // https://www.w3.org/TR/css-values-4/#parse-a-calculation -ErrorOr> Parser::parse_a_calculation(Vector const& original_values) +OwnPtr Parser::parse_a_calculation(Vector const& original_values) { // 1. Discard any s from values. // 2. An item in values is an “operator” if it’s a with the value "+", "-", "*", or "/". Otherwise, it’s a “value”. @@ -6281,7 +6282,7 @@ ErrorOr> Parser::parse_a_calculation(Vector()) return nullptr; - TRY(values.try_append(Operator { static_cast(value.token().delim()) })); + values.append(Operator { static_cast(value.token().delim()) }); continue; } } @@ -6289,34 +6290,34 @@ ErrorOr> Parser::parse_a_calculation(Vectoris_angle()) - TRY(values.try_append({ TRY(NumericCalculationNode::create(dimension->angle())) })); + values.append({ NumericCalculationNode::create(dimension->angle()) }); else if (dimension->is_frequency()) - TRY(values.try_append({ TRY(NumericCalculationNode::create(dimension->frequency())) })); + values.append({ NumericCalculationNode::create(dimension->frequency()) }); else if (dimension->is_length()) - TRY(values.try_append({ TRY(NumericCalculationNode::create(dimension->length())) })); + values.append({ NumericCalculationNode::create(dimension->length()) }); else if (dimension->is_percentage()) - TRY(values.try_append({ TRY(NumericCalculationNode::create(dimension->percentage())) })); + values.append({ NumericCalculationNode::create(dimension->percentage()) }); // FIXME: Resolutions, once calc() supports them. else if (dimension->is_time()) - TRY(values.try_append({ TRY(NumericCalculationNode::create(dimension->time())) })); + values.append({ NumericCalculationNode::create(dimension->time()) }); else VERIFY_NOT_REACHED(); continue; } - TRY(values.try_append({ TRY(UnparsedCalculationNode::create(value)) })); + values.append({ UnparsedCalculationNode::create(value) }); } // If we have no values, the syntax is invalid. @@ -6356,21 +6357,21 @@ ErrorOr> Parser::parse_a_calculation(Vector> run_values; - TRY(run_values.try_append(move(values[start_of_run].get>()))); + run_values.append(move(values[start_of_run].get>())); for (auto i = start_of_run + 1; i <= end_of_run; i += 2) { auto& operator_ = values[i].get().delim; auto& rhs = values[i + 1]; if (operator_ == '/') { - TRY(run_values.try_append(TRY(InvertCalculationNode::create(move(rhs.get>()))))); + run_values.append(InvertCalculationNode::create(move(rhs.get>()))); continue; } VERIFY(operator_ == '*'); - TRY(run_values.try_append(move(rhs.get>()))); + run_values.append(move(rhs.get>())); } // 2. Replace the entire run with a Product node containing the value items of the run as its children. - auto product_node = TRY(ProductCalculationNode::create(move(run_values))); + auto product_node = ProductCalculationNode::create(move(run_values)); values.remove(start_of_run, end_of_run - start_of_run + 1); - TRY(values.try_insert(start_of_run, { move(product_node) })); + values.insert(start_of_run, { move(product_node) }); } // 4. Collect children into Sum and Negate nodes. @@ -6385,59 +6386,57 @@ ErrorOr> Parser::parse_a_calculation(Vector negate_node = TRY(NegateCalculationNode::create(move(rhs.get>()))); + NonnullOwnPtr negate_node = NegateCalculationNode::create(move(rhs.get>())); values.remove(rhs_index); values.insert(rhs_index, move(negate_node)); } // 2. If values has only one item, and it is a Product node or a parenthesized simple block, replace values with that item. if (values.size() == 1) { - TRY(values.first().visit( - [&](ComponentValue& component_value) -> ErrorOr { + values.first().visit( + [&](ComponentValue& component_value) { if (component_value.is_block() && component_value.block().is_paren()) - single_value = TRY(UnparsedCalculationNode::create(component_value)); - return {}; + single_value = UnparsedCalculationNode::create(component_value); }, - [&](NonnullOwnPtr& node) -> ErrorOr { + [&](NonnullOwnPtr& node) { if (node->type() == CalculationNode::Type::Product) single_value = move(node); - return {}; }, - [](auto&) -> ErrorOr { return {}; })); + [](auto&) {}); } // Otherwise, replace values with a Sum node containing the value items of values as its children. if (!single_value.has_value()) { values.remove_all_matching([](Value& value) { return value.has(); }); Vector> value_items; - TRY(value_items.try_ensure_capacity(values.size())); + value_items.ensure_capacity(values.size()); for (auto& value : values) { if (value.has()) continue; value_items.unchecked_append(move(value.get>())); } - single_value = TRY(SumCalculationNode::create(move(value_items))); + single_value = SumCalculationNode::create(move(value_items)); } } // 5. At this point values is a tree of Sum, Product, Negate, and Invert nodes, with other types of values at the leaf nodes. Process the leaf nodes. // For every leaf node leaf in values: bool parsing_failed_for_child_node = false; - TRY(single_value.value()->for_each_child_node([&](NonnullOwnPtr& node) -> ErrorOr { + single_value.value()->for_each_child_node([&](NonnullOwnPtr& node) { if (node->type() != CalculationNode::Type::Unparsed) - return {}; + return; auto& unparsed_node = static_cast(*node); auto& component_value = unparsed_node.component_value(); // 1. If leaf is a parenthesized simple block, replace leaf with the result of parsing a calculation from leaf’s contents. if (component_value.is_block() && component_value.block().is_paren()) { - auto leaf_calculation = TRY(parse_a_calculation(component_value.block().values())); + auto leaf_calculation = parse_a_calculation(component_value.block().values()); if (!leaf_calculation) { parsing_failed_for_child_node = true; - return {}; + return; } node = leaf_calculation.release_nonnull(); - return {}; + return; } // 2. If leaf is a math function, replace leaf with the internal representation of that math function. @@ -6447,19 +6446,19 @@ ErrorOr> Parser::parse_a_calculation(Vector parse_builtin_value(ComponentValue const&); RefPtr parse_calculated_value(ComponentValue const&); // NOTE: Implemented in generated code. (GenerateCSSMathFunctions.cpp) - ErrorOr> parse_math_function(PropertyID, Function const&); + OwnPtr parse_math_function(PropertyID, Function const&); OwnPtr parse_a_calc_function_node(Function const&); RefPtr parse_dimension_value(ComponentValue const&); RefPtr parse_integer_value(TokenStream&); @@ -259,7 +259,7 @@ private: RefPtr parse_grid_area_shorthand_value(Vector const&); RefPtr parse_grid_shorthand_value(Vector const&); - ErrorOr> parse_a_calculation(Vector const&); + OwnPtr parse_a_calculation(Vector const&); ParseErrorOr> parse_complex_selector(TokenStream&, SelectorType); ParseErrorOr> parse_compound_selector(TokenStream&); diff --git a/Userland/Libraries/LibWeb/CSS/StyleValues/CalculatedStyleValue.cpp b/Userland/Libraries/LibWeb/CSS/StyleValues/CalculatedStyleValue.cpp index ae213837cc..7d06dda0e6 100644 --- a/Userland/Libraries/LibWeb/CSS/StyleValues/CalculatedStyleValue.cpp +++ b/Userland/Libraries/LibWeb/CSS/StyleValues/CalculatedStyleValue.cpp @@ -114,9 +114,9 @@ CalculationNode::CalculationNode(Type type) CalculationNode::~CalculationNode() = default; -ErrorOr> NumericCalculationNode::create(NumericValue value) +NonnullOwnPtr NumericCalculationNode::create(NumericValue value) { - return adopt_nonnull_own_or_enomem(new (nothrow) NumericCalculationNode(move(value))); + return adopt_own(*new (nothrow) NumericCalculationNode(move(value))); } NumericCalculationNode::NumericCalculationNode(NumericValue value) @@ -211,9 +211,9 @@ ErrorOr NumericCalculationNode::dump(StringBuilder& builder, int indent) c return builder.try_appendff("{: >{}}NUMERIC({})\n", "", indent, TRY(m_value.visit([](auto& it) { return it.to_string(); }))); } -ErrorOr> SumCalculationNode::create(Vector> values) +NonnullOwnPtr SumCalculationNode::create(Vector> values) { - return adopt_nonnull_own_or_enomem(new (nothrow) SumCalculationNode(move(values))); + return adopt_own(*new (nothrow) SumCalculationNode(move(values))); } SumCalculationNode::SumCalculationNode(Vector> values) @@ -314,14 +314,12 @@ CalculatedStyleValue::CalculationResult SumCalculationNode::resolve(Optional SumCalculationNode::for_each_child_node(Function(NonnullOwnPtr&)> const& callback) +void SumCalculationNode::for_each_child_node(Function&)> const& callback) { for (auto& item : m_values) { - TRY(item->for_each_child_node(callback)); - TRY(callback(item)); + item->for_each_child_node(callback); + callback(item); } - - return {}; } ErrorOr SumCalculationNode::dump(StringBuilder& builder, int indent) const @@ -332,9 +330,9 @@ ErrorOr SumCalculationNode::dump(StringBuilder& builder, int indent) const return {}; } -ErrorOr> ProductCalculationNode::create(Vector> values) +NonnullOwnPtr ProductCalculationNode::create(Vector> values) { - return adopt_nonnull_own_or_enomem(new (nothrow) ProductCalculationNode(move(values))); + return adopt_own(*new (nothrow) ProductCalculationNode(move(values))); } ProductCalculationNode::ProductCalculationNode(Vector> values) @@ -440,14 +438,12 @@ CalculatedStyleValue::CalculationResult ProductCalculationNode::resolve(Optional return total.value(); } -ErrorOr ProductCalculationNode::for_each_child_node(Function(NonnullOwnPtr&)> const& callback) +void ProductCalculationNode::for_each_child_node(Function&)> const& callback) { for (auto& item : m_values) { - TRY(item->for_each_child_node(callback)); - TRY(callback(item)); + item->for_each_child_node(callback); + callback(item); } - - return {}; } ErrorOr ProductCalculationNode::dump(StringBuilder& builder, int indent) const @@ -458,9 +454,9 @@ ErrorOr ProductCalculationNode::dump(StringBuilder& builder, int indent) c return {}; } -ErrorOr> NegateCalculationNode::create(NonnullOwnPtr value) +NonnullOwnPtr NegateCalculationNode::create(NonnullOwnPtr value) { - return adopt_nonnull_own_or_enomem(new (nothrow) NegateCalculationNode(move(value))); + return adopt_own(*new (nothrow) NegateCalculationNode(move(value))); } NegateCalculationNode::NegateCalculationNode(NonnullOwnPtr value) @@ -500,11 +496,10 @@ CalculatedStyleValue::CalculationResult NegateCalculationNode::resolve(Optional< return child_value; } -ErrorOr NegateCalculationNode::for_each_child_node(Function(NonnullOwnPtr&)> const& callback) +void NegateCalculationNode::for_each_child_node(Function&)> const& callback) { - TRY(m_value->for_each_child_node(callback)); - TRY(callback(m_value)); - return {}; + m_value->for_each_child_node(callback); + callback(m_value); } ErrorOr NegateCalculationNode::dump(StringBuilder& builder, int indent) const @@ -514,9 +509,9 @@ ErrorOr NegateCalculationNode::dump(StringBuilder& builder, int indent) co return {}; } -ErrorOr> InvertCalculationNode::create(NonnullOwnPtr value) +NonnullOwnPtr InvertCalculationNode::create(NonnullOwnPtr value) { - return adopt_nonnull_own_or_enomem(new (nothrow) InvertCalculationNode(move(value))); + return adopt_own(*new (nothrow) InvertCalculationNode(move(value))); } InvertCalculationNode::InvertCalculationNode(NonnullOwnPtr value) @@ -563,11 +558,10 @@ CalculatedStyleValue::CalculationResult InvertCalculationNode::resolve(Optional< return child_value; } -ErrorOr InvertCalculationNode::for_each_child_node(Function(NonnullOwnPtr&)> const& callback) +void InvertCalculationNode::for_each_child_node(Function&)> const& callback) { - TRY(m_value->for_each_child_node(callback)); - TRY(callback(m_value)); - return {}; + m_value->for_each_child_node(callback); + callback(m_value); } ErrorOr InvertCalculationNode::dump(StringBuilder& builder, int indent) const @@ -577,9 +571,9 @@ ErrorOr InvertCalculationNode::dump(StringBuilder& builder, int indent) co return {}; } -ErrorOr> MinCalculationNode::create(Vector> values) +NonnullOwnPtr MinCalculationNode::create(Vector> values) { - return adopt_nonnull_own_or_enomem(new (nothrow) MinCalculationNode(move(values))); + return adopt_own(*new (nothrow) MinCalculationNode(move(values))); } MinCalculationNode::MinCalculationNode(Vector> values) @@ -644,14 +638,12 @@ CalculatedStyleValue::CalculationResult MinCalculationNode::resolve(Optional MinCalculationNode::for_each_child_node(Function(NonnullOwnPtr&)> const& callback) +void MinCalculationNode::for_each_child_node(Function&)> const& callback) { for (auto& value : m_values) { - TRY(value->for_each_child_node(callback)); - TRY(callback(value)); + value->for_each_child_node(callback); + callback(value); } - - return {}; } ErrorOr MinCalculationNode::dump(StringBuilder& builder, int indent) const @@ -662,9 +654,9 @@ ErrorOr MinCalculationNode::dump(StringBuilder& builder, int indent) const return {}; } -ErrorOr> MaxCalculationNode::create(Vector> values) +NonnullOwnPtr MaxCalculationNode::create(Vector> values) { - return adopt_nonnull_own_or_enomem(new (nothrow) MaxCalculationNode(move(values))); + return adopt_own(*new (nothrow) MaxCalculationNode(move(values))); } MaxCalculationNode::MaxCalculationNode(Vector> values) @@ -729,14 +721,12 @@ CalculatedStyleValue::CalculationResult MaxCalculationNode::resolve(Optional MaxCalculationNode::for_each_child_node(Function(NonnullOwnPtr&)> const& callback) +void MaxCalculationNode::for_each_child_node(Function&)> const& callback) { for (auto& value : m_values) { - TRY(value->for_each_child_node(callback)); - TRY(callback(value)); + value->for_each_child_node(callback); + callback(value); } - - return {}; } ErrorOr MaxCalculationNode::dump(StringBuilder& builder, int indent) const @@ -747,9 +737,9 @@ ErrorOr MaxCalculationNode::dump(StringBuilder& builder, int indent) const return {}; } -ErrorOr> ClampCalculationNode::create(NonnullOwnPtr min, NonnullOwnPtr center, NonnullOwnPtr max) +NonnullOwnPtr ClampCalculationNode::create(NonnullOwnPtr min, NonnullOwnPtr center, NonnullOwnPtr max) { - return adopt_nonnull_own_or_enomem(new (nothrow) ClampCalculationNode(move(min), move(center), move(max))); + return adopt_own(*new (nothrow) ClampCalculationNode(move(min), move(center), move(max))); } ClampCalculationNode::ClampCalculationNode(NonnullOwnPtr min, NonnullOwnPtr center, NonnullOwnPtr max) @@ -825,16 +815,14 @@ CalculatedStyleValue::CalculationResult ClampCalculationNode::resolve(Optional ClampCalculationNode::for_each_child_node(Function(NonnullOwnPtr&)> const& callback) +void ClampCalculationNode::for_each_child_node(Function&)> const& callback) { - TRY(m_min_value->for_each_child_node(callback)); - TRY(m_center_value->for_each_child_node(callback)); - TRY(m_max_value->for_each_child_node(callback)); - TRY(callback(m_min_value)); - TRY(callback(m_center_value)); - TRY(callback(m_max_value)); - - return {}; + m_min_value->for_each_child_node(callback); + m_center_value->for_each_child_node(callback); + m_max_value->for_each_child_node(callback); + callback(m_min_value); + callback(m_center_value); + callback(m_max_value); } ErrorOr ClampCalculationNode::dump(StringBuilder& builder, int indent) const @@ -846,9 +834,9 @@ ErrorOr ClampCalculationNode::dump(StringBuilder& builder, int indent) con return {}; } -ErrorOr> AbsCalculationNode::create(NonnullOwnPtr value) +NonnullOwnPtr AbsCalculationNode::create(NonnullOwnPtr value) { - return adopt_nonnull_own_or_enomem(new (nothrow) AbsCalculationNode(move(value))); + return adopt_own(*new (nothrow) AbsCalculationNode(move(value))); } AbsCalculationNode::AbsCalculationNode(NonnullOwnPtr value) @@ -897,11 +885,10 @@ CalculatedStyleValue::CalculationResult AbsCalculationNode::resolve(Optional AbsCalculationNode::for_each_child_node(Function(NonnullOwnPtr&)> const& callback) +void AbsCalculationNode::for_each_child_node(Function&)> const& callback) { - TRY(m_value->for_each_child_node(callback)); - TRY(callback(m_value)); - return {}; + m_value->for_each_child_node(callback); + callback(m_value); } ErrorOr AbsCalculationNode::dump(StringBuilder& builder, int indent) const @@ -910,9 +897,9 @@ ErrorOr AbsCalculationNode::dump(StringBuilder& builder, int indent) const return {}; } -ErrorOr> SignCalculationNode::create(NonnullOwnPtr value) +NonnullOwnPtr SignCalculationNode::create(NonnullOwnPtr value) { - return adopt_nonnull_own_or_enomem(new (nothrow) SignCalculationNode(move(value))); + return adopt_own(*new (nothrow) SignCalculationNode(move(value))); } SignCalculationNode::SignCalculationNode(NonnullOwnPtr value) @@ -963,11 +950,10 @@ CalculatedStyleValue::CalculationResult SignCalculationNode::resolve(Optional SignCalculationNode::for_each_child_node(Function(NonnullOwnPtr&)> const& callback) +void SignCalculationNode::for_each_child_node(Function&)> const& callback) { - TRY(m_value->for_each_child_node(callback)); - TRY(callback(m_value)); - return {}; + m_value->for_each_child_node(callback); + callback(m_value); } ErrorOr SignCalculationNode::dump(StringBuilder& builder, int indent) const @@ -976,9 +962,9 @@ ErrorOr SignCalculationNode::dump(StringBuilder& builder, int indent) cons return {}; } -ErrorOr> ConstantCalculationNode::create(ConstantType constant) +NonnullOwnPtr ConstantCalculationNode::create(ConstantType constant) { - return adopt_nonnull_own_or_enomem(new (nothrow) ConstantCalculationNode(constant)); + return adopt_own(*new (nothrow) ConstantCalculationNode(constant)); } ConstantCalculationNode::ConstantCalculationNode(ConstantType constant) @@ -1039,20 +1025,15 @@ CalculatedStyleValue::CalculationResult ConstantCalculationNode::resolve([[maybe VERIFY_NOT_REACHED(); } -ErrorOr ConstantCalculationNode::for_each_child_node([[maybe_unused]] Function(NonnullOwnPtr&)> const& callback) -{ - return {}; -} - ErrorOr ConstantCalculationNode::dump(StringBuilder& builder, int indent) const { TRY(builder.try_appendff("{: >{}}CONSTANT: {}\n", "", indent, TRY(to_string()))); return {}; } -ErrorOr> SinCalculationNode::create(NonnullOwnPtr value) +NonnullOwnPtr SinCalculationNode::create(NonnullOwnPtr value) { - return adopt_nonnull_own_or_enomem(new (nothrow) SinCalculationNode(move(value))); + return adopt_own(*new (nothrow) SinCalculationNode(move(value))); } SinCalculationNode::SinCalculationNode(NonnullOwnPtr value) @@ -1098,11 +1079,10 @@ CalculatedStyleValue::CalculationResult SinCalculationNode::resolve(Optional SinCalculationNode::for_each_child_node(Function(NonnullOwnPtr&)> const& callback) +void SinCalculationNode::for_each_child_node(Function&)> const& callback) { - TRY(m_value->for_each_child_node(callback)); - TRY(callback(m_value)); - return {}; + m_value->for_each_child_node(callback); + callback(m_value); } ErrorOr SinCalculationNode::dump(StringBuilder& builder, int indent) const @@ -1111,9 +1091,9 @@ ErrorOr SinCalculationNode::dump(StringBuilder& builder, int indent) const return {}; } -ErrorOr> CosCalculationNode::create(NonnullOwnPtr value) +NonnullOwnPtr CosCalculationNode::create(NonnullOwnPtr value) { - return adopt_nonnull_own_or_enomem(new (nothrow) CosCalculationNode(move(value))); + return adopt_own(*new (nothrow) CosCalculationNode(move(value))); } CosCalculationNode::CosCalculationNode(NonnullOwnPtr value) @@ -1159,11 +1139,10 @@ CalculatedStyleValue::CalculationResult CosCalculationNode::resolve(Optional CosCalculationNode::for_each_child_node(Function(NonnullOwnPtr&)> const& callback) +void CosCalculationNode::for_each_child_node(Function&)> const& callback) { - TRY(m_value->for_each_child_node(callback)); - TRY(callback(m_value)); - return {}; + m_value->for_each_child_node(callback); + callback(m_value); } ErrorOr CosCalculationNode::dump(StringBuilder& builder, int indent) const @@ -1172,9 +1151,9 @@ ErrorOr CosCalculationNode::dump(StringBuilder& builder, int indent) const return {}; } -ErrorOr> TanCalculationNode::create(NonnullOwnPtr value) +NonnullOwnPtr TanCalculationNode::create(NonnullOwnPtr value) { - return adopt_nonnull_own_or_enomem(new (nothrow) TanCalculationNode(move(value))); + return adopt_own(*new (nothrow) TanCalculationNode(move(value))); } TanCalculationNode::TanCalculationNode(NonnullOwnPtr value) @@ -1220,11 +1199,10 @@ CalculatedStyleValue::CalculationResult TanCalculationNode::resolve(Optional TanCalculationNode::for_each_child_node(Function(NonnullOwnPtr&)> const& callback) +void TanCalculationNode::for_each_child_node(Function&)> const& callback) { - TRY(m_value->for_each_child_node(callback)); - TRY(callback(m_value)); - return {}; + m_value->for_each_child_node(callback); + callback(m_value); } ErrorOr TanCalculationNode::dump(StringBuilder& builder, int indent) const @@ -1233,9 +1211,9 @@ ErrorOr TanCalculationNode::dump(StringBuilder& builder, int indent) const return {}; } -ErrorOr> AsinCalculationNode::create(NonnullOwnPtr value) +NonnullOwnPtr AsinCalculationNode::create(NonnullOwnPtr value) { - return adopt_nonnull_own_or_enomem(new (nothrow) AsinCalculationNode(move(value))); + return adopt_own(*new (nothrow) AsinCalculationNode(move(value))); } AsinCalculationNode::AsinCalculationNode(NonnullOwnPtr value) @@ -1281,11 +1259,10 @@ CalculatedStyleValue::CalculationResult AsinCalculationNode::resolve(Optional AsinCalculationNode::for_each_child_node(Function(NonnullOwnPtr&)> const& callback) +void AsinCalculationNode::for_each_child_node(Function&)> const& callback) { - TRY(m_value->for_each_child_node(callback)); - TRY(callback(m_value)); - return {}; + m_value->for_each_child_node(callback); + callback(m_value); } ErrorOr AsinCalculationNode::dump(StringBuilder& builder, int indent) const @@ -1294,9 +1271,9 @@ ErrorOr AsinCalculationNode::dump(StringBuilder& builder, int indent) cons return {}; } -ErrorOr> AcosCalculationNode::create(NonnullOwnPtr value) +NonnullOwnPtr AcosCalculationNode::create(NonnullOwnPtr value) { - return adopt_nonnull_own_or_enomem(new (nothrow) AcosCalculationNode(move(value))); + return adopt_own(*new (nothrow) AcosCalculationNode(move(value))); } AcosCalculationNode::AcosCalculationNode(NonnullOwnPtr value) @@ -1342,11 +1319,10 @@ CalculatedStyleValue::CalculationResult AcosCalculationNode::resolve(Optional AcosCalculationNode::for_each_child_node(Function(NonnullOwnPtr&)> const& callback) +void AcosCalculationNode::for_each_child_node(Function&)> const& callback) { - TRY(m_value->for_each_child_node(callback)); - TRY(callback(m_value)); - return {}; + m_value->for_each_child_node(callback); + callback(m_value); } ErrorOr AcosCalculationNode::dump(StringBuilder& builder, int indent) const @@ -1355,9 +1331,9 @@ ErrorOr AcosCalculationNode::dump(StringBuilder& builder, int indent) cons return {}; } -ErrorOr> AtanCalculationNode::create(NonnullOwnPtr value) +NonnullOwnPtr AtanCalculationNode::create(NonnullOwnPtr value) { - return adopt_nonnull_own_or_enomem(new (nothrow) AtanCalculationNode(move(value))); + return adopt_own(*new (nothrow) AtanCalculationNode(move(value))); } AtanCalculationNode::AtanCalculationNode(NonnullOwnPtr value) @@ -1403,11 +1379,10 @@ CalculatedStyleValue::CalculationResult AtanCalculationNode::resolve(Optional AtanCalculationNode::for_each_child_node(Function(NonnullOwnPtr&)> const& callback) +void AtanCalculationNode::for_each_child_node(Function&)> const& callback) { - TRY(m_value->for_each_child_node(callback)); - TRY(callback(m_value)); - return {}; + m_value->for_each_child_node(callback); + callback(m_value); } ErrorOr AtanCalculationNode::dump(StringBuilder& builder, int indent) const @@ -1416,9 +1391,9 @@ ErrorOr AtanCalculationNode::dump(StringBuilder& builder, int indent) cons return {}; } -ErrorOr> Atan2CalculationNode::create(NonnullOwnPtr y, NonnullOwnPtr x) +NonnullOwnPtr Atan2CalculationNode::create(NonnullOwnPtr y, NonnullOwnPtr x) { - return adopt_nonnull_own_or_enomem(new (nothrow) Atan2CalculationNode(move(y), move(x))); + return adopt_own(*new (nothrow) Atan2CalculationNode(move(y), move(x))); } Atan2CalculationNode::Atan2CalculationNode(NonnullOwnPtr y, NonnullOwnPtr x) @@ -1471,13 +1446,12 @@ CalculatedStyleValue::CalculationResult Atan2CalculationNode::resolve(Optional Atan2CalculationNode::for_each_child_node(Function(NonnullOwnPtr&)> const& callback) +void Atan2CalculationNode::for_each_child_node(Function&)> const& callback) { - TRY(m_y->for_each_child_node(callback)); - TRY(m_x->for_each_child_node(callback)); - TRY(callback(m_y)); - TRY(callback(m_x)); - return {}; + m_y->for_each_child_node(callback); + m_x->for_each_child_node(callback); + callback(m_y); + callback(m_x); } ErrorOr Atan2CalculationNode::dump(StringBuilder& builder, int indent) const @@ -1486,9 +1460,9 @@ ErrorOr Atan2CalculationNode::dump(StringBuilder& builder, int indent) con return {}; } -ErrorOr> PowCalculationNode::create(NonnullOwnPtr x, NonnullOwnPtr y) +NonnullOwnPtr PowCalculationNode::create(NonnullOwnPtr x, NonnullOwnPtr y) { - return adopt_nonnull_own_or_enomem(new (nothrow) PowCalculationNode(move(x), move(y))); + return adopt_own(*new (nothrow) PowCalculationNode(move(x), move(y))); } PowCalculationNode::PowCalculationNode(NonnullOwnPtr x, NonnullOwnPtr y) @@ -1536,13 +1510,12 @@ CalculatedStyleValue::CalculationResult PowCalculationNode::resolve(Optional PowCalculationNode::for_each_child_node(Function(NonnullOwnPtr&)> const& callback) +void PowCalculationNode::for_each_child_node(Function&)> const& callback) { - TRY(m_x->for_each_child_node(callback)); - TRY(m_y->for_each_child_node(callback)); - TRY(callback(m_x)); - TRY(callback(m_y)); - return {}; + m_x->for_each_child_node(callback); + m_y->for_each_child_node(callback); + callback(m_x); + callback(m_y); } ErrorOr PowCalculationNode::dump(StringBuilder& builder, int indent) const @@ -1551,9 +1524,9 @@ ErrorOr PowCalculationNode::dump(StringBuilder& builder, int indent) const return {}; } -ErrorOr> SqrtCalculationNode::create(NonnullOwnPtr value) +NonnullOwnPtr SqrtCalculationNode::create(NonnullOwnPtr value) { - return adopt_nonnull_own_or_enomem(new (nothrow) SqrtCalculationNode(move(value))); + return adopt_own(*new (nothrow) SqrtCalculationNode(move(value))); } SqrtCalculationNode::SqrtCalculationNode(NonnullOwnPtr value) @@ -1594,11 +1567,10 @@ CalculatedStyleValue::CalculationResult SqrtCalculationNode::resolve(Optional SqrtCalculationNode::for_each_child_node(Function(NonnullOwnPtr&)> const& callback) +void SqrtCalculationNode::for_each_child_node(Function&)> const& callback) { - TRY(m_value->for_each_child_node(callback)); - TRY(callback(m_value)); - return {}; + m_value->for_each_child_node(callback); + callback(m_value); } ErrorOr SqrtCalculationNode::dump(StringBuilder& builder, int indent) const @@ -1607,9 +1579,9 @@ ErrorOr SqrtCalculationNode::dump(StringBuilder& builder, int indent) cons return {}; } -ErrorOr> HypotCalculationNode::create(Vector> values) +NonnullOwnPtr HypotCalculationNode::create(Vector> values) { - return adopt_nonnull_own_or_enomem(new (nothrow) HypotCalculationNode(move(values))); + return adopt_own(*new (nothrow) HypotCalculationNode(move(values))); } HypotCalculationNode::HypotCalculationNode(Vector> values) @@ -1672,14 +1644,12 @@ CalculatedStyleValue::CalculationResult HypotCalculationNode::resolve(Optional HypotCalculationNode::for_each_child_node(Function(NonnullOwnPtr&)> const& callback) +void HypotCalculationNode::for_each_child_node(Function&)> const& callback) { for (auto& value : m_values) { - TRY(value->for_each_child_node(callback)); - TRY(callback(value)); + value->for_each_child_node(callback); + callback(value); } - - return {}; } ErrorOr HypotCalculationNode::dump(StringBuilder& builder, int indent) const @@ -1690,9 +1660,9 @@ ErrorOr HypotCalculationNode::dump(StringBuilder& builder, int indent) con return {}; } -ErrorOr> LogCalculationNode::create(NonnullOwnPtr x, NonnullOwnPtr y) +NonnullOwnPtr LogCalculationNode::create(NonnullOwnPtr x, NonnullOwnPtr y) { - return adopt_nonnull_own_or_enomem(new (nothrow) LogCalculationNode(move(x), move(y))); + return adopt_own(*new (nothrow) LogCalculationNode(move(x), move(y))); } LogCalculationNode::LogCalculationNode(NonnullOwnPtr x, NonnullOwnPtr y) @@ -1740,13 +1710,12 @@ CalculatedStyleValue::CalculationResult LogCalculationNode::resolve(Optional LogCalculationNode::for_each_child_node(Function(NonnullOwnPtr&)> const& callback) +void LogCalculationNode::for_each_child_node(Function&)> const& callback) { - TRY(m_x->for_each_child_node(callback)); - TRY(m_y->for_each_child_node(callback)); - TRY(callback(m_x)); - TRY(callback(m_y)); - return {}; + m_x->for_each_child_node(callback); + m_y->for_each_child_node(callback); + callback(m_x); + callback(m_y); } ErrorOr LogCalculationNode::dump(StringBuilder& builder, int indent) const @@ -1755,9 +1724,9 @@ ErrorOr LogCalculationNode::dump(StringBuilder& builder, int indent) const return {}; } -ErrorOr> ExpCalculationNode::create(NonnullOwnPtr value) +NonnullOwnPtr ExpCalculationNode::create(NonnullOwnPtr value) { - return adopt_nonnull_own_or_enomem(new (nothrow) ExpCalculationNode(move(value))); + return adopt_own(*new (nothrow) ExpCalculationNode(move(value))); } ExpCalculationNode::ExpCalculationNode(NonnullOwnPtr value) @@ -1798,11 +1767,10 @@ CalculatedStyleValue::CalculationResult ExpCalculationNode::resolve(Optional ExpCalculationNode::for_each_child_node(Function(NonnullOwnPtr&)> const& callback) +void ExpCalculationNode::for_each_child_node(Function&)> const& callback) { - TRY(m_value->for_each_child_node(callback)); - TRY(callback(m_value)); - return {}; + m_value->for_each_child_node(callback); + callback(m_value); } ErrorOr ExpCalculationNode::dump(StringBuilder& builder, int indent) const @@ -1811,9 +1779,9 @@ ErrorOr ExpCalculationNode::dump(StringBuilder& builder, int indent) const return {}; } -ErrorOr> RoundCalculationNode::create(RoundingStrategy strategy, NonnullOwnPtr x, NonnullOwnPtr y) +NonnullOwnPtr RoundCalculationNode::create(RoundingStrategy strategy, NonnullOwnPtr x, NonnullOwnPtr y) { - return adopt_nonnull_own_or_enomem(new (nothrow) RoundCalculationNode(strategy, move(x), move(y))); + return adopt_own(*new (nothrow) RoundCalculationNode(strategy, move(x), move(y))); } RoundCalculationNode::RoundCalculationNode(RoundingStrategy mode, NonnullOwnPtr x, NonnullOwnPtr y) @@ -1900,13 +1868,12 @@ CalculatedStyleValue::CalculationResult RoundCalculationNode::resolve(Optional RoundCalculationNode::for_each_child_node(Function(NonnullOwnPtr&)> const& callback) +void RoundCalculationNode::for_each_child_node(Function&)> const& callback) { - TRY(m_x->for_each_child_node(callback)); - TRY(m_y->for_each_child_node(callback)); - TRY(callback(m_x)); - TRY(callback(m_y)); - return {}; + m_x->for_each_child_node(callback); + m_y->for_each_child_node(callback); + callback(m_x); + callback(m_y); } ErrorOr RoundCalculationNode::dump(StringBuilder& builder, int indent) const @@ -1915,9 +1882,9 @@ ErrorOr RoundCalculationNode::dump(StringBuilder& builder, int indent) con return {}; } -ErrorOr> ModCalculationNode::create(NonnullOwnPtr x, NonnullOwnPtr y) +NonnullOwnPtr ModCalculationNode::create(NonnullOwnPtr x, NonnullOwnPtr y) { - return adopt_nonnull_own_or_enomem(new (nothrow) ModCalculationNode(move(x), move(y))); + return adopt_own(*new (nothrow) ModCalculationNode(move(x), move(y))); } ModCalculationNode::ModCalculationNode(NonnullOwnPtr x, NonnullOwnPtr y) @@ -1978,13 +1945,12 @@ CalculatedStyleValue::CalculationResult ModCalculationNode::resolve(Optional ModCalculationNode::for_each_child_node(Function(NonnullOwnPtr&)> const& callback) +void ModCalculationNode::for_each_child_node(Function&)> const& callback) { - TRY(m_x->for_each_child_node(callback)); - TRY(m_y->for_each_child_node(callback)); - TRY(callback(m_x)); - TRY(callback(m_y)); - return {}; + m_x->for_each_child_node(callback); + m_y->for_each_child_node(callback); + callback(m_x); + callback(m_y); } ErrorOr ModCalculationNode::dump(StringBuilder& builder, int indent) const @@ -1993,9 +1959,9 @@ ErrorOr ModCalculationNode::dump(StringBuilder& builder, int indent) const return {}; } -ErrorOr> RemCalculationNode::create(NonnullOwnPtr x, NonnullOwnPtr y) +NonnullOwnPtr RemCalculationNode::create(NonnullOwnPtr x, NonnullOwnPtr y) { - return adopt_nonnull_own_or_enomem(new (nothrow) RemCalculationNode(move(x), move(y))); + return adopt_own(*new (nothrow) RemCalculationNode(move(x), move(y))); } RemCalculationNode::RemCalculationNode(NonnullOwnPtr x, NonnullOwnPtr y) @@ -2055,13 +2021,12 @@ CalculatedStyleValue::CalculationResult RemCalculationNode::resolve(Optional RemCalculationNode::for_each_child_node(Function(NonnullOwnPtr&)> const& callback) +void RemCalculationNode::for_each_child_node(Function&)> const& callback) { - TRY(m_x->for_each_child_node(callback)); - TRY(m_y->for_each_child_node(callback)); - TRY(callback(m_x)); - TRY(callback(m_y)); - return {}; + m_x->for_each_child_node(callback); + m_y->for_each_child_node(callback); + callback(m_x); + callback(m_y); } ErrorOr RemCalculationNode::dump(StringBuilder& builder, int indent) const diff --git a/Userland/Libraries/LibWeb/CSS/StyleValues/CalculatedStyleValue.h b/Userland/Libraries/LibWeb/CSS/StyleValues/CalculatedStyleValue.h index ca39b039c7..a8d68fc770 100644 --- a/Userland/Libraries/LibWeb/CSS/StyleValues/CalculatedStyleValue.h +++ b/Userland/Libraries/LibWeb/CSS/StyleValues/CalculatedStyleValue.h @@ -238,7 +238,7 @@ public: virtual Optional determine_type(PropertyID) const = 0; virtual bool contains_percentage() const = 0; virtual CalculatedStyleValue::CalculationResult resolve(Optional, CalculatedStyleValue::PercentageBasis const&) const = 0; - virtual ErrorOr for_each_child_node(Function(NonnullOwnPtr&)> const&) { return {}; } + virtual void for_each_child_node(Function&)> const&) = 0; virtual ErrorOr dump(StringBuilder&, int indent) const = 0; @@ -251,7 +251,7 @@ private: class NumericCalculationNode final : public CalculationNode { public: - static ErrorOr> create(NumericValue); + static NonnullOwnPtr create(NumericValue); ~NumericCalculationNode(); virtual ErrorOr to_string() const override; @@ -259,6 +259,7 @@ public: virtual Optional determine_type(PropertyID) const override; virtual bool contains_percentage() const override; virtual CalculatedStyleValue::CalculationResult resolve(Optional, CalculatedStyleValue::PercentageBasis const&) const override; + virtual void for_each_child_node(Function&)> const&) override { } virtual ErrorOr dump(StringBuilder&, int indent) const override; @@ -269,7 +270,7 @@ private: class SumCalculationNode final : public CalculationNode { public: - static ErrorOr> create(Vector>); + static NonnullOwnPtr create(Vector>); ~SumCalculationNode(); virtual ErrorOr to_string() const override; @@ -277,7 +278,7 @@ public: virtual Optional determine_type(PropertyID) const override; virtual bool contains_percentage() const override; virtual CalculatedStyleValue::CalculationResult resolve(Optional, CalculatedStyleValue::PercentageBasis const&) const override; - virtual ErrorOr for_each_child_node(Function(NonnullOwnPtr&)> const&) override; + virtual void for_each_child_node(Function&)> const&) override; virtual ErrorOr dump(StringBuilder&, int indent) const override; @@ -288,7 +289,7 @@ private: class ProductCalculationNode final : public CalculationNode { public: - static ErrorOr> create(Vector>); + static NonnullOwnPtr create(Vector>); ~ProductCalculationNode(); virtual ErrorOr to_string() const override; @@ -296,7 +297,7 @@ public: virtual Optional determine_type(PropertyID) const override; virtual bool contains_percentage() const override; virtual CalculatedStyleValue::CalculationResult resolve(Optional, CalculatedStyleValue::PercentageBasis const&) const override; - virtual ErrorOr for_each_child_node(Function(NonnullOwnPtr&)> const&) override; + virtual void for_each_child_node(Function&)> const&) override; virtual ErrorOr dump(StringBuilder&, int indent) const override; @@ -307,7 +308,7 @@ private: class NegateCalculationNode final : public CalculationNode { public: - static ErrorOr> create(NonnullOwnPtr); + static NonnullOwnPtr create(NonnullOwnPtr); ~NegateCalculationNode(); virtual ErrorOr to_string() const override; @@ -315,7 +316,7 @@ public: virtual Optional determine_type(PropertyID) const override; virtual bool contains_percentage() const override; virtual CalculatedStyleValue::CalculationResult resolve(Optional, CalculatedStyleValue::PercentageBasis const&) const override; - virtual ErrorOr for_each_child_node(Function(NonnullOwnPtr&)> const&) override; + virtual void for_each_child_node(Function&)> const&) override; virtual ErrorOr dump(StringBuilder&, int indent) const override; @@ -326,7 +327,7 @@ private: class InvertCalculationNode final : public CalculationNode { public: - static ErrorOr> create(NonnullOwnPtr); + static NonnullOwnPtr create(NonnullOwnPtr); ~InvertCalculationNode(); virtual ErrorOr to_string() const override; @@ -334,7 +335,7 @@ public: virtual Optional determine_type(PropertyID) const override; virtual bool contains_percentage() const override; virtual CalculatedStyleValue::CalculationResult resolve(Optional, CalculatedStyleValue::PercentageBasis const&) const override; - virtual ErrorOr for_each_child_node(Function(NonnullOwnPtr&)> const&) override; + virtual void for_each_child_node(Function&)> const&) override; virtual ErrorOr dump(StringBuilder&, int indent) const override; @@ -345,7 +346,7 @@ private: class MinCalculationNode final : public CalculationNode { public: - static ErrorOr> create(Vector>); + static NonnullOwnPtr create(Vector>); ~MinCalculationNode(); virtual ErrorOr to_string() const override; @@ -353,7 +354,7 @@ public: virtual Optional determine_type(PropertyID) const override; virtual bool contains_percentage() const override; virtual CalculatedStyleValue::CalculationResult resolve(Optional, CalculatedStyleValue::PercentageBasis const&) const override; - virtual ErrorOr for_each_child_node(Function(NonnullOwnPtr&)> const&) override; + virtual void for_each_child_node(Function&)> const&) override; virtual ErrorOr dump(StringBuilder&, int indent) const override; @@ -364,7 +365,7 @@ private: class MaxCalculationNode final : public CalculationNode { public: - static ErrorOr> create(Vector>); + static NonnullOwnPtr create(Vector>); ~MaxCalculationNode(); virtual ErrorOr to_string() const override; @@ -372,7 +373,7 @@ public: virtual Optional determine_type(PropertyID) const override; virtual bool contains_percentage() const override; virtual CalculatedStyleValue::CalculationResult resolve(Optional, CalculatedStyleValue::PercentageBasis const&) const override; - virtual ErrorOr for_each_child_node(Function(NonnullOwnPtr&)> const&) override; + virtual void for_each_child_node(Function&)> const&) override; virtual ErrorOr dump(StringBuilder&, int indent) const override; @@ -383,7 +384,7 @@ private: class ClampCalculationNode final : public CalculationNode { public: - static ErrorOr> create(NonnullOwnPtr, NonnullOwnPtr, NonnullOwnPtr); + static NonnullOwnPtr create(NonnullOwnPtr, NonnullOwnPtr, NonnullOwnPtr); ~ClampCalculationNode(); virtual ErrorOr to_string() const override; @@ -391,7 +392,7 @@ public: virtual Optional determine_type(PropertyID) const override; virtual bool contains_percentage() const override; virtual CalculatedStyleValue::CalculationResult resolve(Optional, CalculatedStyleValue::PercentageBasis const&) const override; - virtual ErrorOr for_each_child_node(Function(NonnullOwnPtr&)> const&) override; + virtual void for_each_child_node(Function&)> const&) override; virtual ErrorOr dump(StringBuilder&, int indent) const override; @@ -404,7 +405,7 @@ private: class AbsCalculationNode final : public CalculationNode { public: - static ErrorOr> create(NonnullOwnPtr); + static NonnullOwnPtr create(NonnullOwnPtr); ~AbsCalculationNode(); virtual ErrorOr to_string() const override; @@ -412,7 +413,7 @@ public: virtual Optional determine_type(PropertyID) const override; virtual bool contains_percentage() const override; virtual CalculatedStyleValue::CalculationResult resolve(Optional, CalculatedStyleValue::PercentageBasis const&) const override; - virtual ErrorOr for_each_child_node(Function(NonnullOwnPtr&)> const&) override; + virtual void for_each_child_node(Function&)> const&) override; virtual ErrorOr dump(StringBuilder&, int indent) const override; @@ -423,7 +424,7 @@ private: class SignCalculationNode final : public CalculationNode { public: - static ErrorOr> create(NonnullOwnPtr); + static NonnullOwnPtr create(NonnullOwnPtr); ~SignCalculationNode(); virtual ErrorOr to_string() const override; @@ -431,7 +432,7 @@ public: virtual Optional determine_type(PropertyID) const override; virtual bool contains_percentage() const override; virtual CalculatedStyleValue::CalculationResult resolve(Optional, CalculatedStyleValue::PercentageBasis const&) const override; - virtual ErrorOr for_each_child_node(Function(NonnullOwnPtr&)> const&) override; + virtual void for_each_child_node(Function&)> const&) override; virtual ErrorOr dump(StringBuilder&, int indent) const override; @@ -442,7 +443,7 @@ private: class ConstantCalculationNode final : public CalculationNode { public: - static ErrorOr> create(CalculationNode::ConstantType); + static NonnullOwnPtr create(CalculationNode::ConstantType); ~ConstantCalculationNode(); virtual ErrorOr to_string() const override; @@ -450,7 +451,7 @@ public: virtual Optional determine_type(PropertyID) const override; virtual bool contains_percentage() const override { return false; } virtual CalculatedStyleValue::CalculationResult resolve(Optional context, CalculatedStyleValue::PercentageBasis const&) const override; - virtual ErrorOr for_each_child_node(Function(NonnullOwnPtr&)> const&) override; + virtual void for_each_child_node(Function&)> const&) override { } virtual ErrorOr dump(StringBuilder&, int indent) const override; @@ -461,7 +462,7 @@ private: class SinCalculationNode final : public CalculationNode { public: - static ErrorOr> create(NonnullOwnPtr); + static NonnullOwnPtr create(NonnullOwnPtr); ~SinCalculationNode(); virtual ErrorOr to_string() const override; @@ -469,7 +470,7 @@ public: virtual Optional determine_type(PropertyID) const override; virtual bool contains_percentage() const override; virtual CalculatedStyleValue::CalculationResult resolve(Optional, CalculatedStyleValue::PercentageBasis const&) const override; - virtual ErrorOr for_each_child_node(Function(NonnullOwnPtr&)> const&) override; + virtual void for_each_child_node(Function&)> const&) override; virtual ErrorOr dump(StringBuilder&, int indent) const override; @@ -480,7 +481,7 @@ private: class CosCalculationNode final : public CalculationNode { public: - static ErrorOr> create(NonnullOwnPtr); + static NonnullOwnPtr create(NonnullOwnPtr); ~CosCalculationNode(); virtual ErrorOr to_string() const override; @@ -488,7 +489,7 @@ public: virtual Optional determine_type(PropertyID) const override; virtual bool contains_percentage() const override; virtual CalculatedStyleValue::CalculationResult resolve(Optional, CalculatedStyleValue::PercentageBasis const&) const override; - virtual ErrorOr for_each_child_node(Function(NonnullOwnPtr&)> const&) override; + virtual void for_each_child_node(Function&)> const&) override; virtual ErrorOr dump(StringBuilder&, int indent) const override; @@ -499,7 +500,7 @@ private: class TanCalculationNode final : public CalculationNode { public: - static ErrorOr> create(NonnullOwnPtr); + static NonnullOwnPtr create(NonnullOwnPtr); ~TanCalculationNode(); virtual ErrorOr to_string() const override; @@ -507,7 +508,7 @@ public: virtual Optional determine_type(PropertyID) const override; virtual bool contains_percentage() const override; virtual CalculatedStyleValue::CalculationResult resolve(Optional, CalculatedStyleValue::PercentageBasis const&) const override; - virtual ErrorOr for_each_child_node(Function(NonnullOwnPtr&)> const&) override; + virtual void for_each_child_node(Function&)> const&) override; virtual ErrorOr dump(StringBuilder&, int indent) const override; @@ -518,7 +519,7 @@ private: class AsinCalculationNode final : public CalculationNode { public: - static ErrorOr> create(NonnullOwnPtr); + static NonnullOwnPtr create(NonnullOwnPtr); ~AsinCalculationNode(); virtual ErrorOr to_string() const override; @@ -526,7 +527,7 @@ public: virtual Optional determine_type(PropertyID) const override; virtual bool contains_percentage() const override; virtual CalculatedStyleValue::CalculationResult resolve(Optional, CalculatedStyleValue::PercentageBasis const&) const override; - virtual ErrorOr for_each_child_node(Function(NonnullOwnPtr&)> const&) override; + virtual void for_each_child_node(Function&)> const&) override; virtual ErrorOr dump(StringBuilder&, int indent) const override; @@ -537,7 +538,7 @@ private: class AcosCalculationNode final : public CalculationNode { public: - static ErrorOr> create(NonnullOwnPtr); + static NonnullOwnPtr create(NonnullOwnPtr); ~AcosCalculationNode(); virtual ErrorOr to_string() const override; @@ -545,7 +546,7 @@ public: virtual Optional determine_type(PropertyID) const override; virtual bool contains_percentage() const override; virtual CalculatedStyleValue::CalculationResult resolve(Optional, CalculatedStyleValue::PercentageBasis const&) const override; - virtual ErrorOr for_each_child_node(Function(NonnullOwnPtr&)> const&) override; + virtual void for_each_child_node(Function&)> const&) override; virtual ErrorOr dump(StringBuilder&, int indent) const override; @@ -556,7 +557,7 @@ private: class AtanCalculationNode final : public CalculationNode { public: - static ErrorOr> create(NonnullOwnPtr); + static NonnullOwnPtr create(NonnullOwnPtr); ~AtanCalculationNode(); virtual ErrorOr to_string() const override; @@ -564,7 +565,7 @@ public: virtual Optional determine_type(PropertyID) const override; virtual bool contains_percentage() const override; virtual CalculatedStyleValue::CalculationResult resolve(Optional, CalculatedStyleValue::PercentageBasis const&) const override; - virtual ErrorOr for_each_child_node(Function(NonnullOwnPtr&)> const&) override; + virtual void for_each_child_node(Function&)> const&) override; virtual ErrorOr dump(StringBuilder&, int indent) const override; @@ -575,7 +576,7 @@ private: class Atan2CalculationNode final : public CalculationNode { public: - static ErrorOr> create(NonnullOwnPtr, NonnullOwnPtr); + static NonnullOwnPtr create(NonnullOwnPtr, NonnullOwnPtr); ~Atan2CalculationNode(); virtual ErrorOr to_string() const override; @@ -583,7 +584,7 @@ public: virtual Optional determine_type(PropertyID) const override; virtual bool contains_percentage() const override; virtual CalculatedStyleValue::CalculationResult resolve(Optional, CalculatedStyleValue::PercentageBasis const&) const override; - virtual ErrorOr for_each_child_node(Function(NonnullOwnPtr&)> const&) override; + virtual void for_each_child_node(Function&)> const&) override; virtual ErrorOr dump(StringBuilder&, int indent) const override; @@ -595,7 +596,7 @@ private: class PowCalculationNode final : public CalculationNode { public: - static ErrorOr> create(NonnullOwnPtr, NonnullOwnPtr); + static NonnullOwnPtr create(NonnullOwnPtr, NonnullOwnPtr); ~PowCalculationNode(); virtual ErrorOr to_string() const override; @@ -603,7 +604,7 @@ public: virtual Optional determine_type(PropertyID) const override; virtual bool contains_percentage() const override { return false; } virtual CalculatedStyleValue::CalculationResult resolve(Optional, CalculatedStyleValue::PercentageBasis const&) const override; - virtual ErrorOr for_each_child_node(Function(NonnullOwnPtr&)> const&) override; + virtual void for_each_child_node(Function&)> const&) override; virtual ErrorOr dump(StringBuilder&, int indent) const override; @@ -615,7 +616,7 @@ private: class SqrtCalculationNode final : public CalculationNode { public: - static ErrorOr> create(NonnullOwnPtr); + static NonnullOwnPtr create(NonnullOwnPtr); ~SqrtCalculationNode(); virtual ErrorOr to_string() const override; @@ -623,7 +624,7 @@ public: virtual Optional determine_type(PropertyID) const override; virtual bool contains_percentage() const override { return false; } virtual CalculatedStyleValue::CalculationResult resolve(Optional, CalculatedStyleValue::PercentageBasis const&) const override; - virtual ErrorOr for_each_child_node(Function(NonnullOwnPtr&)> const&) override; + virtual void for_each_child_node(Function&)> const&) override; virtual ErrorOr dump(StringBuilder&, int indent) const override; @@ -634,7 +635,7 @@ private: class HypotCalculationNode final : public CalculationNode { public: - static ErrorOr> create(Vector>); + static NonnullOwnPtr create(Vector>); ~HypotCalculationNode(); virtual ErrorOr to_string() const override; @@ -642,7 +643,7 @@ public: virtual Optional determine_type(PropertyID) const override; virtual bool contains_percentage() const override; virtual CalculatedStyleValue::CalculationResult resolve(Optional, CalculatedStyleValue::PercentageBasis const&) const override; - virtual ErrorOr for_each_child_node(Function(NonnullOwnPtr&)> const&) override; + virtual void for_each_child_node(Function&)> const&) override; virtual ErrorOr dump(StringBuilder&, int indent) const override; @@ -653,7 +654,7 @@ private: class LogCalculationNode final : public CalculationNode { public: - static ErrorOr> create(NonnullOwnPtr, NonnullOwnPtr); + static NonnullOwnPtr create(NonnullOwnPtr, NonnullOwnPtr); ~LogCalculationNode(); virtual ErrorOr to_string() const override; @@ -661,7 +662,7 @@ public: virtual Optional determine_type(PropertyID) const override; virtual bool contains_percentage() const override { return false; } virtual CalculatedStyleValue::CalculationResult resolve(Optional, CalculatedStyleValue::PercentageBasis const&) const override; - virtual ErrorOr for_each_child_node(Function(NonnullOwnPtr&)> const&) override; + virtual void for_each_child_node(Function&)> const&) override; virtual ErrorOr dump(StringBuilder&, int indent) const override; @@ -673,7 +674,7 @@ private: class ExpCalculationNode final : public CalculationNode { public: - static ErrorOr> create(NonnullOwnPtr); + static NonnullOwnPtr create(NonnullOwnPtr); ~ExpCalculationNode(); virtual ErrorOr to_string() const override; @@ -681,7 +682,7 @@ public: virtual Optional determine_type(PropertyID) const override; virtual bool contains_percentage() const override { return false; } virtual CalculatedStyleValue::CalculationResult resolve(Optional, CalculatedStyleValue::PercentageBasis const&) const override; - virtual ErrorOr for_each_child_node(Function(NonnullOwnPtr&)> const&) override; + virtual void for_each_child_node(Function&)> const&) override; virtual ErrorOr dump(StringBuilder&, int indent) const override; @@ -692,7 +693,7 @@ private: class RoundCalculationNode final : public CalculationNode { public: - static ErrorOr> create(RoundingStrategy, NonnullOwnPtr, NonnullOwnPtr); + static NonnullOwnPtr create(RoundingStrategy, NonnullOwnPtr, NonnullOwnPtr); ~RoundCalculationNode(); virtual ErrorOr to_string() const override; @@ -700,7 +701,7 @@ public: virtual Optional determine_type(PropertyID) const override; virtual bool contains_percentage() const override; virtual CalculatedStyleValue::CalculationResult resolve(Optional, CalculatedStyleValue::PercentageBasis const&) const override; - virtual ErrorOr for_each_child_node(Function(NonnullOwnPtr&)> const&) override; + virtual void for_each_child_node(Function&)> const&) override; virtual ErrorOr dump(StringBuilder&, int indent) const override; @@ -713,7 +714,7 @@ private: class ModCalculationNode final : public CalculationNode { public: - static ErrorOr> create(NonnullOwnPtr, NonnullOwnPtr); + static NonnullOwnPtr create(NonnullOwnPtr, NonnullOwnPtr); ~ModCalculationNode(); virtual ErrorOr to_string() const override; @@ -721,7 +722,7 @@ public: virtual Optional determine_type(PropertyID) const override; virtual bool contains_percentage() const override; virtual CalculatedStyleValue::CalculationResult resolve(Optional, CalculatedStyleValue::PercentageBasis const&) const override; - virtual ErrorOr for_each_child_node(Function(NonnullOwnPtr&)> const&) override; + virtual void for_each_child_node(Function&)> const&) override; virtual ErrorOr dump(StringBuilder&, int indent) const override; @@ -733,7 +734,7 @@ private: class RemCalculationNode final : public CalculationNode { public: - static ErrorOr> create(NonnullOwnPtr, NonnullOwnPtr); + static NonnullOwnPtr create(NonnullOwnPtr, NonnullOwnPtr); ~RemCalculationNode(); virtual ErrorOr to_string() const override; @@ -741,7 +742,7 @@ public: virtual Optional determine_type(PropertyID) const override; virtual bool contains_percentage() const override; virtual CalculatedStyleValue::CalculationResult resolve(Optional, CalculatedStyleValue::PercentageBasis const&) const override; - virtual ErrorOr for_each_child_node(Function(NonnullOwnPtr&)> const&) override; + virtual void for_each_child_node(Function&)> const&) override; virtual ErrorOr dump(StringBuilder&, int indent) const override;