Make NGFragmentBuilder to keep track on text children.

third_party/WebKit/Source/core/layout/ng/ng_line_builder.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/ng_line_builder.h"
 
 #include "core/layout/BidiRun.h"
 #include "core/layout/LayoutBlockFlow.h"
 #include "core/layout/line/LineInfo.h"
 #include "core/layout/line/RootInlineBox.h"
@@ skipping 10 matching lines @@
 
 NGLineBuilder::NGLineBuilder(NGInlineNode* inline_box,
                              NGConstraintSpace* constraint_space,
                              NGFragmentBuilder* containing_block_builder)
     : inline_box_(inline_box),
       constraint_space_(constraint_space),
       containing_block_builder_(containing_block_builder),
       baseline_type_(constraint_space->WritingMode() ==
                              NGWritingMode::kHorizontalTopBottom
                          ? FontBaseline::AlphabeticBaseline
-                         : FontBaseline::IdeographicBaseline)
+                         : FontBaseline::IdeographicBaseline),
+      container_builder_(NGPhysicalFragment::kFragmentBox, inline_box_),
+      container_layout_result_(nullptr)
 #if DCHECK_IS_ON()
       ,
       is_bidi_reordered_(false)
 #endif
 {
 }
 
 bool NGLineBuilder::CanFitOnLine() const {
   LayoutUnit available_size = current_opportunity_.InlineSize();
   if (available_size == NGSizeIndefinite)
@@ skipping 157 matching lines @@
     unsigned logical_index = indices_in_visual_order[visual_index];
     line_item_chunks_in_visual_order[visual_index] =
         (*line_item_chunks)[logical_index];
   }
   line_item_chunks->swap(line_item_chunks_in_visual_order);
 }
 
 void NGLineBuilder::PlaceItems(
     const Vector<LineItemChunk, 32>& line_item_chunks) {
   const Vector<NGLayoutInlineItem>& items = inline_box_->Items();
-  const unsigned fragment_start_index = fragments_.size();
+  const unsigned fragment_start_index = container_builder_.Children().size();
 
   NGFragmentBuilder text_builder(NGPhysicalFragment::kFragmentText,
                                  inline_box_);
   text_builder.SetWritingMode(ConstraintSpace().WritingMode());
   line_box_data_list_.grow(line_box_data_list_.size() + 1);
   LineBoxData& line_box_data = line_box_data_list_.back();
 
   // Accumulate a "strut"; a zero-width inline box with the element's font and
   // line height properties. https://drafts.csswg.org/css2/visudet.html#strut
   const ComputedStyle* block_style = inline_box_->BlockStyle();
@@ skipping 53 matching lines @@
     // The direction of a fragment is the CSS direction to resolve logical
     // properties, not the resolved bidi direction.
     text_builder.SetDirection(style->direction())
         .SetInlineSize(line_item_chunk.inline_size)
         .SetInlineOverflow(line_item_chunk.inline_size)
         .SetBlockSize(height)
         .SetBlockOverflow(height);
     RefPtr<NGPhysicalTextFragment> text_fragment = text_builder.ToTextFragment(
         line_item_chunk.index, line_item_chunk.start_offset,
         line_item_chunk.end_offset);
-    fragments_.push_back(std::move(text_fragment));
 
     NGLogicalOffset logical_offset(
         line_box_data.inline_size + current_opportunity_.InlineStartOffset() -
             ConstraintSpace().BfcOffset().inline_offset,
         top);
-    offsets_.push_back(logical_offset);
+    container_builder_.AddChild(std::move(text_fragment), logical_offset);
     line_box_data.inline_size += line_item_chunk.inline_size;
   }
-  DCHECK_EQ(fragments_.size(), offsets_.size());
 
