[LayoutNG] Inline margin/border/padding, inter-item breaking, and tests

third_party/WebKit/Source/core/layout/ng/inline/ng_line_breaker.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_line_breaker.h"
 
 #include "core/layout/ng/inline/ng_inline_break_token.h"
 #include "core/layout/ng/inline/ng_inline_layout_algorithm.h"
 #include "core/layout/ng/inline/ng_inline_node.h"
 #include "core/layout/ng/inline/ng_text_fragment.h"
 #include "core/layout/ng/ng_box_fragment.h"
 #include "core/layout/ng/ng_break_token.h"
 #include "core/layout/ng/ng_constraint_space.h"
 #include "core/layout/ng/ng_fragment_builder.h"
 #include "core/layout/ng/ng_layout_opportunity_iterator.h"
 #include "core/layout/ng/ng_length_utils.h"
 #include "core/style/ComputedStyle.h"
 #include "platform/fonts/shaping/HarfBuzzShaper.h"
 #include "platform/fonts/shaping/ShapingLineBreaker.h"
-#include "platform/text/TextBreakIterator.h"
 
 namespace blink {
 
 namespace {
 
 // Use a mock of ShapingLineBreaker for test/debug purposes.
 #define MOCK_SHAPE_LINE
 
 #if defined(MOCK_SHAPE_LINE)
 // The mock for ShapingLineBreaker::ShapeLine().
-// Given the design of ShapingLineBreaker, expected semantics are:
-// - The returned offset is always > item.StartOffset().
-// - offset < item.EndOffset():
-//   - width <= available_width: the break opportunity to fit is found.
-//   - width > available_width: the first break opportunity did not fit.
-// - offset == item.EndOffset():
-//   - width <= available_width: the break opportunity at the end of the item
-//     fits.
-//   - width > available_width: the first break opportunity is at the end of
-//     the item and it does not fit.
-// - offset > item.EndOffset():, the first break opportunity is beyond the
-//   end of item and thus cannot measure. In this case, inline_size shows the
-//   width until the end of the item. It may fit or may not.
+// See BreakText() for the expected semantics.
 std::pair<unsigned, LayoutUnit> ShapeLineMock(
     const NGInlineItem& item,
     unsigned offset,
     LayoutUnit available_width,
     const LazyLineBreakIterator& break_iterator) {
   bool has_break_opportunities = false;
   LayoutUnit inline_size;
   while (true) {
     unsigned next_break = break_iterator.NextBreakOpportunity(offset + 1);
     LayoutUnit next_inline_size =
         inline_size +
         item.InlineSize(offset, std::min(next_break, item.EndOffset()));
     if (next_inline_size > available_width) {
       if (!has_break_opportunities)
         return std::make_pair(next_break, next_inline_size);
       return std::make_pair(offset, inline_size);
     }
     if (next_break >= item.EndOffset())
       return std::make_pair(next_break, next_inline_size);
     offset = next_break;
     inline_size = next_inline_size;
     has_break_opportunities = true;
   }
 }
 #endif
 
-LineBreakType GetLineBreakType(const ComputedStyle& style) {
-  if (style.AutoWrap()) {
-    if (style.WordBreak() == EWordBreak::kBreakAll ||
-        style.WordBreak() == EWordBreak::kBreakWord)
-      return LineBreakType::kBreakAll;
-    if (style.WordBreak() == EWordBreak::kKeepAll)
-      return LineBreakType::kKeepAll;
-  }
-  return LineBreakType::kNormal;
-}
-
 }  // namespace
 
 NGLineBreaker::NGLineBreaker(NGInlineNode* node,
                              const NGConstraintSpace* space,
                              NGInlineBreakToken* break_token)
-    : node_(node), constraint_space_(space), item_index_(0), offset_(0) {
+    : node_(node),
+      constraint_space_(space),
+      item_index_(0),
+      offset_(0),
+      break_iterator_(node->Text()) {
   if (break_token) {
     item_index_ = break_token->ItemIndex();
     offset_ = break_token->TextOffset();
     node->AssertOffset(item_index_, offset_);
   }
 }
 
 void NGLineBreaker::NextLine(NGInlineItemResults* item_results,
                              NGInlineLayoutAlgorithm* algorithm) {
   BreakLine(item_results, algorithm);
 
   // TODO(kojii): When editing, or caret is enabled, trailing spaces at wrap
   // point should not be removed. For other cases, we can a) remove, b) leave
   // characters without glyphs, or c) leave both characters and glyphs without
   // measuring. Need to decide which one works the best.
   SkipCollapsibleWhitespaces();
 }
 
 void NGLineBreaker::BreakLine(NGInlineItemResults* item_results,
                               NGInlineLayoutAlgorithm* algorithm) {
   DCHECK(item_results->IsEmpty());
   const Vector<NGInlineItem>& items = node_->Items();
-  const String& text = node_->Text();
   const ComputedStyle& style = node_->Style();
-  LazyLineBreakIterator break_iterator(text, style.LocaleForLineBreakIterator(),
-                                       GetLineBreakType(style));
+  UpdateBreakIterator(style);
 #if !defined(MOCK_SHAPE_LINE)
+  // TODO(kojii): Instantiate in the constructor.
   HarfBuzzShaper shaper(text.Characters16(), text.length());
 #endif
-  LayoutUnit available_width = algorithm->AvailableWidth();
-  LayoutUnit position;
+  available_width_ = algorithm->AvailableWidth();
+  position_ = LayoutUnit(0);
+  LineBreakState state = LineBreakState::kNotBreakable;
+
   while (item_index_ < items.size()) {

[ikilpatrick, 2017/05/30 16:05:26]

If i get time this week i'll play with pulling this up to the algorithm just to
see what it looks like. 

[kojii, 2017/05/30 17:56:18]

Sounds good, will work on other files this week.

+    // CloseTag prohibits to break before.
     const NGInlineItem& item = items[item_index_];
+    if (item.Type() == NGInlineItem::kCloseTag) {
+      item_results->push_back(
+          NGInlineItemResult(item_index_, offset_, item.EndOffset()));
+      HandleCloseTag(item, &item_results->back());
+      continue;
+    }
+
+    if (state == LineBreakState::kBreakAfterTrailings)
+      return;
+    if (state == LineBreakState::kIsBreakable && position_ > available_width_)
+      return HandleOverflow(item_results);
+
     item_results->push_back(
         NGInlineItemResult(item_index_, offset_, item.EndOffset()));
     NGInlineItemResult* item_result = &item_results->back();
+    if (item.Type() == NGInlineItem::kText) {
+      state = HandleText(item, item_result);
+    } else if (item.Type() == NGInlineItem::kAtomicInline) {
+      state = HandleAtomicInline(item, item_result);
+    } else if (item.Type() == NGInlineItem::kControl) {
+      state = HandleControlItem(item, item_result);
+      if (state == LineBreakState::kForcedBreak)
+        return;
+    } else if (item.Type() == NGInlineItem::kOpenTag) {
+      HandleOpenTag(item, item_result);
+      state = LineBreakState::kNotBreakable;
+    } else if (item.Type() == NGInlineItem::kFloating) {
+      HandleFloat(item, item_results, algorithm);
+    } else {
+      MoveToNextOf(item);
+    }
+  }
+  if (state == LineBreakState::kIsBreakable && position_ > available_width_)
+    return HandleOverflow(item_results);
+}
 
-    // If the start offset is at the item boundary, try to add the entire item.
-    if (offset_ == item.StartOffset()) {
-      if (item.Type() == NGInlineItem::kText) {
-        item_result->inline_size = item.InlineSize();
-      } else if (item.Type() == NGInlineItem::kAtomicInline) {
-        LayoutAtomicInline(item, item_result);
-      } else if (item.Type() == NGInlineItem::kControl) {
-        if (HandleControlItem(item, text, item_result, position)) {
-          MoveToNextOf(item);
-          break;
-        }
-      } else if (item.Type() == NGInlineItem::kFloating) {
-        algorithm->LayoutAndPositionFloat(position, item.GetLayoutObject());
-        // Floats may change the available width if they fit.
-        available_width = algorithm->AvailableWidth();
-        // Floats are already positioned in the container_builder.
-        item_results->pop_back();
-        MoveToNextOf(item);
-        continue;
-      } else {
-        MoveToNextOf(item);
-        continue;
-      }
-      LayoutUnit next_position = position + item_result->inline_size;
-      if (next_position <= available_width) {
-        MoveToNextOf(item);
-        position = next_position;
-        continue;
-      }
+NGLineBreaker::LineBreakState NGLineBreaker::HandleText(
+    const NGInlineItem& item,
+    NGInlineItemResult* item_result) {
+  DCHECK_EQ(item.Type(), NGInlineItem::kText);
 
-      // The entire item does not fit. Handle non-text items as overflow,
-      // since only text item is breakable.
-      if (item.Type() != NGInlineItem::kText) {
-        MoveToNextOf(item);
-        return HandleOverflow(item_results, break_iterator);
-      }
+  // If the start offset is at the item boundary, try to add the entire item.
+  if (offset_ == item.StartOffset()) {
+    item_result->inline_size = item.InlineSize();
+    LayoutUnit next_position = position_ + item_result->inline_size;
+    if (!auto_wrap_ || next_position <= available_width_) {
+      position_ = next_position;
+      MoveToNextOf(item);
+      if (auto_wrap_ && break_iterator_.IsBreakable(item.EndOffset()))
+        return LineBreakState::kIsBreakable;
+      item_result->prohibit_break_after = true;
+      return LineBreakState::kNotBreakable;
     }
+  }
 
-    // Either the start or the break is in the mid of a text item.
-    DCHECK_EQ(item.Type(), NGInlineItem::kText);
-    DCHECK_LT(offset_, item.EndOffset());
-    break_iterator.SetLocale(item.Style()->LocaleForLineBreakIterator());
-    break_iterator.SetBreakType(GetLineBreakType(*item.Style()));
+  if (auto_wrap_) {
+    // Try to break inside of this text item.
+    BreakText(item_result, item, available_width_ - position_);
+    position_ += item_result->inline_size;
+
+    bool is_overflow = position_ > available_width_;
+    item_result->no_break_opportunities_inside = is_overflow;
+    if (item_result->end_offset < item.EndOffset()) {
+      offset_ = item_result->end_offset;
+      return is_overflow ? LineBreakState::kIsBreakable
+                         : LineBreakState::kBreakAfterTrailings;
+    }
+    MoveToNextOf(item);
+    return item_result->prohibit_break_after ? LineBreakState::kNotBreakable
+                                             : LineBreakState::kIsBreakable;
+  }
+
+  // Add the rest of the item if !auto_wrap.
+  // Because the start position may need to reshape, run ShapingLineBreaker
+  // with max available width.
+  DCHECK_NE(offset_, item.StartOffset());
+  BreakText(item_result, item, LayoutUnit::Max());
+  DCHECK_EQ(item_result->end_offset, item.EndOffset());
+  item_result->no_break_opportunities_inside = true;
+  item_result->prohibit_break_after = true;
+  position_ += item_result->inline_size;
+  MoveToNextOf(item);
+  return LineBreakState::kNotBreakable;
+}
+
+void NGLineBreaker::BreakText(NGInlineItemResult* item_result,
+                              const NGInlineItem& item,
+                              LayoutUnit available_width) {
+  DCHECK_EQ(item.Type(), NGInlineItem::kText);
+  item.AssertOffset(item_result->start_offset);
+
 #if defined(MOCK_SHAPE_LINE)
-    unsigned break_offset;
-    std::tie(break_offset, item_result->inline_size) = ShapeLineMock(
-        item, offset_, available_width - position, break_iterator);
+  std::tie(item_result->end_offset, item_result->inline_size) = ShapeLineMock(
+      item, item_result->start_offset, available_width, break_iterator_);
 #else
-    // TODO(kojii): We need to instantiate ShapingLineBreaker here because it
-    // has item-specific info as context. Should they be part of ShapeLine() to
-    // instantiate once, or is this just fine since instatiation is not
-    // expensive?
-    DCHECK_EQ(item.TextShapeResult()->StartIndexForResult(),
-              item.StartOffset());
-    DCHECK_EQ(item.TextShapeResult()->EndIndexForResult(), item.EndOffset());
-    ShapingLineBreaker breaker(&shaper, &item.Style()->GetFont(),
-                               item.TextShapeResult(), &break_iterator);
-    unsigned break_offset;
-    item_result->shape_result =
-        breaker.ShapeLine(offset_, available_width - position, &break_offset);
-    item_result->inline_size = item_result->shape_result->SnappedWidth();
+  // TODO(kojii): We need to instantiate ShapingLineBreaker here because it
+  // has item-specific info as context. Should they be part of ShapeLine() to
+  // instantiate once, or is this just fine since instatiation is not
+  // expensive?
+  DCHECK_EQ(item.TextShapeResult()->StartIndexForResult(), item.StartOffset());
+  DCHECK_EQ(item.TextShapeResult()->EndIndexForResult(), item.EndOffset());
+  ShapingLineBreaker breaker(&shaper, &item.Style()->GetFont(),
+                             item.TextShapeResult(), break_iterator_);
+  item_result->shape_result = breaker.ShapeLine(
+      item_result->start_offset, available_width, &item_result->end_offset);
+  item_result->inline_size = item_result->shape_result->SnappedWidth();
 #endif
-    DCHECK_GT(break_offset, offset_);
-    position += item_result->inline_size;
-
-    // If the break found within the item, break here.
-    if (break_offset < item.EndOffset()) {
-      offset_ = item_result->end_offset = break_offset;
-      if (position <= available_width)
-        break;
-      // The first break opportunity of the item does not fit.
-    } else {
-      // No break opporunity in the item, or the first break opportunity is at
-      // the end of the item. If it fits, continue to the next item.
-      item_result->end_offset = item.EndOffset();
-      MoveToNextOf(item);
-      if (position <= available_width)
-        continue;
-    }
-
-    // We need to look at next item if we're overflowing, and the break
-    // opportunity is beyond this item.
-    if (break_offset > item.EndOffset())
-      continue;
-    return HandleOverflow(item_results, break_iterator);
+  DCHECK_GT(item_result->end_offset, item_result->start_offset);
+  // * If width <= available_width:
+  //   * If offset < item.EndOffset(): the break opportunity to fit is found.
+  //   * If offset == item.EndOffset(): the break opportunity at the end fits.
+  //     There may be room for more characters.
+  //   * If offset > item.EndOffset(): the first break opportunity is beyond
+  //     the end. There may be room for more characters.
+  // * If width > available_width: The first break opporunity does not fit.
+  //   offset is the first break opportunity, either inside, at the end, or
+  //   beyond the end.
+  if (item_result->end_offset <= item.EndOffset()) {
+    item_result->prohibit_break_after = false;
+  } else {
+    item_result->prohibit_break_after = true;
+    item_result->end_offset = item.EndOffset();
   }
 }
 
 // Measure control items; new lines and tab, that are similar to text, affect
 // layout, but do not need shaping/painting.
-bool NGLineBreaker::HandleControlItem(const NGInlineItem& item,
-                                      const String& text,
-                                      NGInlineItemResult* item_result,
-                                      LayoutUnit position) {
+NGLineBreaker::LineBreakState NGLineBreaker::HandleControlItem(
+    const NGInlineItem& item,
+    NGInlineItemResult* item_result) {
   DCHECK_EQ(item.Length(), 1u);
-  UChar character = text[item.StartOffset()];
-  if (character == kNewlineCharacter)
-    return true;
-
+  UChar character = node_->Text()[item.StartOffset()];
+  if (character == kNewlineCharacter) {
+    MoveToNextOf(item);
+    return LineBreakState::kForcedBreak;
+  }
   DCHECK_EQ(character, kTabulationCharacter);
   DCHECK(item.Style());
   const ComputedStyle& style = *item.Style();
   const Font& font = style.GetFont();
-  item_result->inline_size = font.TabWidth(style.GetTabSize(), position);
-  return false;
+  item_result->inline_size = font.TabWidth(style.GetTabSize(), position_);
+  position_ += item_result->inline_size;
+  MoveToNextOf(item);
+  // TODO(kojii): Implement break around the tab character.
+  return LineBreakState::kIsBreakable;
 }
 
-void NGLineBreaker::LayoutAtomicInline(const NGInlineItem& item,
-                                       NGInlineItemResult* item_result) {
+NGLineBreaker::LineBreakState NGLineBreaker::HandleAtomicInline(
+    const NGInlineItem& item,
+    NGInlineItemResult* item_result) {
   DCHECK_EQ(item.Type(), NGInlineItem::kAtomicInline);
   NGBlockNode* node = new NGBlockNode(item.GetLayoutObject());
   const ComputedStyle& style = node->Style();
   NGConstraintSpaceBuilder constraint_space_builder(constraint_space_);
   RefPtr<NGConstraintSpace> constraint_space =
       constraint_space_builder.SetIsNewFormattingContext(true)
           .SetIsShrinkToFit(true)
           .SetTextDirection(style.Direction())
           .ToConstraintSpace(FromPlatformWritingMode(style.GetWritingMode()));
   item_result->layout_result = node->Layout(constraint_space.Get());
 
   item_result->inline_size =
       NGBoxFragment(constraint_space_->WritingMode(),
                     ToNGPhysicalBoxFragment(
                         item_result->layout_result->PhysicalFragment().Get()))
           .InlineSize();
 
   item_result->margins =
       ComputeMargins(*constraint_space_, style,
                      constraint_space_->WritingMode(), style.Direction());
   item_result->inline_size += item_result->margins.InlineSum();
+
+  position_ += item_result->inline_size;
+  MoveToNextOf(item);
+  if (auto_wrap_)
+    return LineBreakState::kIsBreakable;
+  item_result->prohibit_break_after = true;
+  return LineBreakState::kNotBreakable;
+}
+
+void NGLineBreaker::HandleFloat(const NGInlineItem& item,
+                                NGInlineItemResults* item_results,
+                                NGInlineLayoutAlgorithm* algorithm) {
+  algorithm->LayoutAndPositionFloat(position_, item.GetLayoutObject());
+  // Floats may change the available width if they fit.
+  available_width_ = algorithm->AvailableWidth();
+  // Floats are already positioned in the container_builder.
+  item_results->pop_back();
+  MoveToNextOf(item);
+}
+
+void NGLineBreaker::HandleOpenTag(const NGInlineItem& item,
+                                  NGInlineItemResult* item_result) {
+  if (item.HasStartEdge()) {
+    DCHECK(item.Style());
+    // TODO(kojii): We compute 16 values and discard 12 out of that, and do it 3
+    // times per element. We may want to cache this. crrev.com/2865903002/#msg14
+    NGBoxStrut margins = ComputeMargins(*constraint_space_, *item.Style(),
+                                        constraint_space_->WritingMode(),
+                                        constraint_space_->Direction());
+    NGBoxStrut borders = ComputeBorders(*constraint_space_, *item.Style());
+    NGBoxStrut paddings = ComputePadding(*constraint_space_, *item.Style());
+    item_result->inline_size =
+        margins.inline_start + borders.inline_start + paddings.inline_start;
+    position_ += item_result->inline_size;
+  }
+  UpdateBreakIterator(*item.Style());
+  MoveToNextOf(item);
+}
+
+void NGLineBreaker::HandleCloseTag(const NGInlineItem& item,
+                                   NGInlineItemResult* item_result) {
+  if (item.HasEndEdge()) {
+    DCHECK(item.Style());
+    NGBoxStrut margins = ComputeMargins(*constraint_space_, *item.Style(),
+                                        constraint_space_->WritingMode(),
+                                        constraint_space_->Direction());
+    NGBoxStrut borders = ComputeBorders(*constraint_space_, *item.Style());
+    NGBoxStrut paddings = ComputePadding(*constraint_space_, *item.Style());
+    item_result->inline_size =
+        margins.inline_end + borders.inline_end + paddings.inline_end;
+    position_ += item_result->inline_size;
+  }
+  DCHECK(item.GetLayoutObject() && item.GetLayoutObject()->Parent());
+  UpdateBreakIterator(item.GetLayoutObject()->Parent()->StyleRef());
+  MoveToNextOf(item);
 }
 
 // Handles when the last item overflows.
 // At this point, item_results does not fit into the current line, and there
 // are no break opportunities in item_results.back().
-void NGLineBreaker::HandleOverflow(
-    NGInlineItemResults* item_results,
-    const LazyLineBreakIterator& break_iterator) {
-  DCHECK_GT(offset_, 0u);
+void NGLineBreaker::HandleOverflow(NGInlineItemResults* item_results) {
+  const Vector<NGInlineItem>& items = node_->Items();
+  LayoutUnit rewind_width = available_width_ - position_;
+  DCHECK_LT(rewind_width, 0);
 
-  // Find the last break opportunity. If none, let this line overflow.
-  unsigned line_start_offset = item_results->front().start_offset;
-  unsigned break_offset =
-      break_iterator.PreviousBreakOpportunity(offset_ - 1, line_start_offset);
-  if (!break_offset || break_offset <= line_start_offset) {
-    AppendCloseTags(item_results);
-    return;
+  // Search for a break opportunity that can fit.
+  // Also keep track of the first break opportunity in case of overflow.
+  unsigned break_before = 0;
+  unsigned break_before_if_before_allow = 0;
+  LayoutUnit rewind_width_if_before_allow;
+  bool last_item_prohibits_break_before = true;
+  for (unsigned i = item_results->size(); i;) {
+    NGInlineItemResult* item_result = &(*item_results)[--i];
+    const NGInlineItem& item = items[item_result->item_index];
+    rewind_width += item_result->inline_size;
+    if (item.Type() == NGInlineItem::kText ||
+        item.Type() == NGInlineItem::kAtomicInline) {
+      // Try to break inside of this item.
+      if (item.Type() == NGInlineItem::kText && rewind_width >= 0 &&
+          !item_result->no_break_opportunities_inside) {
+        // When the text fits but its right margin does not, the break point
+        // must not be at the end.
+        LayoutUnit item_available_width =
+            std::min(rewind_width, item_result->inline_size - 1);
+        BreakText(item_result, item, item_available_width);
+        if (item_result->inline_size <= item_available_width) {
+          DCHECK_LT(item_result->end_offset, item.EndOffset());
+          DCHECK(!item_result->prohibit_break_after);
+          return Rewind(item_results, i + 1);
+        }
+        if (!item_result->prohibit_break_after &&
+            !last_item_prohibits_break_before) {
+          break_before = i + 1;
+        }
+      }
+
+      // Try to break after this item.
+      if (break_before_if_before_allow && !item_result->prohibit_break_after) {
+        if (rewind_width_if_before_allow >= 0)
+          return Rewind(item_results, break_before_if_before_allow);
+        break_before = break_before_if_before_allow;
+      }
+
+      // Otherwise, before this item is a possible break point.
+      break_before_if_before_allow = i;
+      rewind_width_if_before_allow = rewind_width;
+      last_item_prohibits_break_before = false;
+    } else if (item.Type() == NGInlineItem::kCloseTag) {
+      last_item_prohibits_break_before = true;
+    } else {
+      if (i + 1 == break_before_if_before_allow) {
+        break_before_if_before_allow = i;
+        rewind_width_if_before_allow = rewind_width;
+      }
+      last_item_prohibits_break_before = false;
+    }
   }
 
-  // Truncate the end of the line to the break opportunity.
-  const Vector<NGInlineItem>& items = node_->Items();
-  unsigned new_end = item_results->size();
-  while (true) {
-    NGInlineItemResult* item_result = &(*item_results)[--new_end];
-    if (item_result->start_offset < break_offset) {
-      // The break is at the mid of the item. Adjust the end_offset to the new
-      // break offset.
-      const NGInlineItem& item = items[item_result->item_index];
-      item.AssertEndOffset(break_offset);
-      DCHECK_EQ(item.Type(), NGInlineItem::kText);
-      DCHECK_NE(item_result->end_offset, break_offset);
-      item_result->end_offset = break_offset;
-      item_result->inline_size =
-          item.InlineSize(item_result->start_offset, item_result->end_offset);
-      // TODO(kojii): May need to reshape. Add to ShapingLineBreaker?
-      new_end++;
-      break;
-    }
-    if (item_result->start_offset == break_offset) {
-      // The new break offset is at the item boundary. Remove items up to the
-      // new break offset.
-      // TODO(kojii): Remove open tags as well.
-      break;
-    }
-  }
-  DCHECK_GT(new_end, 0u);
+  // The rewind point did not found, let this line overflow.
+  // If there was a break opporunity, the overflow should stop there.
+  if (break_before)
+    Rewind(item_results, break_before);
+}
 
+void NGLineBreaker::Rewind(NGInlineItemResults* item_results,
+                           unsigned new_end) {
   // TODO(kojii): Should we keep results for the next line? We don't need to
   // re-layout atomic inlines.
   // TODO(kojii): Removing processed floats is likely a problematic. Keep
   // floats in this line, or keep it for the next line.
   item_results->Shrink(new_end);
 
-  // Update the current item index and offset to the new break point.
-  const NGInlineItemResult& last_item_result = item_results->back();
-  offset_ = last_item_result.end_offset;
-  item_index_ = last_item_result.item_index;
-  if (items[item_index_].EndOffset() == offset_)
-    item_index_++;
+  MoveToNextOf(item_results->back());
+}
+
+void NGLineBreaker::UpdateBreakIterator(const ComputedStyle& style) {
+  auto_wrap_ = style.AutoWrap();
+
+  if (auto_wrap_) {
+    break_iterator_.SetLocale(style.LocaleForLineBreakIterator());
+
+    if (style.WordBreak() == EWordBreak::kBreakAll ||
+        style.WordBreak() == EWordBreak::kBreakWord) {
+      break_iterator_.SetBreakType(LineBreakType::kBreakAll);
+    } else if (style.WordBreak() == EWordBreak::kKeepAll) {
+      break_iterator_.SetBreakType(LineBreakType::kKeepAll);
+    } else {
+      break_iterator_.SetBreakType(LineBreakType::kNormal);
+    }
+
+    // TODO(kojii): Implement word-wrap/overflow-wrap property
+  }
 }
 
 void NGLineBreaker::MoveToNextOf(const NGInlineItem& item) {
   DCHECK_EQ(&item, &node_->Items()[item_index_]);
   offset_ = item.EndOffset();
   item_index_++;
 }
 
+void NGLineBreaker::MoveToNextOf(const NGInlineItemResult& item_result) {
+  offset_ = item_result.end_offset;
+  item_index_ = item_result.item_index;
+  const NGInlineItem& item = node_->Items()[item_result.item_index];
+  if (offset_ == item.EndOffset())
+    item_index_++;
+}
+
 void NGLineBreaker::SkipCollapsibleWhitespaces() {
   const Vector<NGInlineItem>& items = node_->Items();
   if (item_index_ >= items.size())
     return;
   const NGInlineItem& item = items[item_index_];
   if (item.Type() != NGInlineItem::kText || !item.Style()->CollapseWhiteSpace())
     return;
 
   DCHECK_LT(offset_, item.EndOffset());
   if (node_->Text()[offset_] == kSpaceCharacter) {
     // Skip one whitespace. Collapsible spaces are collapsed to single space in
     // NGInlineItemBuilder, so this removes all collapsible spaces.
     offset_++;
     if (offset_ == item.EndOffset())
       item_index_++;
   }
 }
 
-void NGLineBreaker::AppendCloseTags(NGInlineItemResults* item_results) {
-  const Vector<NGInlineItem>& items = node_->Items();
-  for (; item_index_ < items.size(); item_index_++) {
-    const NGInlineItem& item = items[item_index_];
-    if (item.Type() != NGInlineItem::kCloseTag)
-      break;
-    DCHECK_EQ(offset_, item.EndOffset());
-    item_results->push_back(NGInlineItemResult(item_index_, offset_, offset_));
-  }
-}
-
 RefPtr<NGInlineBreakToken> NGLineBreaker::CreateBreakToken() const {
   const Vector<NGInlineItem>& items = node_->Items();
   if (item_index_ >= items.size())
     return nullptr;
   return NGInlineBreakToken::Create(node_, item_index_, offset_);
 }
 
 }  // namespace blink