[LayoutNG] Implement 'text-align-last'

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 53 matching lines @@
       offset_(0),
       break_iterator_(node.Text()),
       shaper_(node.Text().Characters16(), node.Text().length()) {
   if (break_token) {
     item_index_ = break_token->ItemIndex();
     offset_ = break_token->TextOffset();
     node.AssertOffset(item_index_, offset_);
   }
 }
 
-void NGLineBreaker::NextLine(NGInlineItemResults* item_results,
+bool NGLineBreaker::NextLine(NGLineInfo* line_info,
                              NGInlineLayoutAlgorithm* algorithm) {
-  BreakLine(item_results, algorithm);
+  BreakLine(line_info, 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();
+
+  return !line_info->Results().IsEmpty();
 }
 
-void NGLineBreaker::BreakLine(NGInlineItemResults* item_results,
+void NGLineBreaker::BreakLine(NGLineInfo* line_info,
                               NGInlineLayoutAlgorithm* algorithm) {
-  DCHECK(item_results->IsEmpty());
+  NGInlineItemResults* item_results = &line_info->Results();
+  item_results->clear();
   const Vector<NGInlineItem>& items = node_.Items();
-  const ComputedStyle& style = node_.Style();
-  UpdateBreakIterator(style);
+  line_info->SetLineStyle(node_, !item_index_ && !offset_);
+  UpdateBreakIterator(line_info->LineStyle());
   available_width_ = algorithm->AvailableWidth();
   position_ = LayoutUnit(0);
   LineBreakState state = LineBreakState::kNotBreakable;
 
   while (item_index_ < items.size()) {
     // 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)
+    if (state == LineBreakState::kBreakAfterTrailings) {
+      line_info->SetIsLastLine(false);
       return;
+    }
     if (state == LineBreakState::kIsBreakable && position_ > available_width_)
-      return HandleOverflow(item_results);
+      return HandleOverflow(line_info);
 
     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)
+      if (state == LineBreakState::kForcedBreak) {
+        line_info->SetIsLastLine(true);
         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);
+    return HandleOverflow(line_info);
+  line_info->SetIsLastLine(true);
 }
 
 NGLineBreaker::LineBreakState NGLineBreaker::HandleText(
     const NGInlineItem& item,
     NGInlineItemResult* item_result) {
   DCHECK_EQ(item.Type(), NGInlineItem::kText);
 
   // 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();
@@ skipping 184 matching lines @@
     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) {
+void NGLineBreaker::HandleOverflow(NGLineInfo* line_info) {
+  NGInlineItemResults* item_results = &line_info->Results();
   const Vector<NGInlineItem>& items = node_.Items();
   LayoutUnit rewind_width = available_width_ - position_;
   DCHECK_LT(rewind_width, 0);
 
   // 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);
+          return Rewind(line_info, 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);
+          return Rewind(line_info, 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;
     }
   }
 
   // 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);
+    return Rewind(line_info, break_before);
+
+  line_info->SetIsLastLine(item_index_ >= items.size());
 }
 
-void NGLineBreaker::Rewind(NGInlineItemResults* item_results,
-                           unsigned new_end) {
+void NGLineBreaker::Rewind(NGLineInfo* line_info, unsigned new_end) {
+  NGInlineItemResults* item_results = &line_info->Results();
   // 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);
 
   MoveToNextOf(item_results->back());
+  DCHECK_LT(item_index_, node_.Items().size());
+  line_info->SetIsLastLine(false);
 }
 
 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) {
@@ skipping 41 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