[LayoutNG] Add NGInlineBreakToken and back of NGInlineLayoutAlgorithm

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"
 #include "core/layout/ng/ng_box_fragment.h"
 #include "core/layout/ng/ng_constraint_space_builder.h"
 #include "core/layout/ng/ng_fragment_builder.h"
+#include "core/layout/ng/ng_inline_break_token.h"
+#include "core/layout/ng/ng_inline_layout_algorithm.h"
 #include "core/layout/ng/ng_layout_inline_items_builder.h"
-#include "core/layout/ng/ng_line_builder.h"
 #include "core/layout/ng/ng_physical_box_fragment.h"
 #include "core/layout/ng/ng_physical_text_fragment.h"
 #include "core/layout/ng/ng_text_fragment.h"
-#include "core/layout/ng/ng_text_layout_algorithm.h"
 #include "core/style/ComputedStyle.h"
 #include "platform/fonts/CharacterRange.h"
 #include "platform/fonts/shaping/CachingWordShapeIterator.h"
 #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 {
 
@@ skipping 56 matching lines @@
   LayoutObject* node = start;
   while (node) {
     if (node->isText()) {
       builder->SetIsSVGText(node->isSVGInlineText());
       builder->Append(toLayoutText(node)->text(), node->style(), node);
       node->clearNeedsLayout();
 
     } else if (node->isFloating()) {
       // Add floats and positioned objects in the same way as atomic inlines.
       // Because these objects need positions, they will be handled in
-      // NGLineBuilder.
+      // NGInlineLayoutAlgorithm.
       builder->Append(NGLayoutInlineItem::kFloating, objectReplacementCharacter,
                       nullptr, node);
     } else if (node->isOutOfFlowPositioned()) {
       builder->Append(NGLayoutInlineItem::kOutOfFlowPositioned,
                       objectReplacementCharacter, nullptr, node);
 
     } else if (!node->isInline()) {
       // A block box found. End inline and transit to block layout.
       return node;
 
@@ skipping 119 matching lines @@
 void NGLayoutInlineItem::SetEndOffset(unsigned end_offset) {
   DCHECK_GE(end_offset, start_offset_);
   end_offset_ = end_offset;
 }
 
 LayoutUnit NGLayoutInlineItem::InlineSize() const {
   if (Type() == NGLayoutInlineItem::kText)
     return LayoutUnit(shape_result_->width());
 
   DCHECK(Type() != NGLayoutInlineItem::kAtomicInline)
-      << "Use NGLineBuilder::InlineSize";
+      << "Use NGInlineLayoutAlgorithm::InlineSize";
   // Bidi controls and out-of-flow objects do not have in-flow widths.
   return LayoutUnit();
 }
 
 LayoutUnit NGLayoutInlineItem::InlineSize(unsigned start, unsigned end) const {
   DCHECK(start >= StartOffset() && start <= end && end <= EndOffset());
 
   if (start == end)
     return LayoutUnit();
   if (start == start_offset_ && end == end_offset_)
@@ skipping 25 matching lines @@
   for (auto& item : items_) {
     if (item.Type() != NGLayoutInlineItem::kText)
       continue;
 
     item.shape_result_ = shaper.shape(&item.Style()->font(), item.Direction(),
                                       item.StartOffset(), item.EndOffset());
   }
 }
 
 RefPtr<NGLayoutResult> NGInlineNode::Layout(NGConstraintSpace* constraint_space,
-                                            NGBreakToken*) {
+                                            NGBreakToken* break_token) {
   // TODO(kojii): Invalidate PrepareLayout() more efficiently.
   InvalidatePrepareLayout();
-  NGLineBuilder line_builder(this, constraint_space);
-  Layout(&line_builder);
-  RefPtr<NGLayoutResult> result = line_builder.CreateFragments();
-  line_builder.CopyFragmentDataToLayoutBlockFlow();
+  PrepareLayout();
+
+  NGInlineLayoutAlgorithm algorithm(this, constraint_space,
+                                    toNGInlineBreakToken(break_token));
+  RefPtr<NGLayoutResult> result = algorithm.Layout();
+  algorithm.CopyFragmentDataToLayoutBlockFlow(result.get());
   return result;
 }
 
-void NGInlineNode::Layout(NGLineBuilder* line_builder) {
+MinMaxContentSize NGInlineNode::ComputeMinMaxContentSize() {
   if (!IsPrepareLayoutFinished())
     PrepareLayout();
 
-  if (text_content_.isEmpty())
-    return;
-
-  NGTextLayoutAlgorithm(this).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 =
       NGConstraintSpaceBuilder(writing_mode)
           .SetTextDirection(BlockStyle()->direction())
           .SetAvailableSize({LayoutUnit(), NGSizeIndefinite})
           .ToConstraintSpace(writing_mode);
-  NGLineBuilder line_builder(this, constraint_space.get());
-  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 += line_builder.InlineSize(item);
-
-  return sizes;
+  NGInlineLayoutAlgorithm algorithm(this, constraint_space.get());
+  return algorithm.ComputeMinMaxContentSizeByLayout();
 }
 
 NGLayoutInputNode* NGInlineNode::NextSibling() {
   if (!IsPrepareLayoutFinished())
     PrepareLayout();
   return next_sibling_;
 }
 
 LayoutObject* NGInlineNode::GetLayoutObject() {
   return GetLayoutBlockFlow();
@@ skipping 44 matching lines @@
     unsigned start_index,
     unsigned end_index)
     : start_item_(&(*items)[start_index]),
       size_(end_index - start_index),
       start_index_(start_index) {
   CHECK_LE(start_index, end_index);
   CHECK_LE(end_index, items->size());
 }
 
 }  // namespace blink