[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"
@@ skipping 200 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 top;
     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);
+      LayoutUnit 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(height)
+          .SetBlockOverflow(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_;
+      top = 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);
     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);
@@ skipping 70 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) {
+  LayoutObject* layout_object = item.GetLayoutObject();
+  DCHECK(layout_object && layout_object->isAtomicInlineLevel());
+  const NGLayoutResult* layout_result = item.GetLayoutResult();
+  DCHECK(layout_result);
+  RefPtr<NGPhysicalFragment> fragment = layout_result->PhysicalFragment();
+  bool is_horizontal_writing_mode =
+      IsHorizontalWritingMode(ConstraintSpace().WritingMode());
+  LayoutUnit height;
+  // TODO(kojii): Try to eliminate the text fragment and use the |fragment|
+  // directly. Currently |CopyFragmentDataToLayoutBlockFlow| requires a text
+  // fragment.
+  // TODO(kojii): Margin and border in block progression not implemented yet.
+  if (is_horizontal_writing_mode) {
+    height = fragment->Height();
+    text_builder->SetInlineSize(fragment->Width())
+        .SetInlineOverflow(fragment->WidthOverflow())
+        .SetBlockSize(height)
+        .SetBlockOverflow(fragment->HeightOverflow());
+  } else {
+    height = fragment->Width();
+    text_builder->SetInlineSize(fragment->Height())
+        .SetInlineOverflow(fragment->HeightOverflow())
+        .SetBlockSize(height)
+        .SetBlockOverflow(fragment->WidthOverflow());
+  }
+
+  // TODO(kojii): Add baseline position to NGPhysicalFragment.
+  LayoutBox* box = toLayoutBox(layout_object);
+  LineDirectionMode line_direction_mode =
+      is_horizontal_writing_mode ? 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 top = 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>(
+      height - baseline_offset, line_box_data->max_descent_and_leading);
+
+  return top;
+}
+
 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 45 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