[LayoutNG] Fix empty inlines to influence the used line height

third_party/WebKit/Source/core/layout/ng/inline/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/inline/ng_inline_layout_algorithm.h"
 
 #include "core/layout/ng/inline/ng_bidi_paragraph.h"
 #include "core/layout/ng/inline/ng_inline_break_token.h"
 #include "core/layout/ng/inline/ng_inline_node.h"
 #include "core/layout/ng/inline/ng_line_box_fragment.h"
@@ skipping 376 matching lines @@
         PositionFloat(floating_object.Get(), MutableConstraintSpace());
     container_builder_.MutablePositionedFloats().push_back(floating_object);
     FindNextLayoutOpportunity();
   }
 }
 
 bool NGInlineLayoutAlgorithm::PlaceItems(
     const Vector<LineItemChunk, 32>& line_item_chunks) {
   const Vector<NGInlineItem>& items = Node()->Items();
 
-  // Use a "strut" (a zero-width inline box with the element's font and
-  // line height properties) as the initial metrics for the line box.
-  // https://drafts.csswg.org/css2/visudet.html#strut
   const ComputedStyle& line_style = LineStyle();
   NGLineHeightMetrics line_metrics(line_style, baseline_type_);
   NGLineHeightMetrics line_metrics_with_leading = line_metrics;
   line_metrics_with_leading.AddLeading(line_style.ComputedLineHeightAsFixed());
-  NGLineBoxFragmentBuilder line_box(Node(), line_metrics_with_leading);
+  NGLineBoxFragmentBuilder line_box(Node());
 
   // Compute heights of all inline items by placing the dominant baseline at 0.
   // The baseline is adjusted after the height of the line box is computed.
   NGTextFragmentBuilder text_builder(Node());
-  NGInlineBoxState* box = box_states_.OnBeginPlaceItems(&LineStyle());
+  NGInlineBoxState* box =
+      box_states_.OnBeginPlaceItems(&LineStyle(), baseline_type_);
   LayoutUnit inline_size;
   for (const auto& line_item_chunk : line_item_chunks) {
     const NGInlineItem& item = items[line_item_chunk.index];
     LayoutUnit line_top;
     if (item.Type() == NGInlineItem::kText) {
       DCHECK(item.GetLayoutObject()->IsText());
-      if (box->text_metrics.IsEmpty())
-        box->ComputeTextMetrics(item, baseline_type_);
+      DCHECK(!box->text_metrics.IsEmpty());
       line_top = box->text_top;
       text_builder.SetSize(
           {line_item_chunk.inline_size, box->text_metrics.LineHeight()});
       // Take all used fonts into account if 'line-height: normal'.
-      if (box->include_used_fonts)
-        AccumulateUsedFonts(item, line_item_chunk, &line_box);
+      if (box->include_used_fonts) {
+        box->AccumulateUsedFonts(item, line_item_chunk.start_offset,
+                                 line_item_chunk.end_offset, baseline_type_);
+      }
     } else if (item.Type() == NGInlineItem::kOpenTag) {
       box = box_states_.OnOpenTag(item, &line_box, &text_builder);
+      // Compute text metrics for all inline boxes since even empty inlines
+      // influence the line height.
+      // https://drafts.csswg.org/css2/visudet.html#line-height
+      // TODO(kojii): Review if atomic inline level should have open/close.
+      if (!item.GetLayoutObject()->IsAtomicInlineLevel())
+        box->ComputeTextMetrics(*item.Style(), baseline_type_);
       continue;
     } else if (item.Type() == NGInlineItem::kCloseTag) {
       box = box_states_.OnCloseTag(item, &line_box, box);
       continue;
     } else if (item.Type() == NGInlineItem::kAtomicInline) {
       line_top = PlaceAtomicInline(item, &line_box, box, &text_builder);
     } else if (item.Type() == NGInlineItem::kOutOfFlowPositioned) {
       // TODO(layout-dev): Report the correct static position for the out of
       // flow descendant. We can't do this here yet as it doesn't know the
       // size of the line box.
@@ skipping 48 matching lines @@
   }
 
   // TODO(kojii): Implement flipped line (vertical-lr). In this case, line_top
   // and block_start do not match.
 
   // Up until this point, children are placed so that the dominant baseline is
   // at 0. Move them to the final baseline position, and set the logical top of
   // the line box to the line top.
   line_box.MoveChildrenInBlockDirection(baseline);
   line_box.SetInlineSize(inline_size);
-  container_builder_.AddChild(line_box.ToLineBoxFragment(),
-                              {LayoutUnit(), baseline - line_metrics.ascent});
+  container_builder_.AddChild(
+      line_box.ToLineBoxFragment(),
+      {LayoutUnit(), baseline + box_states_.LineBoxState().text_top});
 
   max_inline_size_ = std::max(max_inline_size_, inline_size);
   content_size_ = line_bottom;
   return true;
 }
 
-void NGInlineLayoutAlgorithm::AccumulateUsedFonts(
-    const NGInlineItem& item,
-    const LineItemChunk& line_item_chunk,
-    NGLineBoxFragmentBuilder* line_box) {
-  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) {
-    NGLineHeightMetrics metrics(fallback_font->GetFontMetrics(),
-                                baseline_type_);
-    metrics.AddLeading(fallback_font->GetFontMetrics().FixedLineSpacing());
-    line_box->UniteMetrics(metrics);
-  }
-}
-
 LayoutUnit NGInlineLayoutAlgorithm::PlaceAtomicInline(
     const NGInlineItem& item,
     NGLineBoxFragmentBuilder* line_box,
     NGInlineBoxState* state,
     NGTextFragmentBuilder* 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();
@@ skipping 58 matching lines @@
 
   // max-content is the width without any line wrapping.
   // TODO(kojii): Implement hard breaks (<br> etc.) to break.
   for (const auto& item : Node()->Items())
     sizes.max_content += InlineSize(item);
 
   return sizes;
 }
 
 }  // namespace blink