[LayoutNG] Implement atomic inlines for LayoutNGInline

third_party/WebKit/Source/core/layout/ng/ng_inline_node.cc

 // Copyright 2016 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "core/layout/ng/ng_inline_node.h"
 
 #include "core/layout/LayoutBlockFlow.h"
 #include "core/layout/LayoutObject.h"
 #include "core/layout/LayoutText.h"
 #include "core/layout/ng/ng_bidi_paragraph.h"
@@ skipping 12 matching lines @@
 #include "platform/fonts/shaping/CachingWordShaper.h"
 #include "platform/fonts/shaping/HarfBuzzShaper.h"
 #include "platform/fonts/shaping/ShapeResultBuffer.h"
 #include "wtf/text/CharacterNames.h"
 
 namespace blink {
 
 NGInlineNode::NGInlineNode(LayoutObject* start_inline, LayoutBlockFlow* block)
     : NGLayoutInputNode(NGLayoutInputNodeType::kLegacyInline),
       start_inline_(start_inline),
-      block_(block) {
+      block_(block),
+      has_atomic_inlines_(false),
+      is_bidi_enabled_(false) {
   DCHECK(start_inline);
   DCHECK(block);
 }
 
 NGInlineNode::NGInlineNode()
     : NGLayoutInputNode(NGLayoutInputNodeType::kLegacyInline),
       start_inline_(nullptr),
-      block_(nullptr) {}
+      block_(nullptr),
+      has_atomic_inlines_(false),
+      is_bidi_enabled_(false) {}
 
 NGInlineNode::~NGInlineNode() {}
 
 NGLayoutInlineItemRange NGInlineNode::Items(unsigned start, unsigned end) {
   return NGLayoutInlineItemRange(&items_, start, end);
 }
 
 void NGInlineNode::InvalidatePrepareLayout() {
   text_content_ = String();
   items_.clear();
+  has_atomic_inlines_ = false;
 }
 
 void NGInlineNode::PrepareLayout() {
   // Scan list of siblings collecting all in-flow non-atomic inlines. A single
   // NGInlineNode represent a collection of adjacent non-atomic inlines.
   CollectInlines(start_inline_, block_);
   if (is_bidi_enabled_)
     SegmentText();
   ShapeText();
 }
@@ skipping 38 matching lines @@
       // A block box found. End inline and transit to block layout.
       return node;
 
     } else {
       builder->EnterInline(node);
 
       // For atomic inlines add a unicode "object replacement character" to
       // signal the presence of a non-text object to the unicode bidi algorithm.
       if (node->isAtomicInlineLevel()) {
         builder->Append(objectReplacementCharacter, nullptr, node);
+        has_atomic_inlines_ = true;
       }
 
       // Otherwise traverse to children if they exist.
       else if (LayoutObject* child = node->slowFirstChild()) {
         node = child;
         continue;
 
       } else {
         // An empty inline node.
         node->clearNeedsLayout();
@@ skipping 92 matching lines @@
   return InlineSize(start_offset_, end_offset_);
 }
 
 LayoutUnit NGLayoutInlineItem::InlineSize(unsigned start, unsigned end) const {
   DCHECK(start >= StartOffset() && start <= end && end <= EndOffset());
 
   if (start == end)
     return LayoutUnit();
 
   if (!style_ || !shape_result_) {
-    // Bidi controls do not have widths.
-    // TODO(kojii): Atomic inline not supported yet.
+    DCHECK(start == start_offset_ && end == end_offset_);
+    if (layout_result_) {
+      DCHECK(layout_object_ && layout_object_->isAtomicInlineLevel() &&
+             !layout_object_->isFloatingOrOutOfFlowPositioned());
+      // TODO(kojii): Store parent's isHorizontalWritingMode in
+      // NGLayoutInlineItem.
+      if (!isHorizontalWritingMode(
+              layout_object_->parent()->styleRef().getWritingMode()))
+        return layout_result_->PhysicalFragment()->Height();
+      return layout_result_->PhysicalFragment()->Width();
+    }
+    DCHECK(!layout_object_ ||
+           layout_object_->isFloatingOrOutOfFlowPositioned());
+    // Bidi controls and out-of-flow objects do not have in-flow widths.
     return LayoutUnit();
   }
 
   if (start == start_offset_ && end == end_offset_)
     return LayoutUnit(shape_result_->width());
 
   return LayoutUnit(ShapeResultBuffer::getCharacterRange(
                         shape_result_, Direction(), shape_result_->width(),
                         start - StartOffset(), end - StartOffset())
                         .width());
 }
 
 void NGLayoutInlineItem::GetFallbackFonts(
     HashSet<const SimpleFontData*>* fallback_fonts,
     unsigned start,
     unsigned end) const {
   DCHECK(start >= StartOffset() && start <= end && end <= EndOffset());
 
   // TODO(kojii): Implement |start| and |end|.
   shape_result_->fallbackFonts(fallback_fonts);
 }
 
 void NGInlineNode::ShapeText() {
   // TODO(eae): Add support for shaping latin-1 text?
   text_content_.ensure16Bit();
 
   // Shape each item with the full context of the entire node.
   HarfBuzzShaper shaper(text_content_.characters16(), text_content_.length());
   for (auto& item : items_) {
-    // Skip object replacement characters and bidi control characters.
+    // Skip non-text items; e.g., bidi controls, atomic inlines, out-of-flow
+    // objects.
     if (!item.style_)
       continue;
 
     item.shape_result_ = shaper.shape(&item.Style()->font(), item.Direction(),
                                       item.StartOffset(), item.EndOffset());
   }
 }
 
 RefPtr<NGLayoutResult> NGInlineNode::Layout(NGConstraintSpace*, NGBreakToken*) {
   ASSERT_NOT_REACHED();
   return nullptr;
 }
 
+void NGInlineNode::LayoutAtomicInlines(
+    const NGConstraintSpace& parent_constraint_space) {
+  NGConstraintSpaceBuilder constraint_space_builder(&parent_constraint_space);
+  constraint_space_builder.SetIsNewFormattingContext(true).SetIsShrinkToFit(
+      true);
+  for (auto& item : items_) {
+    if (item.style_)
+      continue;
+    LayoutObject* layout_object = item.layout_object_;
+    if (layout_object && layout_object->isAtomicInlineLevel() &&
+        !layout_object->isFloatingOrOutOfFlowPositioned() &&
+        (!item.layout_result_ || layout_object->needsLayout())) {
+      NGBlockNode* node = new NGBlockNode(layout_object);
+      const ComputedStyle& style = node->Style();
+      RefPtr<NGConstraintSpace> constraint_space =
+          constraint_space_builder.SetTextDirection(style.direction())
+              .ToConstraintSpace(
+                  FromPlatformWritingMode(style.getWritingMode()));
+      item.layout_result_ = node->Layout(constraint_space.get());
+      DCHECK(!layout_object->needsLayout());
+      // TODO(kojii): Figure out what to do with OOF and unpositioned floats.
+    }
+  }
+}
+
 void NGInlineNode::LayoutInline(NGConstraintSpace* constraint_space,
                                 NGLineBuilder* line_builder) {
   if (!IsPrepareLayoutFinished())
     PrepareLayout();
 
   if (text_content_.isEmpty())
     return;
 
+  if (has_atomic_inlines_)
+    LayoutAtomicInlines(*constraint_space);

[ikilpatrick, 2017/03/15 16:39:41]

We need to decide if we are going to support fragmenting atomic inlines, if so
we'll need to do this in the same position as floats.

I.e. we need to determine the position of the atomic inline to determine where
it will fragment before we can perform layout.

This is completely inconsistent between vendors \o/

I.e.
https://software.hixie.ch/utilities/js/live-dom-viewer/?%3C!DOCTYPE%20html%3E...

Edge: Do fragment and place adjacent text in the first column.
Blink/Webkit: Do fragment and place text in the second column.
FF: Don't fragment and place text in first column.

[kojii, 2017/03/15 17:30:28]

It'd be great if we can, though I acknowledge it's not simple to implement.

Edge even tries to break at line box boundaries in inline-block, so that lines
in the inline-block won't cut off. I heard people complains Blink/WebKit to
break at arbitrary point and often cut the lower half of a line when they print.

CSS isn't very clear about this, but if the rules are also applied to inside of
inline-block, Edge looks conforming. Surprised Gecko doesn't do it, I thought it
does.
https://drafts.csswg.org/css2/page.html#allowed-page-breaks

Given Emil's comment, I'm thinking to make this CL can go either way, but we
need to decide when we support BreakToken for inline. I wish us at least to try.

[mstensho (USE GERRIT), 2017/03/16 09:20:14]

Lines are monolithic, which means that we shouldn't fragment inside them. So we
should never fragment inline-block objects, or any other kind of atomic inline,
for that matter.

See what https://drafts.csswg.org/css-break/#possible-breaks has to say about
monolithic content, and the conclusion: "Since line boxes contain no possible
break points, inline-block and inline-table boxes (and other inline-level
display types that establish a new formatting context) may also be considered
monolithic."

+
   NGTextLayoutAlgorithm(this, constraint_space).LayoutInline(line_builder);
 }
 
 MinMaxContentSize NGInlineNode::ComputeMinMaxContentSize() {
   // Compute the max of inline sizes of all line boxes with 0 available inline
   // size. This gives the min-content, the width where lines wrap at every break
   // opportunity.
   NGWritingMode writing_mode =
       FromPlatformWritingMode(BlockStyle()->getWritingMode());
   RefPtr<NGConstraintSpace> constraint_space =
@@ skipping 68 matching lines @@
     Vector<NGLayoutInlineItem>* items,
     unsigned start_index,
     unsigned end_index)
     : start_item_(&(*items)[start_index]),
       size_(end_index - start_index),
       start_index_(start_index) {
   RELEASE_ASSERT(start_index <= end_index && end_index <= items->size());
 }
 
 }  // namespace blink