[LayoutNG] Implement atomic inlines for LayoutNGInline

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"
 #include "core/layout/ng/ng_bidi_paragraph.h"
+#include "core/layout/ng/ng_box_fragment.h"
 #include "core/layout/ng/ng_constraint_space.h"
+#include "core/layout/ng/ng_constraint_space_builder.h"
 #include "core/layout/ng/ng_fragment_builder.h"
 #include "core/layout/ng/ng_inline_node.h"
 #include "core/layout/ng/ng_length_utils.h"
 #include "core/layout/ng/ng_text_fragment.h"
 #include "core/style/ComputedStyle.h"
 #include "platform/text/BidiRunList.h"
 
 namespace blink {
 
 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),
       container_builder_(NGPhysicalFragment::kFragmentBox, inline_box_),
-      container_layout_result_(nullptr)
+      container_layout_result_(nullptr),
+      is_horizontal_writing_mode_(
+          blink::IsHorizontalWritingMode(constraint_space->WritingMode()))
 #if DCHECK_IS_ON()
       ,
       is_bidi_reordered_(false)
 #endif
 {
+  if (!is_horizontal_writing_mode_)
+    baseline_type_ = FontBaseline::IdeographicBaseline;
 }
 
 bool NGLineBuilder::CanFitOnLine() const {
   LayoutUnit available_size = current_opportunity_.InlineSize();
   if (available_size == NGSizeIndefinite)
     return true;
   return end_position_ <= available_size;
 }
 
 bool NGLineBuilder::HasItems() const {
@@ skipping 22 matching lines @@
   DCHECK_GT(new_end_offset, end_offset_);
   const Vector<NGLayoutInlineItem>& items = inline_box_->Items();
   DCHECK_LE(new_end_offset, items.back().EndOffset());
 
   // SetEnd() while |new_end_offset| is beyond the current last item.
   unsigned last_index = last_index_;
   const NGLayoutInlineItem* item = &items[last_index];
   if (new_end_offset > item->EndOffset()) {
     if (end_offset_ < item->EndOffset()) {
       SetEnd(item->EndOffset(),
-             item->InlineSize(end_offset_, item->EndOffset()));
+             InlineSize(*item, end_offset_, item->EndOffset()));
     }
     item = &items[++last_index];
 
     while (new_end_offset > item->EndOffset()) {
-      SetEnd(item->EndOffset(), item->InlineSize());
+      SetEnd(item->EndOffset(), InlineSize(*item));
       item = &items[++last_index];
     }
   }
 
-  SetEnd(new_end_offset, item->InlineSize(end_offset_, new_end_offset));
+  SetEnd(new_end_offset, InlineSize(*item, end_offset_, new_end_offset));
 }
 
 void NGLineBuilder::SetEnd(unsigned new_end_offset,
                            LayoutUnit inline_size_since_current_end) {
   DCHECK_GT(new_end_offset, end_offset_);
   const Vector<NGLayoutInlineItem>& items = inline_box_->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.
@@ skipping 18 matching lines @@
 void NGLineBuilder::SetBreakOpportunity() {
   last_break_opportunity_index_ = last_index_;
   last_break_opportunity_offset_ = end_offset_;
   last_break_opportunity_position_ = end_position_;
 }
 
 void NGLineBuilder::SetStartOfHangables(unsigned offset) {
   // TODO(kojii): Implement.
 }
 
+LayoutUnit NGLineBuilder::InlineSize(const NGLayoutInlineItem& item) {
+  if (item.IsAtomicInlineLevel())
+    return InlineSizeFromLayout(item);
+  return item.InlineSize();
+}
+
+LayoutUnit NGLineBuilder::InlineSize(const NGLayoutInlineItem& item,
+                                     unsigned start_offset,
+                                     unsigned end_offset) {
+  if (item.StartOffset() == start_offset && item.EndOffset() == end_offset &&
+      item.IsAtomicInlineLevel())
+    return InlineSizeFromLayout(item);
+  return item.InlineSize(start_offset, end_offset);
+}
+
+LayoutUnit NGLineBuilder::InlineSizeFromLayout(const NGLayoutInlineItem& item) {
+  return NGBoxFragment(ConstraintSpace().WritingMode(),
+                       toNGPhysicalBoxFragment(
+                           LayoutItem(item)->PhysicalFragment().get()))
+      .InlineSize();
+}
+
+const NGLayoutResult* NGLineBuilder::LayoutItem(
+    const NGLayoutInlineItem& item) {
+  // Returns the cached NGLayoutResult if available.
+  const Vector<NGLayoutInlineItem>& items = inline_box_->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.IsAtomicInlineLevel());
+  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();
+}
+
 void NGLineBuilder::CreateLine() {
   if (HasItemsAfterLastBreakOpportunity())
     SetBreakOpportunity();
   CreateLineUpToLastBreakOpportunity();
 }
 
 void NGLineBuilder::CreateLineUpToLastBreakOpportunity() {
   const Vector<NGLayoutInlineItem>& items = inline_box_->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,
-                      item.InlineSize(start_offset, end_offset)});
+                      InlineSize(item, start_offset, end_offset)});
     start_offset = end_offset;
   }
 
   if (inline_box_->IsBidiEnabled())
     BidiReorder(&line_item_chunks);
 
   PlaceItems(line_item_chunks);
 
   // Prepare for the next line.
   // Move |start| to |last_break_opportunity|, keeping items after
