LibWeb: Return CSSPixels from `calculate_inner_height()`

Similar to calculate_inner_width(), let's make the caller responsible
for handling "auto" instead of returning the input height as is when
when it cannot be resolved.

Userland/Libraries/LibWeb/Layout/BlockFormattingContext.cpp

@@ -464,17 +464,18 @@ void BlockFormattingContext::compute_height(Box const& box, AvailableSpace const
         if (should_treat_height_as_auto(box, available_space)) {
             height = compute_auto_height_for_block_level_element(box, m_state.get(box).available_inner_space_or_constraints_from(available_space));
         } else {
-            height = calculate_inner_height(box, available_space.height, computed_values.height()).to_px(box);
+            height = calculate_inner_height(box, available_space.height, computed_values.height());
         }
     }
 
     if (!should_treat_max_height_as_none(box, available_space.height)) {
-        auto max_height = calculate_inner_height(box, available_space.height, computed_values.max_height());
-        if (!max_height.is_auto())
-            height = min(height, max_height.to_px(box));
+        if (!computed_values.max_height().is_auto()) {
+            auto max_height = calculate_inner_height(box, available_space.height, computed_values.max_height());
+            height = min(height, max_height);
+        }
     }
     if (!computed_values.min_height().is_auto()) {
-        height = max(height, calculate_inner_height(box, available_space.height, computed_values.min_height()).to_px(box));
+        height = max(height, calculate_inner_height(box, available_space.height, computed_values.min_height()));
     }
 
     if (box.document().in_quirks_mode()

Userland/Libraries/LibWeb/Layout/FlexFormattingContext.cpp

@@ -34,7 +34,7 @@ CSSPixels FlexFormattingContext::get_pixel_width(Box const& box, CSS::Size const
 
 CSSPixels FlexFormattingContext::get_pixel_height(Box const& box, CSS::Size const& size) const
 {
-    return calculate_inner_height(box, containing_block_height_as_available_size(box), size).to_px(box);
+    return calculate_inner_height(box, containing_block_height_as_available_size(box), size);
 }
 
 FlexFormattingContext::FlexFormattingContext(LayoutState& state, Box const& flex_container, FormattingContext* parent)

Userland/Libraries/LibWeb/Layout/FormattingContext.cpp

@@ -515,7 +515,7 @@ CSSPixels FormattingContext::tentative_height_for_replaced_element(Box const& bo
         return 150;
 
     // FIXME: Handle cases when available_space is not definite.
-    return calculate_inner_height(box, available_space.height, computed_height).to_px(box);
+    return calculate_inner_height(box, available_space.height, computed_height);
 }
 
 CSSPixels FormattingContext::compute_height_for_replaced_element(Box const& box, AvailableSpace const& available_space) const
@@ -837,11 +837,11 @@ void FormattingContext::compute_height_for_absolutely_positioned_non_replaced_el
         auto constrained_height = unconstrained_height;
         if (!computed_max_height.is_none()) {
             auto inner_max_height = calculate_inner_height(box, available_space.height, computed_max_height);
-            constrained_height = min(constrained_height, inner_max_height.to_px(box));
+            constrained_height = min(constrained_height, inner_max_height);
         }
         if (!computed_min_height.is_auto()) {
             auto inner_min_height = calculate_inner_height(box, available_space.height, computed_min_height);
-            constrained_height = max(constrained_height, inner_min_height.to_px(box));
+            constrained_height = max(constrained_height, inner_min_height);
         }
         return constrained_height;
     };
@@ -1022,7 +1022,7 @@ void FormattingContext::compute_height_for_absolutely_positioned_non_replaced_el
     if (should_treat_height_as_auto(box, available_space)) {
         used_height = height.to_px(box, height_of_containing_block);
     } else {
-        used_height = calculate_inner_height(box, available_space.height, height).to_px(box);
+        used_height = calculate_inner_height(box, available_space.height, height);
     }
 
     used_height = apply_min_max_height_constraints(used_height);
@@ -1494,8 +1494,10 @@ CSSPixels FormattingContext::calculate_inner_width(Layout::Box const& box, Avail
     return width.resolved(box, width_of_containing_block).to_px(box);
 }
 
-CSS::Length FormattingContext::calculate_inner_height(Layout::Box const& box, AvailableSize const&, CSS::Size const& height) const
+CSSPixels FormattingContext::calculate_inner_height(Layout::Box const& box, AvailableSize const&, CSS::Size const& height) const
 {
+    VERIFY(!height.is_auto());
+
     auto const* containing_block = box.non_anonymous_containing_block();
     auto const& containing_block_state = m_state.get(*containing_block);
     auto height_of_containing_block = containing_block_state.content_height();
@@ -1504,9 +1506,6 @@ CSS::Length FormattingContext::calculate_inner_height(Layout::Box const& box, Av
         // If the box has position: absolute, then the containing block is formed by the padding edge of the ancestor
         height_of_containing_block += containing_block_state.padding_top + containing_block_state.padding_bottom;
     }
-    if (height.is_auto()) {
-        return height.resolved(box, height_of_containing_block);
-    }
 
     auto& computed_values = box.computed_values();
     if (computed_values.box_sizing() == CSS::BoxSizing::BorderBox) {
@@ -1520,10 +1519,10 @@ CSS::Length FormattingContext::calculate_inner_height(Layout::Box const& box, Av
             - padding_top.to_px(box)
             - computed_values.border_bottom().width
             - padding_bottom.to_px(box);
-        return CSS::Length::make_px(max(inner_height, 0));
+        return max(inner_height, 0);
     }
 
-    return height.resolved(box, height_of_containing_block);
+    return height.resolved(box, height_of_containing_block).to_px(box);
 }
 
 CSSPixels FormattingContext::containing_block_width_for(NodeWithStyleAndBoxModelMetrics const& node) const

Userland/Libraries/LibWeb/Layout/FormattingContext.h

@@ -66,7 +66,7 @@ public:
     CSSPixels calculate_fit_content_width(Layout::Box const&, AvailableSpace const&) const;
 
     CSSPixels calculate_inner_width(Layout::Box const&, AvailableSize const&, CSS::Size const& width) const;
-    CSS::Length calculate_inner_height(Layout::Box const&, AvailableSize const&, CSS::Size const& height) const;
+    CSSPixels calculate_inner_height(Layout::Box const&, AvailableSize const&, CSS::Size const& height) const;
 
     virtual CSSPixels greatest_child_width(Box const&) const;
 

Userland/Libraries/LibWeb/Layout/GridFormattingContext.cpp

@@ -1991,7 +1991,9 @@ void GridFormattingContext::run(Box const&, LayoutMode, AvailableSpace const& av
     auto const& containing_block_state = m_state.get(*grid_container().containing_block());
     auto height_of_containing_block = containing_block_state.content_height();
     auto height_of_container_block_as_available_size = AvailableSize::make_definite(height_of_containing_block);
-    auto min_height = calculate_inner_height(grid_container(), height_of_container_block_as_available_size, grid_computed_values.min_height()).to_px(grid_container());
+    CSSPixels min_height = 0;
+    if (!grid_computed_values.min_height().is_auto())
+        min_height = calculate_inner_height(grid_container(), height_of_container_block_as_available_size, grid_computed_values.min_height());
 
     // If automatic grid container height is less than min-height, we need to re-run the track sizing algorithm
     if (m_automatic_content_height < min_height) {
@@ -2331,7 +2333,7 @@ CSSPixels GridFormattingContext::calculate_grid_container_maximum_size(GridDimen
     auto const& computed_values = grid_container().computed_values();
     if (dimension == GridDimension::Column)
         return calculate_inner_width(grid_container(), m_available_space->width, computed_values.max_width());
-    return calculate_inner_height(grid_container(), m_available_space->height, computed_values.max_height()).to_px(grid_container());
+    return calculate_inner_height(grid_container(), m_available_space->height, computed_values.max_height());
 }
 
 CSS::Size const& GridFormattingContext::get_item_preferred_size(GridItem const& item, GridDimension const dimension) const

Userland/Libraries/LibWeb/Layout/InlineFormattingContext.cpp

@@ -180,7 +180,7 @@ void InlineFormattingContext::dimension_box_on_line(Box const& box, LayoutMode l
         parent().compute_height(box, AvailableSpace(AvailableSize::make_indefinite(), AvailableSize::make_indefinite()));
     } else {
         auto inner_height = calculate_inner_height(box, AvailableSize::make_definite(m_containing_block_state.content_height()), height_value);
-        box_state.set_content_height(inner_height.to_px(box));
+        box_state.set_content_height(inner_height);
     }
 
     if (independent_formatting_context)