Add NGColumnLayoutAlgorithm skeleton implementation.

third_party/WebKit/Source/core/layout/ng/ng_inline_layout_algorithm.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_inline_layout_algorithm.h"
 
 #include "core/layout/BidiRun.h"
 #include "core/layout/LayoutBlockFlow.h"
 #include "core/layout/line/LineInfo.h"
 #include "core/layout/line/RootInlineBox.h"
@@ skipping 50 matching lines @@
     NGLogicalOffset offset = PositionFloat(origin_point, space->BfcOffset(),
                                            floating_object.get(), space);
     builder->AddFloatingObject(floating_object, offset);
   }
   builder->MutableUnpositionedFloats().clear();
 }
 
 }  // namespace
 
 NGInlineLayoutAlgorithm::NGInlineLayoutAlgorithm(
-    NGInlineNode* inline_box,
-    NGConstraintSpace* constraint_space,
+    NGInlineNode* inline_node,
+    NGConstraintSpace* space,
     NGInlineBreakToken* break_token)
-    : inline_box_(inline_box),
-      constraint_space_(constraint_space),
-      container_builder_(NGPhysicalFragment::kFragmentBox, inline_box_),
+    : NGLayoutAlgorithm(inline_node, space, break_token),
+      container_builder_(NGPhysicalFragment::kFragmentBox, inline_node),
       is_horizontal_writing_mode_(
-          blink::IsHorizontalWritingMode(constraint_space->WritingMode())),
-      space_builder_(constraint_space)
+          blink::IsHorizontalWritingMode(space->WritingMode())),
+      space_builder_(space)
 #if DCHECK_IS_ON()
       ,
       is_bidi_reordered_(false)
 #endif
 {
   if (!is_horizontal_writing_mode_)
     baseline_type_ = FontBaseline::IdeographicBaseline;
   if (break_token)
     Initialize(break_token->ItemIndex(), break_token->TextOffset());
   else
@@ skipping 14 matching lines @@
 bool NGInlineLayoutAlgorithm::HasBreakOpportunity() const {
   return start_offset_ != last_break_opportunity_offset_;
 }
 
 bool NGInlineLayoutAlgorithm::HasItemsAfterLastBreakOpportunity() const {
   return last_break_opportunity_offset_ != end_offset_;
 }
 
 void NGInlineLayoutAlgorithm::Initialize(unsigned index, unsigned offset) {
   if (index || offset)
-    inline_box_->AssertOffset(index, offset);
+    Node()->AssertOffset(index, offset);
 
   start_index_ = last_index_ = last_break_opportunity_index_ = index;
   start_offset_ = end_offset_ = last_break_opportunity_offset_ = offset;
   end_position_ = last_break_opportunity_position_ = LayoutUnit();
 
   FindNextLayoutOpportunity();
 }
 
 void NGInlineLayoutAlgorithm::SetEnd(unsigned new_end_offset) {
   DCHECK_GT(new_end_offset, end_offset_);
-  const Vector<NGLayoutInlineItem>& items = inline_box_->Items();
+  const Vector<NGLayoutInlineItem>& items = Node()->Items();
   DCHECK_LE(new_end_offset, items.back().EndOffset());
 
   // SetEnd() while |new_end_offset| is beyond the current last item.
   unsigned index = last_index_;
   const NGLayoutInlineItem* item = &items[index];
   if (new_end_offset > item->EndOffset()) {
     if (end_offset_ < item->EndOffset()) {
       SetEnd(index, item->EndOffset(),
              InlineSize(*item, end_offset_, item->EndOffset()));
     }
@@ skipping 12 matching lines @@
     item = &items[++index];
     if (item->Type() != NGLayoutInlineItem::kCloseTag)
       break;
     SetEnd(index, new_end_offset, InlineSize(*item));
   }
 }
 
 void NGInlineLayoutAlgorithm::SetEnd(unsigned index,
                                      unsigned new_end_offset,
                                      LayoutUnit inline_size_since_current_end) {
-  const Vector<NGLayoutInlineItem>& items = inline_box_->Items();
+  const Vector<NGLayoutInlineItem>& items = Node()->Items();
   DCHECK_LE(new_end_offset, items.back().EndOffset());
 
   // |new_end_offset| should be in the current item or next.
   // TODO(kojii): Reconsider this restriction if needed.
   DCHECK((index == last_index_ && new_end_offset > end_offset_) ||
          (index == last_index_ + 1 && new_end_offset >= end_offset_ &&
           end_offset_ == items[last_index_].EndOffset()));
   const NGLayoutInlineItem& item = items[index];
   item.AssertEndOffset(new_end_offset);
 
@@ skipping 36 matching lines @@
     const NGLayoutInlineItem& item) {
   return NGBoxFragment(ConstraintSpace().WritingMode(),
                        toNGPhysicalBoxFragment(
                            LayoutItem(item)->PhysicalFragment().get()))
       .InlineSize();
 }
 
 const NGLayoutResult* NGInlineLayoutAlgorithm::LayoutItem(
     const NGLayoutInlineItem& item) {
   // Returns the cached NGLayoutResult if available.
-  const Vector<NGLayoutInlineItem>& items = inline_box_->Items();
+  const Vector<NGLayoutInlineItem>& items = Node()->Items();
   if (layout_results_.isEmpty())
     layout_results_.resize(items.size());
   unsigned index = std::distance(items.begin(), &item);
   RefPtr<NGLayoutResult>* layout_result = &layout_results_[index];
   if (*layout_result)
     return layout_result->get();
 
   DCHECK(item.Type() == NGLayoutInlineItem::kAtomicInline);
   NGBlockNode* node = new NGBlockNode(item.GetLayoutObject());
   // TODO(kojii): Keep node in NGLayoutInlineItem.
   const ComputedStyle& style = node->Style();
   NGConstraintSpaceBuilder constraint_space_builder(&ConstraintSpace());
   RefPtr<NGConstraintSpace> constraint_space =
       constraint_space_builder.SetIsNewFormattingContext(true)
           .SetIsShrinkToFit(true)
           .SetTextDirection(style.direction())
           .ToConstraintSpace(FromPlatformWritingMode(style.getWritingMode()));
   *layout_result = node->Layout(constraint_space.get());
   return layout_result->get();
 }
 
 bool NGInlineLayoutAlgorithm::CreateLine() {
   if (HasItemsAfterLastBreakOpportunity())
     SetBreakOpportunity();
   return CreateLineUpToLastBreakOpportunity();
 }
 
 bool NGInlineLayoutAlgorithm::CreateLineUpToLastBreakOpportunity() {
-  const Vector<NGLayoutInlineItem>& items = inline_box_->Items();
+  const Vector<NGLayoutInlineItem>& items = Node()->Items();
 
   // Create a list of LineItemChunk from |start| and |last_break_opportunity|.
   // TODO(kojii): Consider refactoring LineItemChunk once NGLineBuilder's public
   // API is more finalized. It does not fit well with the current API.
   Vector<LineItemChunk, 32> line_item_chunks;
   unsigned start_offset = start_offset_;
   for (unsigned i = start_index_; i <= last_break_opportunity_index_; i++) {
     const NGLayoutInlineItem& item = items[i];
     unsigned end_offset =
         std::min(item.EndOffset(), last_break_opportunity_offset_);
     line_item_chunks.push_back(
         LineItemChunk{i, start_offset, end_offset,
                       InlineSize(item, start_offset, end_offset)});
     start_offset = end_offset;
   }
 
-  if (inline_box_->IsBidiEnabled())
+  if (Node()->IsBidiEnabled())
     BidiReorder(&line_item_chunks);
 
   if (!PlaceItems(line_item_chunks))
     return false;
 
   // Prepare for the next line.
   // Move |start| to |last_break_opportunity|, keeping items after
   // |last_break_opportunity|.
   start_index_ = last_break_opportunity_index_;
   start_offset_ = last_break_opportunity_offset_;
   DCHECK_GE(end_position_, last_break_opportunity_position_);
   end_position_ -= last_break_opportunity_position_;
   last_break_opportunity_position_ = LayoutUnit();
 #if DCHECK_IS_ON()
   is_bidi_reordered_ = false;
 #endif
 
   NGLogicalOffset origin_point =
       GetOriginPointForFloats(ConstraintSpace(), content_size_);
-  PositionPendingFloats(origin_point, constraint_space_, &container_builder_);
+  PositionPendingFloats(origin_point, MutableConstraintSpace(),
+                        &container_builder_);
   FindNextLayoutOpportunity();
   return true;
 }
 
 void NGInlineLayoutAlgorithm::BidiReorder(
     Vector<LineItemChunk, 32>* line_item_chunks) {
 #if DCHECK_IS_ON()
   DCHECK(!is_bidi_reordered_);
   is_bidi_reordered_ = true;
 #endif
 
   // TODO(kojii): UAX#9 L1 is not supported yet. Supporting L1 may change
   // embedding levels of parts of runs, which requires to split items.
   // http://unicode.org/reports/tr9/#L1
   // BidiResolver does not support L1 crbug.com/316409.
 
   // Create a list of chunk indices in the visual order.
   // ICU |ubidi_getVisualMap()| works for a run of characters. Since we can
   // handle the direction of each run, we use |ubidi_reorderVisual()| to reorder
   // runs instead of characters.
   Vector<UBiDiLevel, 32> levels;
   levels.reserveInitialCapacity(line_item_chunks->size());
   for (const auto& chunk : *line_item_chunks)
-    levels.push_back(inline_box_->Items()[chunk.index].BidiLevel());
+    levels.push_back(Node()->Items()[chunk.index].BidiLevel());
   Vector<int32_t, 32> indices_in_visual_order(line_item_chunks->size());
   NGBidiParagraph::IndicesInVisualOrder(levels, &indices_in_visual_order);
 
   // Reorder |line_item_chunks| in visual order.
   Vector<LineItemChunk, 32> line_item_chunks_in_visual_order(
       line_item_chunks->size());
   for (unsigned visual_index = 0; visual_index < indices_in_visual_order.size();
        visual_index++) {
     unsigned logical_index = indices_in_visual_order[visual_index];
     line_item_chunks_in_visual_order[visual_index] =
@@ skipping 16 matching lines @@
   // determine if it fits on this line, then perform layout with the correct
   // fragmentation line.
   // diff writing mode - get the inline size from performing layout.
   RefPtr<NGLayoutResult> layout_result = node->Layout(float_space.get());
 
   NGBoxFragment float_fragment(
       float_space->WritingMode(),
       toNGPhysicalBoxFragment(layout_result->PhysicalFragment().get()));
 
   RefPtr<NGFloatingObject> floating_object = NGFloatingObject::Create(
-      float_space.get(), constraint_space_, node->Style(), NGBoxStrut(),
+      float_space.get(), MutableConstraintSpace(), node->Style(), NGBoxStrut(),
       current_opportunity_.size, layout_result->PhysicalFragment().get());
 
   bool float_does_not_fit = end_position + float_fragment.InlineSize() >
                             current_opportunity_.InlineSize();
   // Check if we already have a pending float. That's because a float cannot be
   // higher than any block or floated box generated before.
   if (!container_builder_.UnpositionedFloats().isEmpty() ||
       float_does_not_fit) {
     container_builder_.AddUnpositionedFloat(floating_object);
   } else {
     NGLogicalOffset origin_point =
         GetOriginPointForFloats(ConstraintSpace(), content_size_);
     NGLogicalOffset offset =
-        PositionFloat(origin_point, constraint_space_->BfcOffset(),
-                      floating_object.get(), constraint_space_);
+        PositionFloat(origin_point, ConstraintSpace().BfcOffset(),
+                      floating_object.get(), MutableConstraintSpace());
     container_builder_.AddFloatingObject(floating_object, offset);
     FindNextLayoutOpportunity();
   }
 }
 
 bool NGInlineLayoutAlgorithm::PlaceItems(
     const Vector<LineItemChunk, 32>& line_item_chunks) {
-  const Vector<NGLayoutInlineItem>& items = inline_box_->Items();
+  const Vector<NGLayoutInlineItem>& items = Node()->Items();
 
-  NGLineBoxFragmentBuilder line_box(inline_box_);
-  NGTextFragmentBuilder text_builder(inline_box_);
+  NGLineBoxFragmentBuilder line_box(Node());
+  NGTextFragmentBuilder text_builder(Node());
 
   // 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
-  NGLineHeightMetrics block_metrics(inline_box_->Style(), baseline_type_);
+  NGLineHeightMetrics block_metrics(Style(), baseline_type_);
   line_box.UniteMetrics(block_metrics);
 
   // Use the block style to compute the estimated baseline position because the
   // baseline position is not known until we know the maximum ascent and leading
   // of the line. Items are placed on this baseline, then adjusted later if the
   // estimation turned out to be different.
   LayoutUnit estimated_baseline =
       content_size_ + LayoutUnit(block_metrics.ascent_and_leading);
 
   LayoutUnit inline_size;
@@ skipping 67 matching lines @@
 
   // If the estimated baseline position was not the actual position, move all
   // fragments in the block direction.
   LayoutUnit adjust_baseline(line_box.Metrics().ascent_and_leading -
                              block_metrics.ascent_and_leading);
   if (adjust_baseline)
     line_box.MoveChildrenInBlockDirection(adjust_baseline);
 
   // If there are more content to consume, create an unfinished break token.
   if (last_break_opportunity_index_ != items.size() - 1 ||
-      last_break_opportunity_offset_ != inline_box_->Text().length()) {
-    line_box.SetBreakToken(
-        NGInlineBreakToken::create(inline_box_, last_break_opportunity_index_,
-                                   last_break_opportunity_offset_));
+      last_break_opportunity_offset_ != Node()->Text().length()) {
+    line_box.SetBreakToken(NGInlineBreakToken::create(
+        Node(), last_break_opportunity_index_, last_break_opportunity_offset_));
   }
 
   line_box.SetInlineSize(inline_size);
   container_builder_.AddChild(line_box.ToLineBoxFragment(),
                               {LayoutUnit(), content_size_});
 
   max_inline_size_ = std::max(max_inline_size_, inline_size);
   content_size_ = block_end;
   return true;
 }
@@ skipping 43 matching lines @@
   metrics.descent_and_leading = block_size - baseline_offset;
   line_box->UniteMetrics(metrics);
 
   // TODO(kojii): Figure out what to do with OOF in NGLayoutResult.
   // Floats are ok because atomic inlines are BFC?
 
   return block_start;
 }
 
 void NGInlineLayoutAlgorithm::FindNextLayoutOpportunity() {
-  NGLogicalOffset iter_offset = constraint_space_->BfcOffset();
+  NGLogicalOffset iter_offset = ConstraintSpace().BfcOffset();
   iter_offset.block_offset += content_size_;
-  auto* iter = constraint_space_->LayoutOpportunityIterator(iter_offset);
+  auto* iter = MutableConstraintSpace()->LayoutOpportunityIterator(iter_offset);
   NGLayoutOpportunity opportunity = iter->Next();
   if (!opportunity.IsEmpty())
     current_opportunity_ = opportunity;
 }
 
 RefPtr<NGLayoutResult> NGInlineLayoutAlgorithm::Layout() {
   // TODO(koji): The relationship of NGInlineLayoutAlgorithm and NGLineBreaker
   // should be inverted.
-  if (!inline_box_->Text().isEmpty())
-    NGLineBreaker().BreakLines(this, inline_box_->Text(), start_offset_);
+  if (!Node()->Text().isEmpty())
+    NGLineBreaker().BreakLines(this, Node()->Text(), start_offset_);
 
   // TODO(kojii): Check if the line box width should be content or available.
   container_builder_.SetInlineSize(max_inline_size_)
       .SetInlineOverflow(max_inline_size_)
       .SetBlockSize(content_size_)
       .SetBlockOverflow(content_size_);
 
   return container_builder_.ToBoxFragment();
 }
 
 MinMaxContentSize NGInlineLayoutAlgorithm::ComputeMinMaxContentSizeByLayout() {
   DCHECK(ConstraintSpace().AvailableSize().inline_size == LayoutUnit() &&
          ConstraintSpace().AvailableSize().block_size == NGSizeIndefinite);
-  if (!inline_box_->Text().isEmpty())
-    NGLineBreaker().BreakLines(this, inline_box_->Text(), start_offset_);
+  if (!Node()->Text().isEmpty())
+    NGLineBreaker().BreakLines(this, Node()->Text(), start_offset_);
   MinMaxContentSize sizes;
   sizes.min_content = MaxInlineSize();
 
   // max-content is the width without any line wrapping.
   // TODO(kojii): Implement hard breaks (<br> etc.) to break.
-  for (const auto& item : inline_box_->Items())
+  for (const auto& item : Node()->Items())
     sizes.max_content += InlineSize(item);
 
   return sizes;
 }
 
 void NGInlineLayoutAlgorithm::CopyFragmentDataToLayoutBlockFlow(
     NGLayoutResult* layout_result) {
-  LayoutBlockFlow* block = inline_box_->GetLayoutBlockFlow();
+  LayoutBlockFlow* block = Node()->GetLayoutBlockFlow();
   block->deleteLineBoxTree();
 
-  Vector<NGLayoutInlineItem>& items = inline_box_->Items();
+  Vector<NGLayoutInlineItem>& items = Node()->Items();
   Vector<unsigned, 32> text_offsets(items.size());
-  inline_box_->GetLayoutTextOffsets(&text_offsets);
+  Node()->GetLayoutTextOffsets(&text_offsets);
 
   Vector<const NGPhysicalFragment*, 32> fragments_for_bidi_runs;
   fragments_for_bidi_runs.reserveInitialCapacity(items.size());
   BidiRunList<BidiRun> bidi_runs;
   LineInfo line_info;
   NGPhysicalBoxFragment* box_fragment =
       toNGPhysicalBoxFragment(layout_result->PhysicalFragment().get());
   for (const auto& container_child : box_fragment->Children()) {
     NGPhysicalLineBoxFragment* physical_line_box =
         toNGPhysicalLineBoxFragment(container_child.get());
@@ skipping 61 matching lines @@
     root_line_box->setLineTopBottomPositions(
         baseline - LayoutUnit(metrics.ascent),
         baseline + LayoutUnit(metrics.descent), line_top_with_leading,
         baseline + LayoutUnit(metrics.descent_and_leading));
 
     bidi_runs.deleteRuns();
     fragments_for_bidi_runs.clear();
   }
 }
 }  // namespace blink