[FragmentItem] Implement computing ink overflow

This patch Implements computing ink overflow. The logic is
is copied from the current LayoutNG.

Regresses ~90 tests but fixes ~260. I will update
FlagExpectations later to avoid conflicts.

Bug: 982194
Change-Id: I5e2eaaec858cfb6ee7eec5b515b82a3e71dad46a
Reviewed-on: https://chromium-review.googlesource.com/c/chromium/src/+/1771360Reviewed-by: Xianzhu Wang <wangxianzhu@chromium.org>
Commit-Queue: Koji Ishii <kojii@chromium.org>
Cr-Commit-Position: refs/heads/master@{#712143}

third_party/blink/renderer/core/layout/layout_block_flow.cc

@@ -51,6 +51,7 @@
 #include "third_party/blink/renderer/core/layout/line/inline_iterator.h"
 #include "third_party/blink/renderer/core/layout/line/inline_text_box.h"
 #include "third_party/blink/renderer/core/layout/line/line_width.h"
+#include "third_party/blink/renderer/core/layout/ng/inline/ng_inline_cursor.h"
 #include "third_party/blink/renderer/core/layout/ng/inline/ng_line_height_metrics.h"
 #include "third_party/blink/renderer/core/layout/ng/inline/ng_offset_mapping.h"
 #include "third_party/blink/renderer/core/layout/ng/layout_ng_block_flow.h"
@@ -2577,6 +2578,12 @@ void LayoutBlockFlow::SetPaintFragment(
     const NGBlockBreakToken*,
     scoped_refptr<const NGPhysicalFragment>) {}
 
+const NGFragmentItems* LayoutBlockFlow::FragmentItems() const {
+  if (const NGPhysicalBoxFragment* box_fragment = CurrentFragment())
+    return box_fragment->Items();
+  return nullptr;
+}
+
 void LayoutBlockFlow::ComputeVisualOverflow(
     bool recompute_floats) {
   LayoutRect previous_visual_overflow_rect = VisualOverflowRect();
@@ -4620,6 +4627,16 @@ void LayoutBlockFlow::RecalcInlineChildrenVisualOverflow() {
     return;
   }
 
+  if (UNLIKELY(RuntimeEnabledFeatures::LayoutNGFragmentItemEnabled())) {
+    if (const NGPhysicalBoxFragment* fragment = CurrentFragment()) {
+      if (const NGFragmentItems* items = fragment->Items()) {
+        NGInlineCursor cursor(*items);
+        NGFragmentItem::RecalcInkOverflowAll(&cursor);
+        return;
+      }
+    }
+  }
+
   for (InlineWalker walker(LineLayoutBlockFlow(this)); !walker.AtEnd();
        walker.Advance()) {
     LayoutObject* layout_object = walker.Current().GetLayoutObject();

third_party/blink/renderer/core/layout/layout_block_flow.h

@@ -60,6 +60,7 @@ class LayoutMultiColumnSpannerPlaceholder;
 class LayoutRubyRun;
 class MarginInfo;
 class NGBlockBreakToken;
+class NGFragmentItems;
 class NGOffsetMapping;
 class NGPhysicalFragment;
 
@@ -465,6 +466,7 @@ class CORE_EXPORT LayoutBlockFlow : public LayoutBlock {
   virtual const NGPhysicalBoxFragment* CurrentFragment() const {
     return nullptr;
   }
+  const NGFragmentItems* FragmentItems() const;
 
 #if DCHECK_IS_ON()
   void ShowLineTreeAndMark(const InlineBox* = nullptr,

third_party/blink/renderer/core/layout/layout_block_flow_line.cc

@@ -36,6 +36,8 @@
 #include "third_party/blink/renderer/core/layout/line/line_layout_state.h"
 #include "third_party/blink/renderer/core/layout/line/line_width.h"
 #include "third_party/blink/renderer/core/layout/line/word_measurement.h"
+#include "third_party/blink/renderer/core/layout/ng/inline/ng_fragment_item.h"
+#include "third_party/blink/renderer/core/layout/ng/inline/ng_inline_cursor.h"
 #include "third_party/blink/renderer/core/layout/svg/line/svg_root_inline_box.h"
 #include "third_party/blink/renderer/core/layout/vertical_position_cache.h"
 #include "third_party/blink/renderer/core/paint/ng/ng_paint_fragment.h"
@@ -2392,6 +2394,18 @@ void LayoutBlockFlow::AddVisualOverflowFromInlineChildren() {
         AddContentsVisualOverflow(child_rect);
       }
     }
+  } else if (const NGFragmentItems* items = FragmentItems()) {
+    for (NGInlineCursor cursor(*items); cursor; cursor.MoveToNextSibling()) {
+      const NGFragmentItem* child = cursor.CurrentItem();
+      DCHECK(child);
+      if (child->HasSelfPaintingLayer())
+        continue;
+      PhysicalRect child_rect = child->InkOverflow();
+      if (!child_rect.IsEmpty()) {
+        child_rect.offset += child->Offset();
+        AddContentsVisualOverflow(child_rect);
+      }
+    }
   } else {
     for (RootInlineBox* curr = FirstRootBox(); curr;
          curr = curr->NextRootBox()) {

third_party/blink/renderer/core/layout/ng/inline/ng_fragment_item.cc

@@ -6,6 +6,7 @@
 
 #include "third_party/blink/renderer/core/editing/position_with_affinity.h"
 #include "third_party/blink/renderer/core/layout/ng/inline/ng_fragment_items_builder.h"
+#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"
 
 namespace blink {
@@ -100,9 +101,32 @@ bool NGFragmentItem::IsListMarker() const {
   return false;
 }
 
+bool NGFragmentItem::HasOverflowClip() const {
+  if (const NGPhysicalBoxFragment* fragment = BoxFragment())
+    return fragment->HasOverflowClip();
+  return false;
+}
+
+bool NGFragmentItem::HasSelfPaintingLayer() const {
+  if (const NGPhysicalBoxFragment* fragment = BoxFragment())
+    return fragment->HasSelfPaintingLayer();
+  return false;
+}
+
+PhysicalRect NGFragmentItem::SelfInkOverflow() const {
+  return ink_overflow_ ? ink_overflow_->self_ink_overflow : LocalRect();
+}
+
 PhysicalRect NGFragmentItem::InkOverflow() const {
-  // TODO(yosin): Implement.
+  if (!ink_overflow_)
     return LocalRect();
+
+  if (!IsContainer() || HasOverflowClip())
+    return ink_overflow_->self_ink_overflow;
+
+  const NGContainerInkOverflow& container_ink_overflow =
+      static_cast<NGContainerInkOverflow&>(*ink_overflow_);
+  return container_ink_overflow.SelfAndContentsInkOverflow();
 }
 
 PositionWithAffinity NGFragmentItem::PositionForPoint(
@@ -110,11 +134,6 @@ PositionWithAffinity NGFragmentItem::PositionForPoint(
   return PositionWithAffinity();
 }
 
-PhysicalRect NGFragmentItem::SelfInkOverflow() const {
-  // TODO(kojii): Implement.
-  return LocalRect();
-}
-
 const ShapeResultView* NGFragmentItem::TextShapeResult() const {
   if (Type() == kText)
     return text_.shape_result.get();
@@ -199,6 +218,92 @@ PhysicalRect NGFragmentItem::LocalVisualRectFor(
   return visual_rect;
 }
 
+PhysicalRect NGFragmentItem::RecalcInkOverflowAll(NGInlineCursor* cursor) {
+  DCHECK(cursor);
+  PhysicalRect contents_ink_overflow;
+  while (*cursor) {
+    const NGFragmentItem* item = cursor->CurrentItem();
+    DCHECK(item);
+    PhysicalRect child_rect;
+    item->GetMutableForPainting().RecalcInkOverflow(cursor, &child_rect);
+    if (item->HasSelfPaintingLayer())
+      continue;
+    if (!child_rect.IsEmpty()) {
+      child_rect.offset += item->Offset();
+      contents_ink_overflow.Unite(child_rect);
+    }
+  }
+  return contents_ink_overflow;
+}
+
+void NGFragmentItem::RecalcInkOverflow(
+    NGInlineCursor* cursor,
+    PhysicalRect* self_and_contents_rect_out) {
+  DCHECK_EQ(this, cursor->CurrentItem());
+
+  if (Type() == kText) {
+    cursor->MoveToNext();
+
+    // Re-computing text item is not necessary, because all changes that needs
+    // to re-compute ink overflow invalidate layout.
+    if (ink_overflow_) {
+      *self_and_contents_rect_out = ink_overflow_->self_ink_overflow;
+      return;
+    }
+
+    NGTextFragmentPaintInfo paint_info = TextPaintInfo(cursor->Items());
+    if (paint_info.shape_result) {
+      NGInkOverflow::ComputeTextInkOverflow(paint_info, Style(), Size(),
+                                            &ink_overflow_);
+      *self_and_contents_rect_out =
+          ink_overflow_ ? ink_overflow_->self_ink_overflow : LocalRect();
+      return;
+    }
+
+    DCHECK(!ink_overflow_);
+    *self_and_contents_rect_out = LocalRect();
+    return;
+  }
+
+  if (Type() == kGeneratedText) {
+    cursor->MoveToNext();
+    // TODO(kojii): Implement.
+    ink_overflow_ = nullptr;
+    *self_and_contents_rect_out = LocalRect();
+    return;
+  }
+
+  // Compute the contents ink overflow from descendants.
+  NGInlineCursor descendants_cursor = cursor->CursorForDescendants();
+  cursor->MoveToNextSibling();
+  PhysicalRect contents_rect = RecalcInkOverflowAll(&descendants_cursor);
+
+  // Compute the self ink overflow.
+  PhysicalRect self_rect;
+  if (Type() == kLine) {
+    // Line boxes don't have self overflow. Compute content overflow only.
+    *self_and_contents_rect_out = contents_rect;
+  } else if (const NGPhysicalBoxFragment* box_fragment = BoxFragment()) {
+    self_rect = box_fragment->ComputeSelfInkOverflow();
+    *self_and_contents_rect_out = UnionRect(self_rect, contents_rect);
+  } else {
+    NOTREACHED();
+  }
+
+  SECURITY_CHECK(IsContainer());
+  if (LocalRect().Contains(*self_and_contents_rect_out)) {
+    ink_overflow_ = nullptr;
+  } else if (!ink_overflow_) {
+    ink_overflow_ =
+        std::make_unique<NGContainerInkOverflow>(self_rect, contents_rect);
+  } else {
+    NGContainerInkOverflow* ink_overflow =
+        static_cast<NGContainerInkOverflow*>(ink_overflow_.get());
+    ink_overflow->self_ink_overflow = self_rect;
+    ink_overflow->contents_ink_overflow = contents_rect;
+  }
+}
+
 NGFragmentItem::ItemsForLayoutObject NGFragmentItem::ItemsFor(
     const LayoutObject& layout_object) {
   DCHECK(layout_object.IsInLayoutNGInlineFormattingContext());

third_party/blink/renderer/core/layout/ng/inline/ng_fragment_item.h

@@ -11,6 +11,7 @@
 #include "third_party/blink/renderer/core/layout/ng/inline/ng_line_box_fragment_builder.h"
 #include "third_party/blink/renderer/core/layout/ng/inline/ng_line_height_metrics.h"
 #include "third_party/blink/renderer/core/layout/ng/inline/ng_physical_text_fragment.h"
+#include "third_party/blink/renderer/core/layout/ng/ng_ink_overflow.h"
 #include "third_party/blink/renderer/platform/graphics/paint/display_item_client.h"
 
 namespace blink {
@@ -71,6 +72,7 @@ class CORE_EXPORT NGFragmentItem : public DisplayItemClient {
 
   ItemType Type() const { return static_cast<ItemType>(type_); }
 
+  bool IsContainer() const { return Type() == kBox || Type() == kLine; }
   bool IsAtomicInline() const;
   bool IsEmptyLineBox() const;
   bool IsHiddenForPaint() const { return is_hidden_for_paint_; }
@@ -98,9 +100,9 @@ class CORE_EXPORT NGFragmentItem : public DisplayItemClient {
   const PhysicalRect& Rect() const { return rect_; }
   const PhysicalOffset& Offset() const { return rect_.offset; }
   const PhysicalSize& Size() const { return rect_.size; }
+  PhysicalRect LocalRect() const { return {PhysicalOffset(), Size()}; }
   void SetOffset(const PhysicalOffset& offset) { rect_.offset = offset; }
 
-  PhysicalRect LocalRect() const { return {PhysicalOffset(), Size()}; }
   PhysicalRect InkOverflow() const;
   PhysicalRect SelfInkOverflow() const;
 
@@ -112,6 +114,7 @@ class CORE_EXPORT NGFragmentItem : public DisplayItemClient {
       return box_.descendants_count;
     if (Type() == kLine)
       return line_.descendants_count;
+    DCHECK(!IsContainer());
     return 0;
   }
   bool HasChildren() const { return DescendantsCount() > 1; }
@@ -123,6 +126,9 @@ class CORE_EXPORT NGFragmentItem : public DisplayItemClient {
     return nullptr;
   }
 
+  bool HasOverflowClip() const;
+  bool HasSelfPaintingLayer() const;
+
   // TODO(kojii): Avoid using this function in outside of this class as much as
   // possible, because |NGPhysicalLineBoxFragment| is likely to be removed. Add
   // functions to access data in |NGPhysicalLineBoxFragment| rather than using
@@ -196,17 +202,31 @@ class CORE_EXPORT NGFragmentItem : public DisplayItemClient {
   static ItemsForLayoutObject ItemsFor(const LayoutObject& layout_object);
   static PhysicalRect LocalVisualRectFor(const LayoutObject& layout_object);
 
+  // Re-compute the ink overflow for the |cursor| until its end.
+  static PhysicalRect RecalcInkOverflowAll(NGInlineCursor* cursor);
+
+  // Re-compute the ink overflow for this item. |cursor| should be at |this|,
+  // and is advanced to the next item on return.
+  void RecalcInkOverflow(NGInlineCursor* cursor,
+                         PhysicalRect* self_and_contents_rect_out);
+
   // Painters can use const methods only, except for these explicitly declared
   // methods.
   class MutableForPainting {
     STACK_ALLOCATED();
 
    public:
-    // TODO(kojii): Add painter functions.
+    void RecalcInkOverflow(NGInlineCursor* cursor,
+                           PhysicalRect* self_and_contents_rect_out) {
+      return item_.RecalcInkOverflow(cursor, self_and_contents_rect_out);
+    }
 
    private:
     friend class NGFragmentItem;
-    MutableForPainting(const NGFragmentItem& item) {}
+    MutableForPainting(const NGFragmentItem& item)
+        : item_(const_cast<NGFragmentItem&>(item)) {}
+
+    NGFragmentItem& item_;
   };
   MutableForPainting GetMutableForPainting() const {
     return MutableForPainting(*this);
@@ -322,21 +342,7 @@ class CORE_EXPORT NGFragmentItem : public DisplayItemClient {
 
   PhysicalRect rect_;
 
-  struct NGInkOverflowModel {
-    USING_FAST_MALLOC(NGInkOverflowModel);
-
-   public:
-    NGInkOverflowModel(const PhysicalRect& self_ink_overflow,
-                       const PhysicalRect& contents_ink_overflow);
-
-    PhysicalRect self_ink_overflow;
-    // TODO(kojii): Some types (e.g., kText) never have |contents_ink_overflow|.
-    // Can/should we optimize the memory usage for those cases?
-    PhysicalRect contents_ink_overflow;
-  };
-  mutable std::unique_ptr<NGInkOverflowModel> ink_overflow_;
-  // TOOD(kojii): mutable because this is lazily computed, but it may not be
-  // needed if we use |MutableForPainting|. TBD.
+  std::unique_ptr<NGInkOverflow> ink_overflow_;
 
   // Item index delta to the next item for the same |LayoutObject|.
   // wtf_size_t delta_to_next_for_same_layout_object_ = 0;

third_party/blink/renderer/core/layout/ng/inline/ng_physical_text_fragment.cc

@@ -194,7 +194,8 @@ void NGPhysicalTextFragment::ComputeSelfInkOverflow() const {
     return;
   }
 
-  ink_overflow_ = NGInkOverflow::TextInkOverflow(PaintInfo(), Style(), Size());
+  NGInkOverflow::ComputeTextInkOverflow(PaintInfo(), Style(), Size(),
+                                        &ink_overflow_);
 }
 
 scoped_refptr<const NGPhysicalTextFragment>

third_party/blink/renderer/core/layout/ng/ng_ink_overflow.cc

@@ -11,10 +11,11 @@
 namespace blink {
 
 // static
-std::unique_ptr<NGInkOverflow> NGInkOverflow::TextInkOverflow(
+void NGInkOverflow::ComputeTextInkOverflow(
     const NGTextFragmentPaintInfo& text_info,
     const ComputedStyle& style,
-    const PhysicalSize& size) {
+    const PhysicalSize& size,
+    std::unique_ptr<NGInkOverflow>* ink_overflow_out) {
   // Glyph bounds is in logical coordinate, origin at the alphabetic baseline.
   const Font& font = style.GetFont();
   const FloatRect text_ink_bounds = font.TextInkBounds(text_info);
@@ -62,11 +63,17 @@ std::unique_ptr<NGInkOverflow> NGInkOverflow::TextInkOverflow(
   // Uniting the frame rect ensures that non-ink spaces such side bearings, or
   // even space characters, are included in the visual rect for decorations.
   PhysicalRect local_rect(PhysicalOffset(), size);
-  if (local_rect.Contains(local_ink_overflow))
-    return nullptr;
+  if (local_rect.Contains(local_ink_overflow)) {
+    *ink_overflow_out = nullptr;
+    return;
+  }
   local_ink_overflow.Unite(local_rect);
   local_ink_overflow.ExpandEdgesToPixelBoundaries();
-  return std::make_unique<NGInkOverflow>(local_ink_overflow);
+  if (!*ink_overflow_out) {
+    *ink_overflow_out = std::make_unique<NGInkOverflow>(local_ink_overflow);
+    return;
+  }
+  (*ink_overflow_out)->self_ink_overflow = local_ink_overflow;
 }
 
 }  // namespace blink

third_party/blink/renderer/core/layout/ng/ng_ink_overflow.h

@@ -21,10 +21,11 @@ struct CORE_EXPORT NGInkOverflow {
   NGInkOverflow(const PhysicalRect& self_ink_overflow)
       : self_ink_overflow(self_ink_overflow) {}
 
-  static std::unique_ptr<NGInkOverflow> TextInkOverflow(
+  static void ComputeTextInkOverflow(
       const NGTextFragmentPaintInfo& text_info,
       const ComputedStyle& style,
-      const PhysicalSize& size);
+      const PhysicalSize& size,
+      std::unique_ptr<NGInkOverflow>* ink_overflow_out);
 
   PhysicalRect self_ink_overflow;
 };
@@ -40,6 +41,10 @@ struct CORE_EXPORT NGContainerInkOverflow : NGInkOverflow {
       : NGInkOverflow(self_ink_overflow),
         contents_ink_overflow(contents_ink_overflow) {}
 
+  PhysicalRect SelfAndContentsInkOverflow() const {
+    return UnionRect(self_ink_overflow, contents_ink_overflow);
+  }
+
   PhysicalRect contents_ink_overflow;
 };