@@ skipping 67 matching lines @@
   // estimation turned out to be different.
   LayoutUnit estimated_baseline =
       content_size_ + LayoutUnit(block_metrics.ascent_and_leading);
 
   for (const auto& line_item_chunk : line_item_chunks) {
     const NGLayoutInlineItem& item = items[line_item_chunk.index];
     // Skip bidi controls.
     if (!item.GetLayoutObject())
       continue;
 
-    LayoutUnit top, height;
+    LayoutUnit block_start;
     const ComputedStyle* style = item.Style();
     if (style) {
+      DCHECK(item.GetLayoutObject()->isText());
       // |InlineTextBoxPainter| sets the baseline at |top +
       // ascent-of-primary-font|. Compute |top| to match.
       InlineItemMetrics metrics(*style, baseline_type_);
-      top = estimated_baseline - LayoutUnit(metrics.ascent);
-      height = LayoutUnit(metrics.ascent + metrics.descent);
+      block_start = estimated_baseline - LayoutUnit(metrics.ascent);
+      LayoutUnit line_height = LayoutUnit(metrics.ascent + metrics.descent);
       line_box_data.UpdateMaxAscentAndDescent(metrics);
 
       // Take all used fonts into account if 'line-height: normal'.
       if (style->lineHeight().isNegative())
         AccumulateUsedFonts(item, line_item_chunk, &line_box_data);
+
+      // 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(line_height)
+          .SetBlockOverflow(line_height);
     } else {
       LayoutObject* layout_object = item.GetLayoutObject();
       if (layout_object->isOutOfFlowPositioned()) {
         if (containing_block_builder_) {
           // Absolute positioning blockifies the box's display type.
           // https://drafts.csswg.org/css-display/#transformations
           containing_block_builder_->AddOutOfFlowChildCandidate(
               new NGBlockNode(layout_object),
               NGLogicalOffset(line_box_data.inline_size, content_size_));
         }
         continue;
       } else if (layout_object->isFloating()) {
         // TODO(kojii): Implement float.
         DLOG(ERROR) << "Floats in inline not implemented yet.";
         // TODO(kojii): Temporarily clearNeedsLayout() for not to assert.
         layout_object->clearNeedsLayout();
         continue;
       }
-      DCHECK(layout_object->isAtomicInlineLevel());
-      // TODO(kojii): Implement atomic inline.
-      style = layout_object->style();
-      top = content_size_;
+      block_start = PlaceAtomicInline(item, estimated_baseline, &line_box_data,
+                                      &text_builder);
     }
 
-    // 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);
 
     NGLogicalOffset logical_offset(
         line_box_data.inline_size + current_opportunity_.InlineStartOffset() -
             ConstraintSpace().BfcOffset().inline_offset,
-        top);
+        block_start);
     container_builder_.AddChild(std::move(text_fragment), logical_offset);
     line_box_data.inline_size += line_item_chunk.inline_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;
   }
 
@@ skipping 61 matching lines @@
   HashSet<const SimpleFontData*> fallback_fonts;
   item.GetFallbackFonts(&fallback_fonts, line_item_chunk.start_offset,
                         line_item_chunk.end_offset);
   for (const auto& fallback_font : fallback_fonts) {
     InlineItemMetrics fallback_font_metrics(fallback_font->getFontMetrics(),
                                             baseline_type_);
     line_box_data->UpdateMaxAscentAndDescent(fallback_font_metrics);
   }
 }
 
