From 93c999ce00c7ce44cdd3090e1774d00f4a184612 Mon Sep 17 00:00:00 2001
From: Sam Atkins <atkinssj@serenityos.org>
Date: Wed, 20 Jul 2022 13:03:30 +0100
Subject: [PATCH] LibWeb: Stop handling impossible Percentage return values

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.
---
 Userland/Libraries/LibWeb/CSS/Percentage.cpp | 14 ++++----
 Userland/Libraries/LibWeb/CSS/StyleValue.cpp | 36 +++++++-------------
 Userland/Libraries/LibWeb/CSS/StyleValue.h   |  8 ++---
 3 files changed, 23 insertions(+), 35 deletions(-)

diff --git a/Userland/Libraries/LibWeb/CSS/Percentage.cpp b/Userland/Libraries/LibWeb/CSS/Percentage.cpp
index e6867bf95e..473e04be8f 100644
--- a/Userland/Libraries/LibWeb/CSS/Percentage.cpp
+++ b/Userland/Libraries/LibWeb/CSS/Percentage.cpp
@@ -9,24 +9,24 @@
 
 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
 {
-    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();
 }
 
 }
diff --git a/Userland/Libraries/LibWeb/CSS/StyleValue.cpp b/Userland/Libraries/LibWeb/CSS/StyleValue.cpp
index e049dbd65f..5cc9cca591 100644
--- a/Userland/Libraries/LibWeb/CSS/StyleValue.cpp
+++ b/Userland/Libraries/LibWeb/CSS/StyleValue.cpp
@@ -661,18 +661,15 @@ Optional<Angle> CalculatedStyleValue::resolve_angle() const
     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);
 
     return result.value().visit(
-        [&](Angle const& angle) -> Optional<AnglePercentage> {
+        [&](Angle const& angle) -> Optional<Angle> {
             return angle;
         },
-        [&](Percentage const& percentage) -> Optional<AnglePercentage> {
-            return percentage;
-        },
-        [&](auto const&) -> Optional<AnglePercentage> {
+        [&](auto const&) -> Optional<Angle> {
             return {};
         });
 }
@@ -686,18 +683,15 @@ Optional<Frequency> CalculatedStyleValue::resolve_frequency() const
     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);
 
     return result.value().visit(
-        [&](Frequency const& frequency) -> Optional<FrequencyPercentage> {
+        [&](Frequency const& frequency) -> Optional<Frequency> {
             return frequency;
         },
-        [&](Percentage const& percentage) -> Optional<FrequencyPercentage> {
-            return percentage;
-        },
-        [&](auto const&) -> Optional<FrequencyPercentage> {
+        [&](auto const&) -> Optional<Frequency> {
             return {};
         });
 }
@@ -711,18 +705,15 @@ Optional<Length> CalculatedStyleValue::resolve_length(Layout::Node const& layout
     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);
 
     return result.value().visit(
-        [&](Length const& length) -> Optional<LengthPercentage> {
+        [&](Length const& length) -> Optional<Length> {
             return length;
         },
-        [&](Percentage const& percentage) -> Optional<LengthPercentage> {
-            return percentage;
-        },
-        [&](auto const&) -> Optional<LengthPercentage> {
+        [&](auto const&) -> Optional<Length> {
             return {};
         });
 }
@@ -744,18 +735,15 @@ Optional<Time> CalculatedStyleValue::resolve_time() const
     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);
 
     return result.value().visit(
-        [&](Time const& time) -> Optional<TimePercentage> {
+        [&](Time const& time) -> Optional<Time> {
             return time;
         },
-        [&](Percentage const& percentage) -> Optional<TimePercentage> {
-            return percentage;
-        },
-        [&](auto const&) -> Optional<TimePercentage> {
+        [&](auto const&) -> Optional<Time> {
             return {};
         });
 }
diff --git a/Userland/Libraries/LibWeb/CSS/StyleValue.h b/Userland/Libraries/LibWeb/CSS/StyleValue.h
index 2d2b90390e..a439dabe49 100644
--- a/Userland/Libraries/LibWeb/CSS/StyleValue.h
+++ b/Userland/Libraries/LibWeb/CSS/StyleValue.h
@@ -677,14 +677,14 @@ public:
     NonnullOwnPtr<CalcSum> const& expression() const { return m_expression; }
 
     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<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<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<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<i64> resolve_integer();