[LayoutNG] Implement LayoutBR/preserved newlines and tabs

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"
@@ skipping 109 matching lines @@
     item_results->push_back(
         NGInlineItemResult(item_index_, offset_, item.EndOffset()));
     NGInlineItemResult* item_result = &item_results->back();
 
     // 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();
-        offset_ = item.EndOffset();
-        item_index_++;
+        MoveToNextOf(item);
         continue;
       } else {
-        offset_ = item.EndOffset();
-        item_index_++;
+        MoveToNextOf(item);
         continue;
       }
       LayoutUnit next_position = position + item_result->inline_size;
       if (next_position <= available_width) {
-        offset_ = item.EndOffset();
-        item_index_++;
+        MoveToNextOf(item);
         position = next_position;
         continue;
       }
 
       // The entire item does not fit. Handle non-text items as overflow,
       // since only text item is breakable.
       if (item.Type() != NGInlineItem::kText) {
-        offset_ = item.EndOffset();
-        item_index_++;
+        MoveToNextOf(item);
         return HandleOverflow(item_results, break_iterator);
       }
     }
 
     // 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 defined(MOCK_SHAPE_LINE)
@@ skipping 20 matching lines @@
 
     // 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.
-      offset_ = item_result->end_offset = item.EndOffset();
-      item_index_++;
+      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);
   }
 }
 
+// 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) {
+  DCHECK_EQ(item.Length(), 1u);
+  UChar character = text[item.StartOffset()];
+  if (character == kNewlineCharacter)
+    return true;
+
+  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;
+}
+
 void NGLineBreaker::LayoutAtomicInline(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())
@@ skipping 64 matching lines @@
   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_++;
 }
 
+void NGLineBreaker::MoveToNextOf(const NGInlineItem& item) {
+  DCHECK_EQ(&item, &node_->Items()[item_index_]);
+  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) {
@@ skipping 17 matching lines @@
 }
 
 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