+LayoutUnit NGLineBuilder::PlaceAtomicInline(const NGLayoutInlineItem& item,
+                                            LayoutUnit estimated_baseline,
+                                            LineBoxData* line_box_data,
+                                            NGFragmentBuilder* text_builder) {
+  NGBoxFragment fragment(
+      ConstraintSpace().WritingMode(),
+      toNGPhysicalBoxFragment(LayoutItem(item)->PhysicalFragment().get()));
+  // TODO(kojii): Margin and border in block progression not implemented yet.
+  LayoutUnit block_size = fragment.BlockSize();
+
+  // TODO(kojii): Try to eliminate the wrapping text fragment and use the
+  // |fragment| directly. Currently |CopyFragmentDataToLayoutBlockFlow|
+  // requires a text fragment.
+  text_builder->SetInlineSize(fragment.InlineSize())
+      .SetInlineOverflow(fragment.InlineOverflow())
+      .SetBlockSize(block_size)
+      .SetBlockOverflow(fragment.BlockOverflow());
+
+  // TODO(kojii): Add baseline position to NGPhysicalFragment.
+  LayoutBox* box = toLayoutBox(item.GetLayoutObject());
+  LineDirectionMode line_direction_mode =
+      IsHorizontalWritingMode() ? LineDirectionMode::HorizontalLine
+                                : LineDirectionMode::VerticalLine;
+  bool is_first_line = line_box_data_list_.size() == 1;
+  int baseline_offset =
+      box->baselinePosition(baseline_type_, is_first_line, line_direction_mode);
+  LayoutUnit block_start = estimated_baseline - baseline_offset;
+
+  line_box_data->max_ascent_and_leading =
+      std::max<float>(baseline_offset, line_box_data->max_ascent_and_leading);
+  line_box_data->max_descent_and_leading = std::max<float>(
+      block_size - baseline_offset, line_box_data->max_descent_and_leading);
+
+  // TODO(kojii): Figure out what to do with OOF in NGLayoutResult.
+  // Floats are ok because atomic inlines are BFC?
+
+  return block_start;
+}
+
 void NGLineBuilder::FindNextLayoutOpportunity() {
   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() {
@@ skipping 41 matching lines @@
       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));
         layout_object->clearNeedsLayout();
       } else {
         DCHECK(layout_object->isAtomicInlineLevel());
         run =
             new BidiRun(0, 1, item.BidiLevel(), LineLayoutItem(layout_object));
-        // TODO(kojii): Temporarily clearNeedsLayout() for not to assert.
-        layout_object->clearNeedsLayout();
       }
       bidi_runs.addRun(run);
       fragments_for_bidi_runs.push_back(text_fragment);
     }
     // TODO(kojii): bidi needs to find the logical last run.
     bidi_runs.setLogicallyLastRun(bidi_runs.lastRun());
 
     // Create a RootInlineBox from BidiRunList. InlineBoxes created for the
     // RootInlineBox are set to Bidirun::m_box.
     line_info.setEmpty(false);
     // TODO(kojii): Implement setFirstLine, LastLine, etc.
     RootInlineBox* line_box = block->constructLine(bidi_runs, line_info);
 
     // Copy fragments data to InlineBoxes.
     DCHECK_EQ(fragments_for_bidi_runs.size(), bidi_runs.runCount());
     BidiRun* run = bidi_runs.firstRun();
     for (auto* physical_fragment : fragments_for_bidi_runs) {
       DCHECK(run);
       NGTextFragment fragment(ConstraintSpace().WritingMode(),
                               toNGPhysicalTextFragment(physical_fragment));
       InlineBox* inline_box = run->m_box;
       inline_box->setLogicalWidth(fragment.InlineSize());
       inline_box->setLogicalLeft(fragment.InlineOffset());
       inline_box->setLogicalTop(fragment.BlockOffset());
+      if (inline_box->getLineLayoutItem().isBox()) {
+        LineLayoutBox box(inline_box->getLineLayoutItem());
+        box.setLocation(inline_box->location());
+      }
       run = run->next();
     }
     DCHECK(!run);
 
     // Copy LineBoxData to RootInlineBox.
     line_box->setLogicalWidth(line_box_data.inline_size);
+    line_box->setLogicalTop(line_box_data.top_with_leading);
     LayoutUnit baseline_position =
         line_box_data.top_with_leading +
         LayoutUnit(line_box_data.max_ascent_and_leading);
     line_box->setLineTopBottomPositions(
         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