Stowage/ladybird
2
0
Fork 0
mirror of https://github.com/LadybirdBrowser/ladybird.git synced 2025-12-07 21:59:54 +00:00
Code Issues Projects Releases Packages Wiki Activity

LibWeb: Don't pass unnecessary PropertyComputationDependencies struct

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

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

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

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

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

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

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

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

@ -18,10 +18,10 @@ String BorderRadiusStyleValue::to_string(SerializationMode mode) const
return MUST(String::formatted("{} {}", m_properties.horizontal_radius->to_string(mode), m_properties.vertical_radius->to_string(mode)));
}
ValueComparingNonnullRefPtr<StyleValue const> BorderRadiusStyleValue::absolutized(ComputationContext const& computation_context, PropertyComputationDependencies& property_computation_dependencies) const
ValueComparingNonnullRefPtr<StyleValue const> BorderRadiusStyleValue::absolutized(ComputationContext const& computation_context) const
{
auto absolutized_horizontal_radius = m_properties.horizontal_radius->absolutized(computation_context, property_computation_dependencies);
auto absolutized_vertical_radius = m_properties.vertical_radius->absolutized(computation_context, property_computation_dependencies);
auto absolutized_horizontal_radius = m_properties.horizontal_radius->absolutized(computation_context);
auto absolutized_vertical_radius = m_properties.vertical_radius->absolutized(computation_context);
if (absolutized_vertical_radius == m_properties.vertical_radius && absolutized_horizontal_radius == m_properties.horizontal_radius)
return *this;

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

@ -26,7 +26,7 @@ ValueComparingNonnullRefPtr<LengthStyleValue const> LengthStyleValue::create(Len
return adopt_ref(*new (nothrow) LengthStyleValue(length));
}
ValueComparingNonnullRefPtr<StyleValue const> LengthStyleValue::absolutized(ComputationContext const& computation_context, PropertyComputationDependencies&) const
ValueComparingNonnullRefPtr<StyleValue const> LengthStyleValue::absolutized(ComputationContext const& computation_context) const
{
if (auto length = m_length.absolutize(computation_context.length_resolution_context.viewport_rect, computation_context.length_resolution_context.font_metrics, computation_context.length_resolution_context.root_font_metrics); length.has_value())
return LengthStyleValue::create(length.release_value());

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

@ -8,6 +8,7 @@
#include <LibWeb/CSS/StyleValues/CalculatedStyleValue.h>
#include <LibWeb/CSS/StyleValues/IntegerStyleValue.h>
#include <LibWeb/CSS/StyleValues/NumberStyleValue.h>
#include <LibWeb/DOM/Element.h>
namespace Web::CSS {
@ -23,9 +24,9 @@ String TreeCountingFunctionStyleValue::to_string(SerializationMode) const
VERIFY_NOT_REACHED();
}
size_t TreeCountingFunctionStyleValue::resolve(DOM::AbstractElement const& abstract_element, PropertyComputationDependencies& property_computation_dependencies) const
size_t TreeCountingFunctionStyleValue::resolve(DOM::AbstractElement const& abstract_element) const
{
property_computation_dependencies.tree_counting_function = true;
const_cast<DOM::Element&>(abstract_element.element()).set_style_uses_tree_counting_function();
auto tree_counting_function_resolution_context = abstract_element.tree_counting_function_resolution_context();
@ -39,22 +40,20 @@ size_t TreeCountingFunctionStyleValue::resolve(DOM::AbstractElement const& abstr
VERIFY_NOT_REACHED();
}
RefPtr<CalculationNode const> TreeCountingFunctionStyleValue::resolve_to_calculation_node(CalculationContext const& calculation_context, CalculationResolutionContext const& calculation_resolution_context, PropertyComputationDependencies* property_computation_dependencies) const
RefPtr<CalculationNode const> TreeCountingFunctionStyleValue::resolve_to_calculation_node(CalculationContext const& calculation_context, CalculationResolutionContext const& calculation_resolution_context) const
{
if (!calculation_resolution_context.abstract_element.has_value())
return nullptr;
VERIFY(property_computation_dependencies);
return NumericCalculationNode::create(Number { Number::Type::Number, static_cast<double>(resolve(calculation_resolution_context.abstract_element.value(), *property_computation_dependencies)) }, calculation_context);
return NumericCalculationNode::create(Number { Number::Type::Number, static_cast<double>(resolve(calculation_resolution_context.abstract_element.value())) }, calculation_context);
}
ValueComparingNonnullRefPtr<StyleValue const> TreeCountingFunctionStyleValue::absolutized(ComputationContext const& computation_context, PropertyComputationDependencies& property_computation_dependencies) const
ValueComparingNonnullRefPtr<StyleValue const> TreeCountingFunctionStyleValue::absolutized(ComputationContext const& computation_context) const
{
// FIXME: We should clamp this value in case it falls outside the valid range for the context it is in
VERIFY(computation_context.abstract_element.has_value());
size_t value = resolve(computation_context.abstract_element.value(), property_computation_dependencies);
size_t value = resolve(computation_context.abstract_element.value());
switch (m_computed_type) {
case ComputedType::Integer:

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

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