-  if (fragment_start_index == fragments_.size()) {
+  if (fragment_start_index == container_builder_.Children().size()) {
     // The line was empty. Remove the LineBoxData.
     line_box_data_list_.shrink(line_box_data_list_.size() - 1);
     return;
   }
 
   // If the estimated baseline position was not the actual position, move all
   // fragments in the block direction.
   if (block_metrics.ascent_and_leading !=
       line_box_data.max_ascent_and_leading) {
     LayoutUnit adjust_top(line_box_data.max_ascent_and_leading -
                           block_metrics.ascent_and_leading);
-    for (unsigned i = fragment_start_index; i < offsets_.size(); i++)
-      offsets_[i].block_offset += adjust_top;
+    auto& offsets = container_builder_.MutableOffsets();
+    for (unsigned i = fragment_start_index; i < offsets.size(); i++)
+      offsets[i].block_offset += adjust_top;
   }
 
-  line_box_data.fragment_end = fragments_.size();
+  line_box_data.fragment_end = container_builder_.Children().size();
   line_box_data.top_with_leading = content_size_;
   max_inline_size_ = std::max(max_inline_size_, line_box_data.inline_size);
   content_size_ += LayoutUnit(line_box_data.max_ascent_and_leading +
                               line_box_data.max_descent_and_leading);
 }
 
 NGLineBuilder::InlineItemMetrics::InlineItemMetrics(
     const ComputedStyle& style,
     FontBaseline baseline_type) {
   const SimpleFontData* font_data = style.font().primaryFont();
@@ skipping 50 matching lines @@
   NGLogicalOffset iter_offset = constraint_space_->BfcOffset();
   iter_offset.block_offset += content_size_;
   auto* iter = constraint_space_->LayoutOpportunityIterator(iter_offset);
   NGLayoutOpportunity opportunity = iter->Next();
   if (!opportunity.IsEmpty())
     current_opportunity_ = opportunity;
 }
 
 RefPtr<NGLayoutResult> NGLineBuilder::CreateFragments() {
   DCHECK(!HasItems()) << "Must call CreateLine()";
-  DCHECK_EQ(fragments_.size(), offsets_.size());
-
-  NGFragmentBuilder container_builder(NGPhysicalFragment::kFragmentBox,
-                                      inline_box_);
-
-  for (unsigned i = 0; i < fragments_.size(); i++) {
-    // TODO(layout-dev): This should really be a std::move but
-    // CopyFragmentDataToLayoutBlockFlow also uses the fragments.
-    container_builder.AddChild(fragments_[i].get(), offsets_[i]);
-  }
 
   // TODO(kojii): Check if the line box width should be content or available.
   // TODO(kojii): Need to take constraint_space into account.
-  container_builder.SetInlineSize(max_inline_size_)
+  container_builder_.SetInlineSize(max_inline_size_)
       .SetInlineOverflow(max_inline_size_)
       .SetBlockSize(content_size_)
       .SetBlockOverflow(content_size_);
 
-  return container_builder.ToBoxFragment();
+  container_layout_result_ = container_builder_.ToBoxFragment();
+  return container_layout_result_;
 }
 
 void NGLineBuilder::CopyFragmentDataToLayoutBlockFlow() {
   LayoutBlockFlow* block = inline_box_->GetLayoutBlockFlow();
   block->deleteLineBoxTree();
 
   Vector<NGLayoutInlineItem>& items = inline_box_->Items();
   Vector<unsigned, 32> text_offsets(items.size());
   inline_box_->GetLayoutTextOffsets(&text_offsets);
 
-  Vector<NGPhysicalFragment*, 32> fragments_for_bidi_runs;
+  Vector<const NGPhysicalFragment*, 32> fragments_for_bidi_runs;
   fragments_for_bidi_runs.reserveInitialCapacity(items.size());
   BidiRunList<BidiRun> bidi_runs;
   LineInfo line_info;
   unsigned fragment_index = 0;
+  NGPhysicalBoxFragment* box_fragment = toNGPhysicalBoxFragment(
+      container_layout_result_->PhysicalFragment().get());
   for (const auto& line_box_data : line_box_data_list_) {
     // Create a BidiRunList for this line.
     for (; fragment_index < line_box_data.fragment_end; fragment_index++) {
-      NGPhysicalTextFragment* text_fragment =
-          toNGPhysicalTextFragment(fragments_[fragment_index].get());
+      const NGPhysicalFragment* fragment =
+          box_fragment->Children()[fragment_index].get();
+      if (!fragment->IsText())
+        continue;
+      const auto* text_fragment = toNGPhysicalTextFragment(fragment);
       const NGLayoutInlineItem& item = items[text_fragment->ItemIndex()];
       LayoutObject* layout_object = item.GetLayoutObject();
       if (!layout_object)  // Skip bidi controls.
         continue;
       BidiRun* run;
       if (layout_object->isText()) {
         unsigned text_offset = text_offsets[text_fragment->ItemIndex()];
         run = new BidiRun(text_fragment->StartOffset() - text_offset,
                           text_fragment->EndOffset() - text_offset,
                           item.BidiLevel(), LineLayoutItem(layout_object));
@@ skipping 41 matching lines @@
         baseline_position - LayoutUnit(line_box_data.max_ascent),
         baseline_position + LayoutUnit(line_box_data.max_descent),
         line_box_data.top_with_leading,
         baseline_position + LayoutUnit(line_box_data.max_descent_and_leading));
 
     bidi_runs.deleteRuns();
     fragments_for_bidi_runs.clear();
   }
 }
 }  // namespace blink