[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 201 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_);
+    DCHECK(!IsAtomicInlineLevel()) << "Use NGLineBuilder::InlineSize";
+    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());
 }
 
+RefPtr<NGLayoutResult> NGLayoutInlineItem::Layout(
+    const NGConstraintSpace& parent_space) const {
+  DCHECK(IsAtomicInlineLevel());
+
+  NGBlockNode* node = new NGBlockNode(layout_object_);
+  // TODO(kojii): Keep node in NGLayoutInlineItem.
+  const ComputedStyle& style = node->Style();
+  NGConstraintSpaceBuilder constraint_space_builder(&parent_space);

[ikilpatrick, 2017/03/16 16:15:40]

we should do this in the parents call, ::Layout takes the space it should
layout, not the parents space.

[kojii, 2017/03/16 16:48:45]

Moved this function to NGLineBuilder, please see there.

+  RefPtr<NGConstraintSpace> constraint_space =
+      constraint_space_builder.SetIsNewFormattingContext(true)
+          .SetIsShrinkToFit(true)
+          .SetTextDirection(style.direction())
+          .ToConstraintSpace(FromPlatformWritingMode(style.getWritingMode()));
+  return node->Layout(constraint_space.get());
+}
+
 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();
@@ skipping 34 matching lines @@
           .SetAvailableSize({LayoutUnit(), NGSizeIndefinite})
           .ToConstraintSpace(writing_mode);
   NGLineBuilder line_builder(this, constraint_space.get(), nullptr);
   Layout(&line_builder);
   MinMaxContentSize sizes;
   sizes.min_content = line_builder.MaxInlineSize();
 
   // max-content is the width without any line wrapping.
   // TODO(kojii): Implement hard breaks (<br> etc.) to break.
   for (const auto& item : items_)
-    sizes.max_content += item.InlineSize();
+    sizes.max_content += line_builder.InlineSize(item);
 
   return sizes;
 }
 
 NGLayoutInputNode* NGInlineNode::NextSibling() {
   if (!IsPrepareLayoutFinished())
     PrepareLayout();
   return next_sibling_;
 }
 
@@ skipping 45 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