RGBCube/serenity
1
Fork 0
mirror of https://github.com/RGBCube/serenity synced 2025-07-26 08:47:34 +00:00
Code Issues Activity Actions

LibWeb: Stop handling impossible Percentage return values

Browse source 
When a `calc()` is resolved, it can only return a Percentage value if
the requested type is Percentage. In all other cases, it returns a
concrete value.

eg, a `calc()` with Lengths and Percentages in will always resolve to a
Length, never a Percentage. This means we can just return Length
directly instead of LengthPercentage, which simplifies things in a few
places.
This commit is contained in:
Sam Atkins 2022-07-20 13:03:30 +01:00 • committed by Andreas Kling
parent cf6e49350e
commit 93c999ce00
3 changed files with 23 additions and 35 deletions
Download patch file Download diff file Expand all files Collapse all files

14
Userland/Libraries/LibWeb/CSS/Percentage.cpp
View file

@ -9,24 +9,24 @@
namespace Web::CSS { namespace Web::CSS {
Angle AnglePercentage::resolve_calculated(NonnullRefPtr<CalculatedStyleValue> const& calculated, Layout::Node const& layout_node, Angle const& reference_value) const Angle AnglePercentage::resolve_calculated(NonnullRefPtr<CalculatedStyleValue> const& calculated, Layout::Node const&, Angle const& reference_value) const
{ {
return calculated->resolve_angle_percentage(reference_value)->resolved(layout_node, reference_value); return calculated->resolve_angle_percentage(reference_value).value();
} }
Frequency FrequencyPercentage::resolve_calculated(NonnullRefPtr<CalculatedStyleValue> const& calculated, Layout::Node const& layout_node, Frequency const& reference_value) const Frequency FrequencyPercentage::resolve_calculated(NonnullRefPtr<CalculatedStyleValue> const& calculated, Layout::Node const&, Frequency const& reference_value) const
{ {
return calculated->resolve_frequency_percentage(reference_value)->resolved(layout_node, reference_value); return calculated->resolve_frequency_percentage(reference_value).value();
} }
Length LengthPercentage::resolve_calculated(NonnullRefPtr<CalculatedStyleValue> const& calculated, Layout::Node const& layout_node, Length const& reference_value) const Length LengthPercentage::resolve_calculated(NonnullRefPtr<CalculatedStyleValue> const& calculated, Layout::Node const& layout_node, Length const& reference_value) const
{ {
return calculated->resolve_length_percentage(layout_node, reference_value)->resolved(layout_node, reference_value); return calculated->resolve_length_percentage(layout_node, reference_value).value();
} }
Time TimePercentage::resolve_calculated(NonnullRefPtr<CalculatedStyleValue> const& calculated, Layout::Node const& layout_node, Time const& reference_value) const Time TimePercentage::resolve_calculated(NonnullRefPtr<CalculatedStyleValue> const& calculated, Layout::Node const&, Time const& reference_value) const
{ {
return calculated->resolve_time_percentage(reference_value)->resolved(layout_node, reference_value); return calculated->resolve_time_percentage(reference_value).value();
} }
} }

36
Userland/Libraries/LibWeb/CSS/StyleValue.cpp
View file

