Change BoxModelObjectPainter to not store flow size

Refactor BoxPainterBase and BoxModelObjectPainter to supply flowbox size
as parameter to PaintFillLayer instead of storing it as a private field.

This will in turn help with code re-use between InlineFlowBoxPainter and
the LayoutNG equivalent.

Bug: 714962
Cq-Include-Trybots: master.tryserver.blink:linux_trusty_blink_rel;master.tryserver.chromium.linux:linux_layout_tests_slimming_paint_v2
Change-Id: I342c51c87eb253e2d6420f2b11440b77c564f67d
Reviewed-on: https://chromium-review.googlesource.com/1054133Reviewed-by: Aleks Totic <atotic@chromium.org>
Commit-Queue: Emil A Eklund <eae@chromium.org>
Cr-Commit-Position: refs/heads/master@{#557738}

third_party/blink/renderer/core/paint/box_model_object_painter.cc

@@ -49,8 +49,7 @@ LayoutSize LogicalOffsetOnLine(const InlineFlowBox& flow_box) {
 }  // anonymous namespace
 
 BoxModelObjectPainter::BoxModelObjectPainter(const LayoutBoxModelObject& box,
-                                             const InlineFlowBox* flow_box,
-                                             const LayoutSize& flow_box_size)
+                                             const InlineFlowBox* flow_box)
     : BoxPainterBase(box,
                      &box.GetDocument(),
                      box.StyleRef(),
@@ -59,8 +58,7 @@ BoxModelObjectPainter::BoxModelObjectPainter(const LayoutBoxModelObject& box,
                      box.PaddingOutsets(),
                      box.Layer()),
       box_model_(box),
-      flow_box_(flow_box),
-      flow_box_size_(flow_box_size) {}
+      flow_box_(flow_box) {}
 
 bool BoxModelObjectPainter::
     IsPaintingBackgroundOfPaintContainerIntoScrollingContentsLayer(
@@ -98,14 +96,16 @@ void BoxModelObjectPainter::PaintTextClipMask(GraphicsContext& context,
 
 FloatRoundedRect BoxModelObjectPainter::GetBackgroundRoundedRect(
     const LayoutRect& border_rect,
+    const LayoutSize& flow_box_size,
     bool include_logical_left_edge,
     bool include_logical_right_edge) const {
   FloatRoundedRect border = BoxPainterBase::GetBackgroundRoundedRect(
-      border_rect, include_logical_left_edge, include_logical_right_edge);
+      border_rect, flow_box_size, include_logical_left_edge,
+      include_logical_right_edge);
   if (flow_box_ && (flow_box_->NextForSameLayoutObject() ||
                     flow_box_->PrevForSameLayoutObject())) {
     FloatRoundedRect segment_border = box_model_.StyleRef().GetRoundedBorderFor(
-        LayoutRect(LayoutPoint(), LayoutSize(FlooredIntSize(flow_box_size_))),
+        LayoutRect(LayoutPoint(), LayoutSize(FlooredIntSize(flow_box_size))),
         include_logical_left_edge, include_logical_right_edge);
     border.SetRadii(segment_border.GetRadii());
   }

third_party/blink/renderer/core/paint/box_model_object_painter.h

@@ -25,8 +25,7 @@ class BoxModelObjectPainter : public BoxPainterBase {
 
  public:
   BoxModelObjectPainter(const LayoutBoxModelObject&,
-                        const InlineFlowBox* = nullptr,
-                        const LayoutSize& flow_box_size = LayoutSize());
+                        const InlineFlowBox* = nullptr);
 
   static bool IsPaintingBackgroundOfPaintContainerIntoScrollingContentsLayer(
       const LayoutBoxModelObject*,
@@ -45,14 +44,14 @@ class BoxModelObjectPainter : public BoxPainterBase {
                                       const BoxPainterBase::FillLayerInfo&,
                                       const LayoutRect&) override;
   FloatRoundedRect GetBackgroundRoundedRect(
-      const LayoutRect&,
+      const LayoutRect& border_rect,
+      const LayoutSize& flow_box_size,
       bool include_logical_left_edge,
       bool include_logical_right_edge) const override;
 
  private:
   const LayoutBoxModelObject& box_model_;
   const InlineFlowBox* flow_box_;
-  const LayoutSize flow_box_size_;
 };
 
 }  // namespace blink

third_party/blink/renderer/core/paint/box_painter_base.cc

@@ -271,6 +271,7 @@ bool BoxPainterBase::CalculateFillLayerOcclusionCulling(
 
 FloatRoundedRect BoxPainterBase::BackgroundRoundedRectAdjustedForBleedAvoidance(
     const LayoutRect& border_rect,
+    const LayoutSize& flow_box_size,
     BackgroundBleedAvoidance bleed_avoidance,
     bool include_logical_left_edge,
     bool include_logical_right_edge) const {
@@ -304,7 +305,8 @@ FloatRoundedRect BoxPainterBase::BackgroundRoundedRectAdjustedForBleedAvoidance(
             edges[static_cast<unsigned>(BoxSide::kLeft)].Width());
 
     FloatRoundedRect background_rounded_rect = GetBackgroundRoundedRect(
-        border_rect, include_logical_left_edge, include_logical_right_edge);
+        border_rect, flow_box_size, include_logical_left_edge,
+        include_logical_right_edge);
     FloatRect inset_rect(background_rounded_rect.Rect());
     inset_rect.Expand(insets);
     FloatRoundedRect::Radii inset_radii(background_rounded_rect.GetRadii());
@@ -313,7 +315,8 @@ FloatRoundedRect BoxPainterBase::BackgroundRoundedRectAdjustedForBleedAvoidance(
     return FloatRoundedRect(inset_rect, inset_radii);
   }
 
-  return GetBackgroundRoundedRect(border_rect, include_logical_left_edge,
+  return GetBackgroundRoundedRect(border_rect, flow_box_size,
+                                  include_logical_left_edge,
                                   include_logical_right_edge);
 }
 
@@ -513,6 +516,7 @@ LayoutRectOutsets BoxPainterBase::PaddingOutsets(
 
 FloatRoundedRect BoxPainterBase::GetBackgroundRoundedRect(
     const LayoutRect& border_rect,
+    const LayoutSize& flow_box_size,
     bool include_logical_left_edge,
     bool include_logical_right_edge) const {
   return style_.GetRoundedBorderFor(border_rect, include_logical_left_edge,
@@ -525,7 +529,8 @@ void BoxPainterBase::PaintFillLayer(const PaintInfo& paint_info,
                                     const LayoutRect& rect,
                                     BackgroundBleedAvoidance bleed_avoidance,
                                     BackgroundImageGeometry& geometry,
-                                    SkBlendMode op) {
+                                    SkBlendMode op,
+                                    const LayoutSize flow_box_size) {
   GraphicsContext& context = paint_info.context;
   if (rect.IsEmpty())
     return;
@@ -563,8 +568,9 @@ void BoxPainterBase::PaintFillLayer(const PaintInfo& paint_info,
   }
 
   LayoutRectOutsets border_padding_insets = -(border_ + padding_);
-  FloatRoundedRect border_rect = RoundedBorderRectForClip(
-      info, bg_layer, rect, bleed_avoidance, border_padding_insets);
+  FloatRoundedRect border_rect =
+      RoundedBorderRectForClip(info, bg_layer, rect, flow_box_size,
+                               bleed_avoidance, border_padding_insets);
 
   // Fast path for drawing simple color backgrounds.
   if (PaintFastBottomLayer(display_item_, node_, paint_info, info, rect,
@@ -650,18 +656,19 @@ FloatRoundedRect BoxPainterBase::RoundedBorderRectForClip(
     const BoxPainterBase::FillLayerInfo& info,
     const FillLayer& bg_layer,
     const LayoutRect& rect,
+    const LayoutSize& flow_box_size,
     BackgroundBleedAvoidance bleed_avoidance,
     LayoutRectOutsets border_padding_insets) const {
   if (!info.is_rounded_fill)
     return FloatRoundedRect();
 
   FloatRoundedRect border =
-      info.is_border_fill
-          ? BackgroundRoundedRectAdjustedForBleedAvoidance(
-                rect, bleed_avoidance, info.include_left_edge,
-                info.include_right_edge)
-          : GetBackgroundRoundedRect(rect, info.include_left_edge,
-                                     info.include_right_edge);
+      info.is_border_fill ? BackgroundRoundedRectAdjustedForBleedAvoidance(
+                                rect, flow_box_size, bleed_avoidance,
+                                info.include_left_edge, info.include_right_edge)
+                          : GetBackgroundRoundedRect(rect, flow_box_size,
+                                                     info.include_left_edge,
+                                                     info.include_right_edge);
 
   // Clip to the padding or content boxes as necessary.
   if (bg_layer.Clip() == EFillBox::kContent) {

third_party/blink/renderer/core/paint/box_painter_base.h

@@ -5,6 +5,7 @@
 #ifndef THIRD_PARTY_BLINK_RENDERER_CORE_PAINT_BOX_PAINTER_BASE_H_
 #define THIRD_PARTY_BLINK_RENDERER_CORE_PAINT_BOX_PAINTER_BASE_H_
 
+#include "base/optional.h"
 #include "third_party/blink/renderer/core/layout/background_bleed_avoidance.h"
 #include "third_party/blink/renderer/core/style/style_image.h"
 #include "third_party/blink/renderer/platform/geometry/layout_rect_outsets.h"
@@ -62,7 +63,8 @@ class BoxPainterBase {
                       const LayoutRect&,
                       BackgroundBleedAvoidance,
                       BackgroundImageGeometry&,
-                      SkBlendMode = SkBlendMode::kSrcOver);
+                      SkBlendMode = SkBlendMode::kSrcOver,
+                      const LayoutSize flow_box_size = LayoutSize());
 
   void PaintMaskImages(const PaintInfo&,
                        const LayoutRect&,
@@ -142,6 +144,7 @@ class BoxPainterBase {
  protected:
   FloatRoundedRect BackgroundRoundedRectAdjustedForBleedAvoidance(
       const LayoutRect& border_rect,
+      const LayoutSize& flow_box_size,
       BackgroundBleedAvoidance,
       bool include_logical_left_edge,
       bool include_logical_right_edge) const;
@@ -149,6 +152,7 @@ class BoxPainterBase {
       const FillLayerInfo&,
       const FillLayer&,
       const LayoutRect&,
+      const LayoutSize& flow_box_size,
       BackgroundBleedAvoidance,
       LayoutRectOutsets border_padding_insets) const;
 
@@ -179,6 +183,7 @@ class BoxPainterBase {
                                          BackgroundBleedAvoidance) const = 0;
   virtual FloatRoundedRect GetBackgroundRoundedRect(
       const LayoutRect& border_rect,
+      const LayoutSize& flow_box_size,
       bool include_logical_left_edge,
       bool include_logical_right_edge) const;
 

third_party/blink/renderer/core/paint/inline_flow_box_painter.cc

@@ -74,22 +74,23 @@ void InlineFlowBoxPainter::PaintFillLayer(const PaintInfo& paint_info,
   BackgroundImageGeometry geometry(*box_model);
   StyleImage* img = fill_layer.GetImage();
   bool has_fill_image = img && img->CanRender();
-  BoxModelObjectPainter box_model_painter(*box_model, &inline_flow_box_,
-                                          rect.Size());
+  BoxModelObjectPainter box_model_painter(*box_model, &inline_flow_box_);
   if ((!has_fill_image &&
        !inline_flow_box_.GetLineLayoutItem().Style()->HasBorderRadius()) ||
       (!inline_flow_box_.PrevForSameLayoutObject() &&
        !inline_flow_box_.NextForSameLayoutObject()) ||
       !inline_flow_box_.Parent()) {
     box_model_painter.PaintFillLayer(paint_info, c, fill_layer, rect,
-                                     kBackgroundBleedNone, geometry, op);
+                                     kBackgroundBleedNone, geometry, op,
+                                     rect.Size());
   } else if (inline_flow_box_.GetLineLayoutItem()
                  .Style()
                  ->BoxDecorationBreak() == EBoxDecorationBreak::kClone) {
     GraphicsContextStateSaver state_saver(paint_info.context);
     paint_info.context.Clip(PixelSnappedIntRect(rect));
     box_model_painter.PaintFillLayer(paint_info, c, fill_layer, rect,
-                                     kBackgroundBleedNone, geometry, op);
+                                     kBackgroundBleedNone, geometry, op,
+                                     rect.Size());
   } else {
     // We have a fill image that spans multiple lines.
     // FIXME: frameSize ought to be the same as rect.size().
@@ -100,9 +101,9 @@ void InlineFlowBoxPainter::PaintFillLayer(const PaintInfo& paint_info,
     GraphicsContextStateSaver state_saver(paint_info.context);
     // TODO(chrishtr): this should likely be pixel-snapped.
     paint_info.context.Clip(PixelSnappedIntRect(rect));
-    box_model_painter.PaintFillLayer(paint_info, c, fill_layer,
-                                     image_strip_paint_rect,
-                                     kBackgroundBleedNone, geometry, op);
+    box_model_painter.PaintFillLayer(
+        paint_info, c, fill_layer, image_strip_paint_rect, kBackgroundBleedNone,
+        geometry, op, rect.Size());
   }
 }