LibWeb: Convert border painting to new pixel units

Author: AtkinsSJ

Userland/Libraries/LibWeb/Painting/BackgroundPainting.cpp

@@ -77,7 +77,7 @@ void paint_background(PaintContext& context, Layout::NodeWithStyleAndBoxModelMet
 
     Gfx::AntiAliasingPainter aa_painter { painter };
     aa_painter.fill_rect_with_rounded_corners(context.rounded_device_rect(color_box.rect).to_type<int>(),
-        background_color, color_box.radii.top_left.as_corner(), color_box.radii.top_right.as_corner(), color_box.radii.bottom_right.as_corner(), color_box.radii.bottom_left.as_corner());
+        background_color, color_box.radii.top_left.as_corner(context), color_box.radii.top_right.as_corner(context), color_box.radii.bottom_right.as_corner(context), color_box.radii.bottom_left.as_corner(context));
 
     if (!has_paintable_layers)
         return;
@@ -114,7 +114,7 @@ void paint_background(PaintContext& context, Layout::NodeWithStyleAndBoxModelMet
         CSSPixelRect const& css_clip_rect = clip_box.rect;
         auto clip_rect = context.rounded_device_rect(css_clip_rect);
         painter.add_clip_rect(clip_rect.to_type<int>());
-        ScopedCornerRadiusClip corner_clip { painter, clip_rect.to_type<int>(), clip_box.radii };
+        ScopedCornerRadiusClip corner_clip { context, painter, clip_rect, clip_box.radii };
 
         if (layer.clip == CSS::BackgroundBox::BorderBox) {
             // Shrink the effective clip rect if to account for the bits the borders will definitely paint over

Userland/Libraries/LibWeb/Painting/BorderPainting.cpp

@@ -13,26 +13,26 @@
 namespace Web::Painting {
 
 struct BorderRadiusData {
-    float horizontal_radius { 0 };
-    float vertical_radius { 0 };
+    CSSPixels horizontal_radius { 0 };
+    CSSPixels vertical_radius { 0 };
 
-    Gfx::AntiAliasingPainter::CornerRadius as_corner() const
+    Gfx::AntiAliasingPainter::CornerRadius as_corner(PaintContext& context) const
     {
         return Gfx::AntiAliasingPainter::CornerRadius {
-            static_cast<int>(horizontal_radius),
-            static_cast<int>(vertical_radius)
+            context.floored_device_pixels(horizontal_radius).value(),
+            context.floored_device_pixels(vertical_radius).value()
         };
     };
 
     inline operator bool() const
     {
-        return static_cast<int>(horizontal_radius) > 0 && static_cast<int>(vertical_radius) > 0;
+        return horizontal_radius > 0 && vertical_radius > 0;
     }
 
-    inline void shrink(float horizontal, float vertical)
+    inline void shrink(CSSPixels horizontal, CSSPixels vertical)
     {
-        horizontal_radius = max(0, horizontal_radius - horizontal);
-        vertical_radius = max(0, vertical_radius - vertical);
+        horizontal_radius = max(CSSPixels(0), horizontal_radius - horizontal);
+        vertical_radius = max(CSSPixels(0), vertical_radius - vertical);
     }
 };
 
@@ -47,7 +47,7 @@ struct BorderRadiiData {
         return top_left || top_right || bottom_right || bottom_left;
     }
 
-    inline void shrink(float top, float right, float bottom, float left)
+    inline void shrink(CSSPixels top, CSSPixels right, CSSPixels bottom, CSSPixels left)
     {
         top_left.shrink(left, top);
         top_right.shrink(right, top);
@@ -56,7 +56,7 @@ struct BorderRadiiData {
     }
 };
 
-BorderRadiiData normalized_border_radii_data(Layout::Node const&, Gfx::FloatRect const&, CSS::BorderRadiusData top_left_radius, CSS::BorderRadiusData top_right_radius, CSS::BorderRadiusData bottom_right_radius, CSS::BorderRadiusData bottom_left_radius);
+BorderRadiiData normalized_border_radii_data(Layout::Node const&, CSSPixelRect const&, CSS::BorderRadiusData top_left_radius, CSS::BorderRadiusData top_right_radius, CSS::BorderRadiusData bottom_right_radius, CSS::BorderRadiusData bottom_left_radius);
 
 enum class BorderEdge {
     Top,
@@ -71,9 +71,9 @@ struct BordersData {
     CSS::BorderData left;
 };
 
-RefPtr<Gfx::Bitmap> get_cached_corner_bitmap(Gfx::IntSize corners_size);
+RefPtr<Gfx::Bitmap> get_cached_corner_bitmap(DevicePixelSize corners_size);
 
-void paint_border(PaintContext& context, BorderEdge edge, Gfx::IntRect const& rect, BorderRadiiData const& border_radii_data, BordersData const& borders_data);
-void paint_all_borders(PaintContext& context, Gfx::FloatRect const& bordered_rect, BorderRadiiData const& border_radii_data, BordersData const&);
+void paint_border(PaintContext& context, BorderEdge edge, DevicePixelRect const& rect, BorderRadiiData const& border_radii_data, BordersData const& borders_data);
+void paint_all_borders(PaintContext& context, CSSPixelRect const& bordered_rect, BorderRadiiData const& border_radii_data, BordersData const&);
 
 }

Userland/Libraries/LibWeb/Painting/BorderPainting.h

@@ -10,16 +10,16 @@
 
 namespace Web::Painting {
 
-ErrorOr<BorderRadiusCornerClipper> BorderRadiusCornerClipper::create(Gfx::IntRect const& border_rect, BorderRadiiData const& border_radii, CornerClip corner_clip, UseCachedBitmap use_cached_bitmap)
+ErrorOr<BorderRadiusCornerClipper> BorderRadiusCornerClipper::create(PaintContext& context, DevicePixelRect const& border_rect, BorderRadiiData const& border_radii, CornerClip corner_clip, UseCachedBitmap use_cached_bitmap)
 {
     VERIFY(border_radii.has_any_radius());
 
-    auto top_left = border_radii.top_left.as_corner();
-    auto top_right = border_radii.top_right.as_corner();
-    auto bottom_right = border_radii.bottom_right.as_corner();
-    auto bottom_left = border_radii.bottom_left.as_corner();
+    auto top_left = border_radii.top_left.as_corner(context);
+    auto top_right = border_radii.top_right.as_corner(context);
+    auto bottom_right = border_radii.bottom_right.as_corner(context);
+    auto bottom_left = border_radii.bottom_left.as_corner(context);
 
-    Gfx::IntSize corners_bitmap_size {
+    DevicePixelSize corners_bitmap_size {
         max(
             top_left.horizontal_radius + top_right.horizontal_radius,
             bottom_left.horizontal_radius + bottom_right.horizontal_radius),
@@ -34,7 +34,7 @@ ErrorOr<BorderRadiusCornerClipper> BorderRadiusCornerClipper::create(Gfx::IntRec
         if (!corner_bitmap)
             return Error::from_errno(ENOMEM);
     } else {
-        corner_bitmap = TRY(Gfx::Bitmap::try_create(Gfx::BitmapFormat::BGRA8888, corners_bitmap_size));
+        corner_bitmap = TRY(Gfx::Bitmap::try_create(Gfx::BitmapFormat::BGRA8888, corners_bitmap_size.to_type<int>()));
     }
 
     CornerData corner_data {
@@ -60,7 +60,7 @@ void BorderRadiusCornerClipper::sample_under_corners(Gfx::Painter& page_painter)
     corner_aa_painter.fill_rect_with_rounded_corners(corner_rect, Color::NamedColor::Black,
         m_data.corner_radii.top_left, m_data.corner_radii.top_right, m_data.corner_radii.bottom_right, m_data.corner_radii.bottom_left);
 
-    auto copy_page_masked = [&](auto const& mask_src, auto const& page_location) {
+    auto copy_page_masked = [&](Gfx::IntRect const& mask_src, Gfx::IntPoint const& page_location) {
         for (int row = 0; row < mask_src.height(); ++row) {
             for (int col = 0; col < mask_src.width(); ++col) {
                 auto corner_location = mask_src.location().translated(col, row);
@@ -81,13 +81,13 @@ void BorderRadiusCornerClipper::sample_under_corners(Gfx::Painter& page_painter)
 
     // Copy the pixels under the corner mask (using the alpha of the mask):
     if (m_data.corner_radii.top_left)
-        copy_page_masked(m_data.corner_radii.top_left.as_rect().translated(m_data.bitmap_locations.top_left), m_data.page_locations.top_left);
+        copy_page_masked(m_data.corner_radii.top_left.as_rect().translated(m_data.bitmap_locations.top_left.to_type<int>()), m_data.page_locations.top_left.to_type<int>());
     if (m_data.corner_radii.top_right)
-        copy_page_masked(m_data.corner_radii.top_right.as_rect().translated(m_data.bitmap_locations.top_right), m_data.page_locations.top_right);
+        copy_page_masked(m_data.corner_radii.top_right.as_rect().translated(m_data.bitmap_locations.top_right.to_type<int>()), m_data.page_locations.top_right.to_type<int>());
     if (m_data.corner_radii.bottom_right)
-        copy_page_masked(m_data.corner_radii.bottom_right.as_rect().translated(m_data.bitmap_locations.bottom_right), m_data.page_locations.bottom_right);
+        copy_page_masked(m_data.corner_radii.bottom_right.as_rect().translated(m_data.bitmap_locations.bottom_right.to_type<int>()), m_data.page_locations.bottom_right.to_type<int>());
     if (m_data.corner_radii.bottom_left)
-        copy_page_masked(m_data.corner_radii.bottom_left.as_rect().translated(m_data.bitmap_locations.bottom_left), m_data.page_locations.bottom_left);
+        copy_page_masked(m_data.corner_radii.bottom_left.as_rect().translated(m_data.bitmap_locations.bottom_left.to_type<int>()), m_data.page_locations.bottom_left.to_type<int>());
 
     m_has_sampled = true;
 }
@@ -98,13 +98,13 @@ void BorderRadiusCornerClipper::blit_corner_clipping(Gfx::Painter& painter)
 
     // Restore the corners:
     if (m_data.corner_radii.top_left)
-        painter.blit(m_data.page_locations.top_left, *m_corner_bitmap, m_data.corner_radii.top_left.as_rect().translated(m_data.bitmap_locations.top_left));
+        painter.blit(m_data.page_locations.top_left.to_type<int>(), *m_corner_bitmap, m_data.corner_radii.top_left.as_rect().translated(m_data.bitmap_locations.top_left.to_type<int>()));
     if (m_data.corner_radii.top_right)
-        painter.blit(m_data.page_locations.top_right, *m_corner_bitmap, m_data.corner_radii.top_right.as_rect().translated(m_data.bitmap_locations.top_right));
+        painter.blit(m_data.page_locations.top_right.to_type<int>(), *m_corner_bitmap, m_data.corner_radii.top_right.as_rect().translated(m_data.bitmap_locations.top_right.to_type<int>()));
     if (m_data.corner_radii.bottom_right)
-        painter.blit(m_data.page_locations.bottom_right, *m_corner_bitmap, m_data.corner_radii.bottom_right.as_rect().translated(m_data.bitmap_locations.bottom_right));
+        painter.blit(m_data.page_locations.bottom_right.to_type<int>(), *m_corner_bitmap, m_data.corner_radii.bottom_right.as_rect().translated(m_data.bitmap_locations.bottom_right.to_type<int>()));
     if (m_data.corner_radii.bottom_left)
-        painter.blit(m_data.page_locations.bottom_left, *m_corner_bitmap, m_data.corner_radii.bottom_left.as_rect().translated(m_data.bitmap_locations.bottom_left));
+        painter.blit(m_data.page_locations.bottom_left.to_type<int>(), *m_corner_bitmap, m_data.corner_radii.bottom_left.as_rect().translated(m_data.bitmap_locations.bottom_left.to_type<int>()));
 }
 
 }

Userland/Libraries/LibWeb/Painting/BorderRadiusCornerClipper.cpp

@@ -23,7 +23,7 @@ class BorderRadiusCornerClipper {
         No
     };
 
-    static ErrorOr<BorderRadiusCornerClipper> create(Gfx::IntRect const& border_rect, BorderRadiiData const& border_radii, CornerClip corner_clip = CornerClip::Outside, UseCachedBitmap use_cached_bitmap = UseCachedBitmap::Yes);
+    static ErrorOr<BorderRadiusCornerClipper> create(PaintContext&, DevicePixelRect const& border_rect, BorderRadiiData const& border_radii, CornerClip corner_clip = CornerClip::Outside, UseCachedBitmap use_cached_bitmap = UseCachedBitmap::Yes);
 
     void sample_under_corners(Gfx::Painter& page_painter);
     void blit_corner_clipping(Gfx::Painter& page_painter);
@@ -38,14 +38,14 @@ class BorderRadiusCornerClipper {
             CornerRadius bottom_left;
         } corner_radii;
         struct CornerLocations {
-            Gfx::IntPoint top_left;
-            Gfx::IntPoint top_right;
-            Gfx::IntPoint bottom_right;
-            Gfx::IntPoint bottom_left;
+            DevicePixelPoint top_left;
+            DevicePixelPoint top_right;
+            DevicePixelPoint bottom_right;
+            DevicePixelPoint bottom_left;
         };
         CornerLocations page_locations;
         CornerLocations bitmap_locations;
-        Gfx::IntSize corner_bitmap_size;
+        DevicePixelSize corner_bitmap_size;
     } m_data;
 
     NonnullRefPtr<Gfx::Bitmap> m_corner_bitmap;
@@ -61,11 +61,11 @@ class BorderRadiusCornerClipper {
 };
 
 struct ScopedCornerRadiusClip {
-    ScopedCornerRadiusClip(Gfx::Painter& painter, Gfx::IntRect const& border_rect, BorderRadiiData const& border_radii, CornerClip corner_clip = CornerClip::Outside, BorderRadiusCornerClipper::UseCachedBitmap use_cached_bitmap = BorderRadiusCornerClipper::UseCachedBitmap::Yes)
+    ScopedCornerRadiusClip(PaintContext& context, Gfx::Painter& painter, DevicePixelRect const& border_rect, BorderRadiiData const& border_radii, CornerClip corner_clip = CornerClip::Outside, BorderRadiusCornerClipper::UseCachedBitmap use_cached_bitmap = BorderRadiusCornerClipper::UseCachedBitmap::Yes)
         : m_painter(painter)
     {
         if (border_radii.has_any_radius()) {
-            auto clipper = BorderRadiusCornerClipper::create(border_rect, border_radii, corner_clip, use_cached_bitmap);
+            auto clipper = BorderRadiusCornerClipper::create(context, border_rect, border_radii, corner_clip, use_cached_bitmap);
             if (!clipper.is_error()) {
                 m_corner_clipper = clipper.release_value();
                 m_corner_clipper->sample_under_corners(m_painter);

Userland/Libraries/LibWeb/Painting/BorderRadiusCornerClipper.h

@@ -31,8 +31,8 @@ void CanvasPaintable::paint(PaintContext& context, PaintPhase phase) const
     PaintableBox::paint(context, phase);
 
     if (phase == PaintPhase::Foreground) {
-        auto canvas_rect = absolute_rect().to_rounded<int>();
-        ScopedCornerRadiusClip corner_clip { context.painter(), canvas_rect, normalized_border_radii_data(ShrinkRadiiForBorders::Yes) };
+        auto canvas_rect = context.rounded_device_rect(absolute_rect().to_type<CSSPixels>());
+        ScopedCornerRadiusClip corner_clip { context, context.painter(), canvas_rect, normalized_border_radii_data(ShrinkRadiiForBorders::Yes) };
 
         // FIXME: This should be done at a different level.
         if (is_out_of_view(context))
@@ -41,7 +41,7 @@ void CanvasPaintable::paint(PaintContext& context, PaintPhase phase) const
         if (layout_box().dom_node().bitmap()) {
             // FIXME: Remove this const_cast.
             const_cast<HTML::HTMLCanvasElement&>(layout_box().dom_node()).present();
-            context.painter().draw_scaled_bitmap(canvas_rect, *layout_box().dom_node().bitmap(), layout_box().dom_node().bitmap()->rect(), 1.0f, to_gfx_scaling_mode(computed_values().image_rendering()));
+            context.painter().draw_scaled_bitmap(canvas_rect.to_type<int>(), *layout_box().dom_node().bitmap(), layout_box().dom_node().bitmap()->rect(), 1.0f, to_gfx_scaling_mode(computed_values().image_rendering()));
         }
     }
 }

Userland/Libraries/LibWeb/Painting/CanvasPaintable.cpp

@@ -125,7 +125,7 @@ void apply_backdrop_filter(PaintContext& context, Layout::Node const& node, Gfx:
     // FIXME: 3. If element B has any transforms (between B and the Backdrop Root), apply the inverse of those transforms to the contents of T’.
 
     // 4. Apply a clip to the contents of T’, using the border box of element B, including border-radius if specified. Note that the children of B are not considered for the sizing or location of this clip.
-    ScopedCornerRadiusClip corner_clipper { context.painter(), backdrop_region, border_radii_data };
+    ScopedCornerRadiusClip corner_clipper { context, context.painter(), backdrop_region.to_type<DevicePixels>(), border_radii_data };
 
     // FIXME: 5. Draw all of element B, including its background, border, and any children elements, into T’.
 

Userland/Libraries/LibWeb/Painting/FilterPainting.cpp

@@ -49,9 +49,9 @@ void ImagePaintable::paint(PaintContext& context, PaintPhase phase) const
                 alt = image_element.src();
             context.painter().draw_text(enclosing_int_rect(absolute_rect()), alt, Gfx::TextAlignment::Center, computed_values().color(), Gfx::TextElision::Right);
         } else if (auto bitmap = layout_box().image_loader().bitmap(layout_box().image_loader().current_frame_index())) {
-            auto image_rect = absolute_rect().to_rounded<int>();
-            ScopedCornerRadiusClip corner_clip { context.painter(), image_rect, normalized_border_radii_data(ShrinkRadiiForBorders::Yes) };
-            context.painter().draw_scaled_bitmap(image_rect, *bitmap, bitmap->rect(), 1.0f, to_gfx_scaling_mode(computed_values().image_rendering()));
+            auto image_rect = context.rounded_device_rect(absolute_rect().to_type<CSSPixels>());
+            ScopedCornerRadiusClip corner_clip { context, context.painter(), image_rect, normalized_border_radii_data(ShrinkRadiiForBorders::Yes) };
+            context.painter().draw_scaled_bitmap(image_rect.to_type<int>(), *bitmap, bitmap->rect(), 1.0f, to_gfx_scaling_mode(computed_values().image_rendering()));
         }
     }
 }

Userland/Libraries/LibWeb/Painting/ImagePaintable.cpp

@@ -54,7 +54,7 @@ void InlinePaintable::paint(PaintContext& context, Painting::PaintPhase phase) c
                 absolute_fragment_rect.set_width(absolute_fragment_rect.width() + extra_end_width);
             }
 
-            auto border_radii_data = Painting::normalized_border_radii_data(layout_node(), absolute_fragment_rect, top_left_border_radius, top_right_border_radius, bottom_right_border_radius, bottom_left_border_radius);
+            auto border_radii_data = Painting::normalized_border_radii_data(layout_node(), absolute_fragment_rect.to_type<CSSPixels>(), top_left_border_radius, top_right_border_radius, bottom_right_border_radius, bottom_left_border_radius);
             Painting::paint_background(context, layout_node(), absolute_fragment_rect.to_type<CSSPixels>(), computed_values().background_color(), computed_values().image_rendering(), &computed_values().background_layers(), border_radii_data);
 
             if (auto computed_box_shadow = computed_values().box_shadow(); !computed_box_shadow.is_empty()) {
@@ -92,7 +92,7 @@ void InlinePaintable::paint(PaintContext& context, Painting::PaintPhase phase) c
         auto containing_block_position_in_absolute_coordinates = containing_block()->paint_box()->absolute_position();
 
         for_each_fragment([&](auto const& fragment, bool is_first_fragment, bool is_last_fragment) {
-            Gfx::FloatRect absolute_fragment_rect { containing_block_position_in_absolute_coordinates.translated(fragment.offset()), fragment.size() };
+            CSSPixelRect absolute_fragment_rect { containing_block_position_in_absolute_coordinates.translated(fragment.offset()), fragment.size() };
 
             if (is_first_fragment) {
                 float extra_start_width = box_model().padding.left;

Userland/Libraries/LibWeb/Painting/InlinePaintable.cpp

@@ -36,8 +36,8 @@ void NestedBrowsingContextPaintable::paint(PaintContext& context, PaintPhase pha
     PaintableBox::paint(context, phase);
 
     if (phase == PaintPhase::Foreground) {
-        auto clip_rect = absolute_rect().to_rounded<int>();
-        ScopedCornerRadiusClip corner_clip { context.painter(), clip_rect, normalized_border_radii_data(ShrinkRadiiForBorders::Yes) };
+        auto clip_rect = context.rounded_device_rect(absolute_rect().to_type<CSSPixels>());
+        ScopedCornerRadiusClip corner_clip { context, context.painter(), clip_rect, normalized_border_radii_data(ShrinkRadiiForBorders::Yes) };
 
         auto* hosted_document = layout_box().dom_node().content_document_without_origin_check();
         if (!hosted_document)
@@ -49,7 +49,7 @@ void NestedBrowsingContextPaintable::paint(PaintContext& context, PaintPhase pha
         context.painter().save();
         auto old_viewport_rect = context.device_viewport_rect();
 
-        context.painter().add_clip_rect(clip_rect);
+        context.painter().add_clip_rect(clip_rect.to_type<int>());
         context.painter().translate(absolute_x(), absolute_y());
 
         context.set_device_viewport_rect({ {}, layout_box().dom_node().nested_browsing_context()->size() });