@ -661,18 +661,15 @@ Optional<Angle> CalculatedStyleValue::resolve_angle() const
return {}; return {};
} }
Optional<AnglePercentage> CalculatedStyleValue::resolve_angle_percentage(Angle const& percentage_basis) const Optional<Angle> CalculatedStyleValue::resolve_angle_percentage(Angle const& percentage_basis) const
{ {
auto result = m_expression->resolve(nullptr, percentage_basis); auto result = m_expression->resolve(nullptr, percentage_basis);
return result.value().visit( return result.value().visit(
[&](Angle const& angle) -> Optional<AnglePercentage> { [&](Angle const& angle) -> Optional<Angle> {
return angle; return angle;
}, },
[&](Percentage const& percentage) -> Optional<AnglePercentage> { [&](auto const&) -> Optional<Angle> {
return percentage;
},
[&](auto const&) -> Optional<AnglePercentage> {
return {}; return {};
}); });
} }
@ -686,18 +683,15 @@ Optional<Frequency> CalculatedStyleValue::resolve_frequency() const
return {}; return {};
} }
Optional<FrequencyPercentage> CalculatedStyleValue::resolve_frequency_percentage(Frequency const& percentage_basis) const Optional<Frequency> CalculatedStyleValue::resolve_frequency_percentage(Frequency const& percentage_basis) const
{ {
auto result = m_expression->resolve(nullptr, percentage_basis); auto result = m_expression->resolve(nullptr, percentage_basis);
return result.value().visit( return result.value().visit(
[&](Frequency const& frequency) -> Optional<FrequencyPercentage> { [&](Frequency const& frequency) -> Optional<Frequency> {
return frequency; return frequency;
}, },
[&](Percentage const& percentage) -> Optional<FrequencyPercentage> { [&](auto const&) -> Optional<Frequency> {
return percentage;
},
[&](auto const&) -> Optional<FrequencyPercentage> {
return {}; return {};
}); });
} }
@ -711,18 +705,15 @@ Optional<Length> CalculatedStyleValue::resolve_length(Layout::Node const& layout
return {}; return {};
} }
Optional<LengthPercentage> CalculatedStyleValue::resolve_length_percentage(Layout::Node const& layout_node, Length const& percentage_basis) const Optional<Length> CalculatedStyleValue::resolve_length_percentage(Layout::Node const& layout_node, Length const& percentage_basis) const
{ {
auto result = m_expression->resolve(&layout_node, percentage_basis); auto result = m_expression->resolve(&layout_node, percentage_basis);
return result.value().visit( return result.value().visit(
[&](Length const& length) -> Optional<LengthPercentage> { [&](Length const& length) -> Optional<Length> {
return length; return length;
}, },
[&](Percentage const& percentage) -> Optional<LengthPercentage> { [&](auto const&) -> Optional<Length> {
return percentage;
},
[&](auto const&) -> Optional<LengthPercentage> {
return {}; return {};
}); });
} }
@ -744,18 +735,15 @@ Optional<Time> CalculatedStyleValue::resolve_time() const
return {}; return {};
} }
Optional<TimePercentage> CalculatedStyleValue::resolve_time_percentage(Time const& percentage_basis) const Optional<Time> CalculatedStyleValue::resolve_time_percentage(Time const& percentage_basis) const
{ {
auto result = m_expression->resolve(nullptr, percentage_basis); auto result = m_expression->resolve(nullptr, percentage_basis);
return result.value().visit( return result.value().visit(
[&](Time const& time) -> Optional<TimePercentage> { [&](Time const& time) -> Optional<Time> {
return time; return time;
}, },
[&](Percentage const& percentage) -> Optional<TimePercentage> { [&](auto const&) -> Optional<Time> {
return percentage;
},
[&](auto const&) -> Optional<TimePercentage> {
return {}; return {};
}); });
} }

8
Userland/Libraries/LibWeb/CSS/StyleValue.h
View file

@ -677,14 +677,14 @@ public:
NonnullOwnPtr<CalcSum> const& expression() const { return m_expression; } NonnullOwnPtr<CalcSum> const& expression() const { return m_expression; }
Optional<Angle> resolve_angle() const; Optional<Angle> resolve_angle() const;
Optional<AnglePercentage> resolve_angle_percentage(Angle const& percentage_basis) const; Optional<Angle> resolve_angle_percentage(Angle const& percentage_basis) const;
Optional<Frequency> resolve_frequency() const; Optional<Frequency> resolve_frequency() const;
Optional<FrequencyPercentage> resolve_frequency_percentage(Frequency const& percentage_basis) const; Optional<Frequency> resolve_frequency_percentage(Frequency const& percentage_basis) const;
Optional<Length> resolve_length(Layout::Node const& layout_node) const; Optional<Length> resolve_length(Layout::Node const& layout_node) const;
Optional<LengthPercentage> resolve_length_percentage(Layout::Node const&, Length const& percentage_basis) const; Optional<Length> resolve_length_percentage(Layout::Node const&, Length const& percentage_basis) const;
Optional<Percentage> resolve_percentage() const; Optional<Percentage> resolve_percentage() const;
Optional<Time> resolve_time() const; Optional<Time> resolve_time() const;
Optional<TimePercentage> resolve_time_percentage(Time const& percentage_basis) const; Optional<Time> resolve_time_percentage(Time const& percentage_basis) const;
Optional<float> resolve_number(); Optional<float> resolve_number();
Optional<i64> resolve_integer(); Optional<i64> resolve_integer();