[LayoutNG] Implement CSS 'text-indent' property

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 49 matching lines @@
                              NGConstraintSpace* space,
                              NGFragmentBuilder* container_builder,
                              const NGInlineBreakToken* break_token)
     : node_(node),
       constraint_space_(space),
       container_builder_(container_builder),
       item_index_(0),
       offset_(0),
       break_iterator_(node.Text()),
       shaper_(node.Text().Characters16(), node.Text().length()),
-      spacing_(node.Text()) {
+      spacing_(node.Text()),
+      auto_wrap_(false),
+      should_create_line_box_(false),
+      is_after_forced_break_(false) {
   if (break_token) {
     item_index_ = break_token->ItemIndex();
     offset_ = break_token->TextOffset();
     node.AssertOffset(item_index_, offset_);
   }
 }
 
+// @return if this is the "first formatted line".
+// https://www.w3.org/TR/CSS22/selector.html#first-formatted-line
+bool NGLineBreaker::IsFirstFormattedLine() const {
+  if (item_index_ || offset_)
+    return false;
+  // The first line of an anonymous block box is only affected if it is the
+  // first child of its parent element.
+  // https://drafts.csswg.org/css-text-3/#text-indent-property
+  LayoutBlockFlow* block = node_.GetLayoutBlockFlow();
+  if (block->IsAnonymousBlock() && block->PreviousSibling()) {
+    // TODO(kojii): In NG, leading OOF creates a block box.
+    // text-indent-first-line-002.html fails for this reason.
+    // crbug.com/734554
+    return false;
+  }
+  return true;
+}
+
 bool NGLineBreaker::NextLine(NGLineInfo* line_info,
                              const NGLogicalOffset& content_offset) {
   content_offset_ = content_offset;
   BreakLine(line_info);
 
   // 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();
 
   if (line_info->Results().IsEmpty())
     return false;
 
   // TODO(kojii): There are cases where we need to PlaceItems() without creating
   // line boxes. These cases need to be reviewed.
   if (should_create_line_box_)
     ComputeLineLocation(line_info);
 
   return true;
 }
 
 void NGLineBreaker::BreakLine(NGLineInfo* line_info) {
   NGInlineItemResults* item_results = &line_info->Results();
   item_results->clear();
   const Vector<NGInlineItem>& items = node_.Items();
-  line_info->SetLineStyle(node_, !item_index_ && !offset_);
+  line_info->SetLineStyle(node_, *constraint_space_, IsFirstFormattedLine(),
+                          is_after_forced_break_);
   SetCurrentStyle(line_info->LineStyle());
-  position_ = LayoutUnit(0);
+  is_after_forced_break_ = false;
   should_create_line_box_ = false;
   LineBreakState state = LineBreakState::kNotBreakable;
 
+  // Use 'text-indent' as the initial position. This lets tab positions to align
+  // regardless of 'text-indent'.
+  position_ = line_info->TextIndent();
+
   // We are only able to calculate our available_width if our container has
   // been positioned in the BFC coordinate space yet.
   if (container_builder_->BfcOffset())
     UpdateAvailableWidth();
   else
     opportunity_.reset();
 
   while (item_index_ < items.size()) {
     // CloseTag prohibits to break before.
     const NGInlineItem& item = items[item_index_];
@@ skipping 15 matching lines @@
     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) {
+        is_after_forced_break_ = true;
         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);
     } else {
       MoveToNextOf(item);
@@ skipping 470 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