[LayoutNG] Refactor NGLineBreaker for ShapingLineBreaker

third_party/WebKit/Source/core/layout/ng/inline/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/inline/ng_inline_node.h"
 
 #include "core/layout/BidiRun.h"
 #include "core/layout/LayoutBlockFlow.h"
 #include "core/layout/LayoutObject.h"
 #include "core/layout/LayoutText.h"
 #include "core/layout/line/LineInfo.h"
 #include "core/layout/line/RootInlineBox.h"
 #include "core/layout/ng/inline/ng_bidi_paragraph.h"
 #include "core/layout/ng/inline/ng_inline_break_token.h"
 #include "core/layout/ng/inline/ng_inline_item.h"
 #include "core/layout/ng/inline/ng_inline_items_builder.h"
 #include "core/layout/ng/inline/ng_inline_layout_algorithm.h"
 #include "core/layout/ng/inline/ng_line_box_fragment.h"
+#include "core/layout/ng/inline/ng_line_breaker.h"
 #include "core/layout/ng/inline/ng_physical_line_box_fragment.h"
 #include "core/layout/ng/inline/ng_physical_text_fragment.h"
 #include "core/layout/ng/inline/ng_text_fragment.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_physical_box_fragment.h"
 #include "core/style/ComputedStyle.h"
 #include "platform/fonts/shaping/HarfBuzzShaper.h"
 #include "platform/wtf/text/CharacterNames.h"
@@ skipping 172 matching lines @@
                                     ToNGInlineBreakToken(break_token));
   RefPtr<NGLayoutResult> result = algorithm.Layout();
   CopyFragmentDataToLayoutBox(*constraint_space, result.Get());
   return result;
 }
 
 MinMaxContentSize NGInlineNode::ComputeMinMaxContentSize() {
   if (!IsPrepareLayoutFinished())
     PrepareLayout();
 
-  // 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(Style().GetWritingMode());
-  RefPtr<NGConstraintSpace> constraint_space =
-      NGConstraintSpaceBuilder(writing_mode)
-          .SetTextDirection(Style().Direction())
-          .SetAvailableSize({LayoutUnit(), NGSizeIndefinite})
-          .ToConstraintSpace(writing_mode);
-  NGInlineLayoutAlgorithm algorithm(this, constraint_space.Get());
-  return algorithm.ComputeMinMaxContentSizeByLayout();
+  const ComputedStyle& style = Style();
+  NGWritingMode writing_mode = FromPlatformWritingMode(style.GetWritingMode());
+  NGConstraintSpaceBuilder space_builder(writing_mode);
+  space_builder.SetTextDirection(style.Direction());
+
+  MinMaxContentSize sizes;
+  NGInlineItemResults item_results;
+  RefPtr<NGConstraintSpace> space;
+  {

[eae, 2017/05/10 21:31:38]

Could we break these blocks out into separate static functions or private
members? Or better yet, perhaps a single templetized one so we can share the
bulk of the logic?

[kojii, 2017/05/11 16:17:36]

Done. I'd like this to be more efficient than running two line breaking,
hopefully before we ship. Added comment.

+    // 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.
+    space_builder.SetAvailableSize({LayoutUnit(), NGSizeIndefinite});
+    space = space_builder.ToConstraintSpace(writing_mode);
+    NGLineBreaker line_breaker(this, space.Get());
+    NGInlineLayoutAlgorithm algorithm(this, space.Get());
+    while (true) {
+      line_breaker.NextLine(&item_results, &algorithm);
+      if (item_results.IsEmpty())
+        break;
+      LayoutUnit inline_size;
+      for (const NGInlineItemResult item_result : item_results)
+        inline_size += item_result.inline_size;
+      sizes.min_content = std::max(inline_size, sizes.min_content);
+      item_results.clear();
+    }
+  }
+
+  {
+    // TODO(kojii): NGConstraintSpaceBuilder does not allow NGSizeIndefinite
+    // inline available size. We can allow it, or make this more efficient
+    // without using NGLineBreaker.
+    space_builder.SetAvailableSize({LayoutUnit::Max(), NGSizeIndefinite});
+    space = space_builder.ToConstraintSpace(writing_mode);
+    NGLineBreaker line_breaker(this, space.Get());
+    NGInlineLayoutAlgorithm algorithm(this, space.Get());
+    while (true) {
+      line_breaker.NextLine(&item_results, &algorithm);
+      if (item_results.IsEmpty())
+        break;
+      for (const NGInlineItemResult item_result : item_results)
+        sizes.max_content += item_result.inline_size;
+      item_results.clear();
+    }
+  }
+
+  return sizes;
 }
 
 NGLayoutInputNode* NGInlineNode::NextSibling() {
   if (!IsPrepareLayoutFinished())
     PrepareLayout();
   return next_sibling_;
 }
 
 LayoutObject* NGInlineNode::GetLayoutObject() const {
   return GetLayoutBlockFlow();
@@ skipping 135 matching lines @@
 String NGInlineNode::ToString() const {
   return String::Format("NGInlineNode");
 }
 
 DEFINE_TRACE(NGInlineNode) {
   visitor->Trace(next_sibling_);
   NGLayoutInputNode::Trace(visitor);
 }
 
 }  // namespace blink