Remove NGPaintFragment from NGBoxFragmentPainter

Bug: 1154531
Change-Id: I28fae7f200063d3f6abf29f8bca0ec143e33f520
Reviewed-on: https://chromium-review.googlesource.com/c/chromium/src/+/2586292
Auto-Submit: Koji Ishii <kojii@chromium.org>
Reviewed-by: Ian Kilpatrick <ikilpatrick@chromium.org>
Commit-Queue: Ian Kilpatrick <ikilpatrick@chromium.org>
Commit-Queue: Koji Ishii <kojii@chromium.org>
Cr-Commit-Position: refs/heads/master@{#836346}

third_party/blink/renderer/core/paint/ng/ng_box_fragment_painter.h

@@ -10,7 +10,6 @@
 #include "third_party/blink/renderer/core/layout/ng/inline/ng_inline_cursor.h"
 #include "third_party/blink/renderer/core/layout/ng/ng_physical_box_fragment.h"
 #include "third_party/blink/renderer/core/paint/box_painter_base.h"
-#include "third_party/blink/renderer/core/paint/ng/ng_paint_fragment.h"
 #include "third_party/blink/renderer/platform/geometry/layout_point.h"
 #include "third_party/blink/renderer/platform/geometry/layout_size.h"
 #include "third_party/blink/renderer/platform/wtf/allocator/allocator.h"
@@ -36,11 +35,6 @@ class NGBoxFragmentPainter : public BoxPainterBase {
 
  public:
   NGBoxFragmentPainter(const NGPhysicalBoxFragment&);
-  // Construct for a box fragment. |NGPaintFragment| for this
-  // box if this box has inline formatting context, otherwise |nullptr|.
-  NGBoxFragmentPainter(const NGPhysicalBoxFragment&, const NGPaintFragment*);
-  // Construct for an inline formatting context.
-  NGBoxFragmentPainter(const NGPaintFragment&);
   // Construct for an inline box.
   NGBoxFragmentPainter(const NGInlineCursor& inline_box_cursor,
                        const NGFragmentItem& item,
@@ -102,7 +96,6 @@ class NGBoxFragmentPainter : public BoxPainterBase {
  private:
   NGBoxFragmentPainter(const NGPhysicalBoxFragment&,
                        const DisplayItemClient& display_item_client,
-                       const NGPaintFragment* = nullptr,
                        const NGInlineCursor* inline_box_cursor = nullptr,
                        const NGFragmentItem* = nullptr);
 
@@ -138,25 +131,17 @@ class NGBoxFragmentPainter : public BoxPainterBase {
                               const PhysicalOffset& paint_offset);
   void PaintLineBox(const NGPhysicalFragment& line_box_fragment,
                     const DisplayItemClient& display_item_client,
-                    const NGPaintFragment* line_box_paint_fragment,
-                    const NGFragmentItem* line_box_item,
+                    const NGFragmentItem& line_box_item,
                     wtf_size_t line_fragment_id,
                     const PaintInfo&,
                     const PhysicalOffset& paint_offset);
   void PaintBackplate(NGInlineCursor* descendants,
                       const PaintInfo&,
                       const PhysicalOffset& paint_offset);
-  void PaintInlineChildren(NGPaintFragment::ChildList,
-                           const PaintInfo&,
-                           const PhysicalOffset& paint_offset);
   void PaintInlineChildBoxUsingLegacyFallback(const NGPhysicalFragment&,
                                               const PaintInfo&);
   void PaintBlockFlowContents(const PaintInfo&,
                               const PhysicalOffset& paint_offset);
-  void PaintAtomicInlineChild(const NGPaintFragment&, const PaintInfo&);
-  void PaintTextChild(const NGPaintFragment&,
-                      const PaintInfo&,
-                      const PhysicalOffset& paint_offset);
   void PaintTextItem(const NGInlineCursor& cursor,
                      const PaintInfo&,
                      const PhysicalOffset& paint_offset,
@@ -247,9 +232,6 @@ class NGBoxFragmentPainter : public BoxPainterBase {
                             const HitTestLocation&,
                             PhysicalOffset,
                             HitTestAction);
-  bool HitTestPaintFragmentChildren(const HitTestContext& hit_test,
-                                    const NGInlineCursor& children,
-                                    const PhysicalOffset& physical_offset);
   bool HitTestItemsChildren(const HitTestContext& hit_test,
                             const NGPhysicalBoxFragment& container,
                             const NGInlineCursor& children);
@@ -309,10 +291,6 @@ class NGBoxFragmentPainter : public BoxPainterBase {
 
   const NGPhysicalBoxFragment& box_fragment_;
   const DisplayItemClient& display_item_client_;
-  // If this box has inline children, either |paint_fragment_| or |items_| is
-  // not null, depends on |LayoutNGFragmentItemEnabled|. TODO(kojii): Remove
-  // |NGPaintFragment| once the transition is done. crbug.com/982194
-  const NGPaintFragment* paint_fragment_;
   const NGFragmentItems* items_;
   const NGFragmentItem* box_item_ = nullptr;
   const NGInlineCursor* inline_box_cursor_ = nullptr;
@@ -321,47 +299,23 @@ class NGBoxFragmentPainter : public BoxPainterBase {
 inline NGBoxFragmentPainter::NGBoxFragmentPainter(
     const NGPhysicalBoxFragment& box,
     const DisplayItemClient& display_item_client,
-    const NGPaintFragment* paint_fragment,
     const NGInlineCursor* inline_box_cursor,
     const NGFragmentItem* box_item)
     : BoxPainterBase(&box.GetDocument(), box.Style(), box.GeneratingNode()),
       box_fragment_(box),
       display_item_client_(display_item_client),
-      paint_fragment_(paint_fragment),
       items_(box.Items()),
       box_item_(box_item),
       inline_box_cursor_(inline_box_cursor) {
   DCHECK(box.IsBox() || box.IsRenderedLegend());
   DCHECK_EQ(box.PostLayout(), &box);
 #if DCHECK_IS_ON()
-  if (RuntimeEnabledFeatures::LayoutNGFragmentItemEnabled()) {
-    DCHECK(!paint_fragment_);
-    if (inline_box_cursor_)
-      DCHECK_EQ(inline_box_cursor_->Current().Item(), box_item_);
-    if (box_item_)
-      DCHECK_EQ(box_item_->BoxFragment(), &box);
-    DCHECK_EQ(box.IsInlineBox(), !!inline_box_cursor_);
-    DCHECK_EQ(box.IsInlineBox(), !!box_item_);
-  } else {
-    DCHECK(!inline_box_cursor_);
-    DCHECK(!box_item_);
-    if (paint_fragment)
-      DCHECK_EQ(&paint_fragment->PhysicalFragment(), &box);
-    if (box.IsInlineBox()) {
-      DCHECK(paint_fragment_);
-    } else if (box.IsInlineFormattingContext()) {
-      // If no children, there maybe or may not be NGPaintFragment.
-      // TODO(kojii): To be investigated if this correct or should be fixed.
-      if (!box.Children().empty()) {
-        if (!box.GetLayoutObject() ||
-            !box.GetLayoutObject()->ChildPaintBlockedByDisplayLock()) {
-          DCHECK(paint_fragment);
-        }
-      }
-    } else {
-      // We may not have |paint_fragment_| nor |box_item_|.
-    }
-  }
+  if (inline_box_cursor_)
+    DCHECK_EQ(inline_box_cursor_->Current().Item(), box_item_);
+  if (box_item_)
+    DCHECK_EQ(box_item_->BoxFragment(), &box);
+  DCHECK_EQ(box.IsInlineBox(), !!inline_box_cursor_);
+  DCHECK_EQ(box.IsInlineBox(), !!box_item_);
 #endif
 }
 
@@ -369,37 +323,15 @@ inline NGBoxFragmentPainter::NGBoxFragmentPainter(
     const NGPhysicalBoxFragment& fragment)
     : NGBoxFragmentPainter(fragment,
                            *fragment.GetLayoutObject(),
-                           /* paint_fragment */ nullptr,
                            /* inline_box_cursor */ nullptr,
                            /* box_item */ nullptr) {}
 
-inline NGBoxFragmentPainter::NGBoxFragmentPainter(
-    const NGPhysicalBoxFragment& fragment,
-    const NGPaintFragment* paint_fragment)
-    : NGBoxFragmentPainter(
-          fragment,
-          paint_fragment
-              ? *static_cast<const DisplayItemClient*>(paint_fragment)
-              : *static_cast<const DisplayItemClient*>(
-                    fragment.GetLayoutObject()),
-          paint_fragment,
-          /* inline_box_cursor */ nullptr,
-          /* box_item */ nullptr) {}
-
-inline NGBoxFragmentPainter::NGBoxFragmentPainter(
-    const NGPaintFragment& paint_fragment)
-    : NGBoxFragmentPainter(
-          To<NGPhysicalBoxFragment>(paint_fragment.PhysicalFragment()),
-          paint_fragment,
-          &paint_fragment) {}
-
 inline NGBoxFragmentPainter::NGBoxFragmentPainter(
     const NGInlineCursor& inline_box_cursor,
     const NGFragmentItem& item,
     const NGPhysicalBoxFragment& fragment)
     : NGBoxFragmentPainter(fragment,
                            *item.GetDisplayItemClient(),
-                           /* paint_fragment */ nullptr,
                            &inline_box_cursor,
                            &item) {
   DCHECK_EQ(item.BoxFragment(), &fragment);

third_party/blink/renderer/core/paint/ng/ng_inline_box_fragment_painter.cc

@@ -10,7 +10,6 @@
 #include "third_party/blink/renderer/core/layout/ng/inline/ng_physical_text_fragment.h"
 #include "third_party/blink/renderer/core/layout/ng/ng_fragment.h"
 #include "third_party/blink/renderer/core/paint/background_image_geometry.h"
-#include "third_party/blink/renderer/core/paint/ng/ng_paint_fragment.h"
 #include "third_party/blink/renderer/core/paint/paint_info.h"
 #include "third_party/blink/renderer/core/paint/paint_layer.h"
 #include "third_party/blink/renderer/core/paint/paint_phase.h"
@@ -30,10 +29,6 @@ bool HasMultipleItems(const Items items) {
   return iter != items.end() && ++iter != items.end();
 }
 
-inline bool HasMultiplePaintFragments(const LayoutObject& layout_object) {
-  return HasMultipleItems(NGPaintFragment::InlineFragmentsFor(&layout_object));
-}
-
 inline bool MayHaveMultipleFragmentItems(const NGFragmentItem& item,
                                          const LayoutObject& layout_object) {
   return !item.IsFirstForNode() || !item.IsLastForNode() ||
@@ -54,30 +49,17 @@ PhysicalBoxSides NGInlineBoxFragmentPainter::SidesToInclude() const {
 
 void NGInlineBoxFragmentPainter::Paint(const PaintInfo& paint_info,
                                        const PhysicalOffset& paint_offset) {
-  base::Optional<ScopedDisplayItemFragment> display_item_fragment;
-  if (inline_box_item_) {
-    display_item_fragment.emplace(paint_info.context,
-                                  inline_box_item_->FragmentId());
-  }
+  ScopedDisplayItemFragment display_item_fragment(
+      paint_info.context, inline_box_item_.FragmentId());
 
   const PhysicalOffset adjusted_paint_offset =
-      paint_offset + (inline_box_paint_fragment_
-                          ? inline_box_paint_fragment_->Offset()
-                          : inline_box_item_->OffsetInContainerFragment());
+      paint_offset + inline_box_item_.OffsetInContainerFragment();
   if (paint_info.phase == PaintPhase::kForeground)
     PaintBackgroundBorderShadow(paint_info, adjusted_paint_offset);
 
   const bool suppress_box_decoration_background = true;
-  if (inline_box_paint_fragment_) {
-    NGBoxFragmentPainter box_painter(PhysicalFragment(),
-                                     inline_box_paint_fragment_);
-    box_painter.PaintObject(paint_info, adjusted_paint_offset,
-                            suppress_box_decoration_background);
-    return;
-  }
   DCHECK(inline_box_cursor_);
-  DCHECK(inline_box_item_);
-  NGBoxFragmentPainter box_painter(*inline_box_cursor_, *inline_box_item_,
+  NGBoxFragmentPainter box_painter(*inline_box_cursor_, inline_box_item_,
                                    PhysicalFragment());
   box_painter.PaintObject(paint_info, adjusted_paint_offset,
                           suppress_box_decoration_background);
@@ -116,27 +98,15 @@ void NGInlineBoxFragmentPainterBase::PaintBackgroundBorderShadow(
 
   DCHECK(inline_box_fragment_.GetLayoutObject());
   const LayoutObject& layout_object = *inline_box_fragment_.GetLayoutObject();
-  DCHECK(inline_box_paint_fragment_ || inline_box_item_);
   bool object_may_have_multiple_boxes =
-      inline_box_paint_fragment_
-          ? HasMultiplePaintFragments(layout_object)
-          : MayHaveMultipleFragmentItems(*inline_box_item_, layout_object);
+      MayHaveMultipleFragmentItems(inline_box_item_, layout_object);
 
   // TODO(eae): Switch to LayoutNG version of BackgroundImageGeometry.
   BackgroundImageGeometry geometry(*static_cast<const LayoutBoxModelObject*>(
       inline_box_fragment_.GetLayoutObject()));
-  if (inline_box_paint_fragment_) {
-    NGBoxFragmentPainter box_painter(
-        To<NGPhysicalBoxFragment>(inline_box_fragment_),
-        inline_box_paint_fragment_);
-    PaintBoxDecorationBackground(
-        box_painter, paint_info, paint_offset, adjusted_frame_rect, geometry,
-        object_may_have_multiple_boxes, SidesToInclude());
-    return;
-  }
   DCHECK(inline_box_cursor_);
   NGBoxFragmentPainter box_painter(
-      *inline_box_cursor_, *inline_box_item_,
+      *inline_box_cursor_, inline_box_item_,
       To<NGPhysicalBoxFragment>(inline_box_fragment_));
   PaintBoxDecorationBackground(
       box_painter, paint_info, paint_offset, adjusted_frame_rect, geometry,
@@ -145,13 +115,7 @@ void NGInlineBoxFragmentPainterBase::PaintBackgroundBorderShadow(
 
 IntRect NGInlineBoxFragmentPainterBase::VisualRect(
     const PhysicalOffset& paint_offset) {
-  PhysicalRect overflow_rect;
-  if (inline_box_paint_fragment_) {
-    overflow_rect = inline_box_paint_fragment_->SelfInkOverflow();
-  } else {
-    DCHECK(inline_box_item_);
-    overflow_rect = inline_box_item_->SelfInkOverflow();
-  }
+  PhysicalRect overflow_rect = inline_box_item_.SelfInkOverflow();
   overflow_rect.Move(paint_offset);
   return EnclosingIntRect(overflow_rect);
 }
@@ -162,14 +126,9 @@ void NGLineBoxFragmentPainter::PaintBackgroundBorderShadow(
   DCHECK_EQ(paint_info.phase, PaintPhase::kForeground);
   DCHECK_EQ(inline_box_fragment_.Type(), NGPhysicalFragment::kFragmentLineBox);
   DCHECK(NeedsPaint(inline_box_fragment_));
-#if DCHECK_IS_ON()
-  if (RuntimeEnabledFeatures::LayoutNGFragmentItemEnabled()) {
-    DCHECK(inline_box_item_);
-    // |NGFragmentItem| uses the fragment id when painting the background of
-    // line boxes. Please see |NGFragmentItem::kInitialLineFragmentId|.
-    DCHECK_NE(paint_info.context.GetPaintController().CurrentFragment(), 0u);
-  }
-#endif
+  // |NGFragmentItem| uses the fragment id when painting the background of
+  // line boxes. Please see |NGFragmentItem::kInitialLineFragmentId|.
+  DCHECK_NE(paint_info.context.GetPaintController().CurrentFragment(), 0u);
 
   if (line_style_ == style_ ||
       line_style_.Visibility() != EVisibility::kVisible)
@@ -208,7 +167,7 @@ void NGLineBoxFragmentPainter::PaintBackgroundBorderShadow(
   const LayoutBlockFlow& layout_block_flow =
       *To<LayoutBlockFlow>(block_fragment_.GetLayoutObject());
   BackgroundImageGeometry geometry(layout_block_flow);
-  NGBoxFragmentPainter box_painter(block_fragment_, block_paint_fragment_);
+  NGBoxFragmentPainter box_painter(block_fragment_);
   PaintBoxDecorationBackground(
       box_painter, paint_info, paint_offset, rect, geometry,
       /*object_has_multiple_boxes*/ false, PhysicalBoxSides());
@@ -228,19 +187,10 @@ void NGInlineBoxFragmentPainterBase::ComputeFragmentOffsetOnLine(
   LayoutUnit after;
   bool before_self = true;
   for (; cursor; cursor.MoveToNextForSameLayoutObject()) {
-    if (inline_box_paint_fragment_) {
-      DCHECK(cursor.CurrentPaintFragment());
-      if (cursor.CurrentPaintFragment() == inline_box_paint_fragment_) {
-        before_self = false;
-        continue;
-      }
-    } else {
-      DCHECK(inline_box_item_);
-      DCHECK(cursor.CurrentItem());
-      if (cursor.CurrentItem() == inline_box_item_) {
-        before_self = false;
-        continue;
-      }
+    DCHECK(cursor.CurrentItem());
+    if (cursor.CurrentItem() == &inline_box_item_) {
+      before_self = false;
+      continue;
     }
     const NGPhysicalBoxFragment* box_fragment = cursor.Current().BoxFragment();
     DCHECK(box_fragment);
@@ -338,24 +288,6 @@ void NGInlineBoxFragmentPainter::PaintAllFragments(
   if (UNLIKELY(block_flow->NeedsLayout()))
     return;
 
-  if (!RuntimeEnabledFeatures::LayoutNGFragmentItemEnabled()) {
-    auto fragments = NGPaintFragment::InlineFragmentsFor(&layout_inline);
-
-    // TODO(kojii): The root of this inline formatting context should have a
-    // PaintFragment, but it looks like there's a case it doesn't stand.
-    // crbug.com/969096
-    CHECK(block_flow->PaintFragment() || fragments.IsEmpty());
-
-    for (const NGPaintFragment* fragment : fragments) {
-      PhysicalOffset child_offset = paint_offset +
-                                    fragment->OffsetInContainerFragment() -
-                                    fragment->Offset();
-      DCHECK(fragment->PhysicalFragment().IsBox());
-      NGInlineBoxFragmentPainter(*fragment).Paint(paint_info, child_offset);
-    }
-    return;
-  }
-
   NGInlineCursor cursor(*block_flow);
   cursor.MoveTo(layout_inline);
   if (!cursor)
@@ -380,10 +312,8 @@ void NGInlineBoxFragmentPainter::PaintAllFragments(
 
 #if DCHECK_IS_ON()
 void NGInlineBoxFragmentPainter::CheckValid() const {
-  if (inline_box_item_) {
-    DCHECK(inline_box_cursor_);
-    DCHECK_EQ(inline_box_cursor_->Current().Item(), inline_box_item_);
-  }
+  DCHECK(inline_box_cursor_);
+  DCHECK_EQ(inline_box_cursor_->Current().Item(), &inline_box_item_);
 
   DCHECK_EQ(inline_box_fragment_.Type(),
             NGPhysicalFragment::NGFragmentType::kFragmentBox);

third_party/blink/renderer/core/paint/ng/ng_inline_box_fragment_painter.h

@@ -13,7 +13,6 @@
 
 namespace blink {
 
-class NGPaintFragment;
 struct PaintInfo;
 struct PhysicalRect;
 
@@ -28,56 +27,30 @@ class NGInlineBoxFragmentPainterBase : public InlineBoxPainterBase {
                                    LayoutUnit* total_width) const;
 
  protected:
-  NGInlineBoxFragmentPainterBase(
-      const NGPhysicalFragment& inline_box_fragment,
-      const NGInlineCursor* inline_box_cursor,
-      const NGPaintFragment* inline_box_paint_fragment,
-      const NGFragmentItem* inline_box_item,
-      const LayoutObject& layout_object,
-      const ComputedStyle& style,
-      const ComputedStyle& line_style)
+  NGInlineBoxFragmentPainterBase(const NGPhysicalFragment& inline_box_fragment,
+                                 const NGInlineCursor* inline_box_cursor,
+                                 const NGFragmentItem& inline_box_item,
+                                 const LayoutObject& layout_object,
+                                 const ComputedStyle& style,
+                                 const ComputedStyle& line_style)
       : InlineBoxPainterBase(layout_object,
                              &layout_object.GetDocument(),
                              layout_object.GeneratingNode(),
                              style,
                              line_style),
         inline_box_fragment_(inline_box_fragment),
-        inline_box_paint_fragment_(inline_box_paint_fragment),
         inline_box_item_(inline_box_item),
         inline_box_cursor_(inline_box_cursor) {
 #if DCHECK_IS_ON()
-    if (inline_box_cursor) {
-      DCHECK(inline_box_item);
-      DCHECK_EQ(inline_box_cursor->Current().Item(), inline_box_item);
-    }
-    if (inline_box_paint_fragment) {
-      DCHECK_EQ(&inline_box_paint_fragment->PhysicalFragment(),
-                &inline_box_fragment);
-      DCHECK(!inline_box_item);
-    } else if (inline_box_item) {
-      if (inline_box_item->BoxFragment())
-        DCHECK_EQ(inline_box_item->BoxFragment(), &inline_box_fragment);
-      else
-        DCHECK_EQ(inline_box_item->LineBoxFragment(), &inline_box_fragment);
-    } else {
-      NOTREACHED();
-    }
+    if (inline_box_cursor)
+      DCHECK_EQ(inline_box_cursor->Current().Item(), &inline_box_item);
+    if (inline_box_item.BoxFragment())
+      DCHECK_EQ(inline_box_item.BoxFragment(), &inline_box_fragment);
+    else
+      DCHECK_EQ(inline_box_item.LineBoxFragment(), &inline_box_fragment);
 #endif
   }
 
-  // Constructor for |NGPaintFragment|.
-  NGInlineBoxFragmentPainterBase(const NGPaintFragment& inline_box_fragment,
-                                 const LayoutObject& layout_object,
-                                 const ComputedStyle& style,
-                                 const ComputedStyle& line_style)
-      : NGInlineBoxFragmentPainterBase(inline_box_fragment.PhysicalFragment(),
-                                       /* inline_box_cursor */ nullptr,
-                                       &inline_box_fragment,
-                                       /* inline_box_item */ nullptr,
-                                       layout_object,
-                                       style,
-                                       line_style) {}
-
   // Constructor for |NGFragmentItem|.
   NGInlineBoxFragmentPainterBase(
       const NGInlineCursor& inline_box_cursor,
@@ -88,17 +61,14 @@ class NGInlineBoxFragmentPainterBase : public InlineBoxPainterBase {
       const ComputedStyle& line_style)
       : NGInlineBoxFragmentPainterBase(inline_box_fragment,
                                        &inline_box_cursor,
-                                       /* inline_box_paint_fragment */ nullptr,
-                                       &inline_box_item,
+                                       inline_box_item,
                                        layout_object,
                                        style,
                                        line_style) {}
 
   const DisplayItemClient& GetDisplayItemClient() const {
-    if (inline_box_paint_fragment_)
-      return *inline_box_paint_fragment_;
-    DCHECK(inline_box_item_);
-    return *inline_box_item_->GetDisplayItemClient();
+    DCHECK(inline_box_item_.GetDisplayItemClient());
+    return *inline_box_item_.GetDisplayItemClient();
   }
 
   virtual PhysicalBoxSides SidesToInclude() const = 0;
@@ -123,8 +93,7 @@ class NGInlineBoxFragmentPainterBase : public InlineBoxPainterBase {
   IntRect VisualRect(const PhysicalOffset& paint_offset);
 
   const NGPhysicalFragment& inline_box_fragment_;
-  const NGPaintFragment* inline_box_paint_fragment_ = nullptr;
-  const NGFragmentItem* inline_box_item_ = nullptr;
+  const NGFragmentItem& inline_box_item_;
   const NGInlineCursor* inline_box_cursor_ = nullptr;
 };
 
@@ -134,18 +103,6 @@ class NGInlineBoxFragmentPainter : public NGInlineBoxFragmentPainterBase {
   STACK_ALLOCATED();
 
  public:
-  // Constructor for |NGPaintFragment|.
-  NGInlineBoxFragmentPainter(const NGPaintFragment& inline_box_fragment)
-      : NGInlineBoxFragmentPainterBase(inline_box_fragment,
-                                       *inline_box_fragment.GetLayoutObject(),
-                                       inline_box_fragment.Style(),
-                                       inline_box_fragment.Style()) {
-    DCHECK_EQ(inline_box_fragment.PhysicalFragment().Type(),
-              NGPhysicalFragment::NGFragmentType::kFragmentBox);
-    DCHECK_EQ(inline_box_fragment.PhysicalFragment().BoxType(),
-              NGPhysicalFragment::NGBoxType::kInlineBox);
-  }
-
   // Constructor for |NGFragmentItem|.
   NGInlineBoxFragmentPainter(const NGInlineCursor& inline_box_cursor,
                              const NGFragmentItem& inline_box_item,
@@ -194,15 +151,11 @@ class NGLineBoxFragmentPainter : public NGInlineBoxFragmentPainterBase {
 
  public:
   NGLineBoxFragmentPainter(const NGPhysicalFragment& line_box_fragment,
-                           const NGPaintFragment* line_box_paint_fragment,
-                           const NGFragmentItem* line_box_item,
-                           const NGPhysicalBoxFragment& block_fragment,
-                           const NGPaintFragment* block_paint_fragment)
+                           const NGFragmentItem& line_box_item,
+                           const NGPhysicalBoxFragment& block_fragment)
       : NGLineBoxFragmentPainter(line_box_fragment,
-                                 line_box_paint_fragment,
                                  line_box_item,
                                  block_fragment,
-                                 block_paint_fragment,
                                  *block_fragment.GetLayoutObject()) {}
 
   static bool NeedsPaint(const NGPhysicalFragment& line_fragment) {
@@ -218,15 +171,12 @@ class NGLineBoxFragmentPainter : public NGInlineBoxFragmentPainterBase {
 
  private:
   NGLineBoxFragmentPainter(const NGPhysicalFragment& line_box_fragment,
-                           const NGPaintFragment* line_box_paint_fragment,
-                           const NGFragmentItem* line_box_item,
+                           const NGFragmentItem& line_box_item,
                            const NGPhysicalBoxFragment& block_fragment,
-                           const NGPaintFragment* block_paint_fragment,
                            const LayoutObject& layout_block_flow)
       : NGInlineBoxFragmentPainterBase(
             line_box_fragment,
             /* inline_box_cursor */ nullptr,
-            line_box_paint_fragment,
             line_box_item,
             layout_block_flow,
             // Use the style from the containing block. |line_fragment.Style()|
@@ -235,8 +185,7 @@ class NGLineBoxFragmentPainter : public NGInlineBoxFragmentPainterBase {
             // TODO(kojii): Reconsider |line_fragment.Style()|.
             layout_block_flow.StyleRef(),
             layout_block_flow.FirstLineStyleRef()),
-        block_fragment_(block_fragment),
-        block_paint_fragment_(block_paint_fragment) {
+        block_fragment_(block_fragment) {
     DCHECK_EQ(line_box_fragment.Type(),
               NGPhysicalFragment::NGFragmentType::kFragmentLineBox);
     DCHECK(NeedsPaint(line_box_fragment));
@@ -250,7 +199,6 @@ class NGLineBoxFragmentPainter : public NGInlineBoxFragmentPainterBase {
   PhysicalBoxSides SidesToInclude() const final { return PhysicalBoxSides(); }
 
   const NGPhysicalBoxFragment& block_fragment_;
-  const NGPaintFragment* block_paint_fragment_;
 };
 
 }  // namespace blink

third_party/blink/renderer/core/paint/ng/ng_table_painters.cc

@@ -642,17 +642,8 @@ void NGTableCellPainter::PaintBoxDecorationBackground(
                            DisplayItem::kBoxDecorationBackground, visual_rect);
 
   PhysicalRect paint_rect(paint_offset, fragment_.Size());
-
-  const NGPaintFragment* paint_fragment =
-      To<LayoutNGTableCell>(fragment_.GetLayoutObject())->PaintFragment();
-  if (paint_fragment) {
-    NGBoxFragmentPainter(*paint_fragment)
-        .PaintBoxDecorationBackgroundWithRectImpl(paint_info, paint_rect,
-                                                  box_decoration_data);
-  } else {
-    NGBoxFragmentPainter(fragment_).PaintBoxDecorationBackgroundWithRectImpl(
-        paint_info, paint_rect, box_decoration_data);
-  }
+  NGBoxFragmentPainter(fragment_).PaintBoxDecorationBackgroundWithRectImpl(
+      paint_info, paint_rect, box_decoration_data);
 }
 
 // Inspired by TableCellPainter::PaintBackground.