[LayoutNG] Initial support for the 'vertical-align' property

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 253 matching lines @@
     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_;
+  // If the offset is at the end of the item, move to the next item.
+  if (start_offset_ == items[start_index_].EndOffset() &&
+      start_index_ < items.size() - 1) {
+    start_index_++;
+  }
   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.block_offset, MutableConstraintSpace(),
@@ skipping 13 matching lines @@
   // 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());
+  const Vector<NGLayoutInlineItem>& items = Node()->Items();
   for (const auto& chunk : *line_item_chunks)
-    levels.push_back(Node()->Items()[chunk.index].BidiLevel());
+    levels.push_back(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] =
         (*line_item_chunks)[logical_index];
   }
+
+  // Keep Open before Close in the visual order.
+  HashMap<LayoutObject*, unsigned> first_index;
+  for (unsigned i = 0; i < line_item_chunks_in_visual_order.size(); i++) {
+    LineItemChunk& chunk = line_item_chunks_in_visual_order[i];
+    const NGLayoutInlineItem& item = items[chunk.index];
+    if (item.Type() != NGLayoutInlineItem::kOpenTag &&
+        item.Type() != NGLayoutInlineItem::kCloseTag) {
+      continue;
+    }
+    auto result = first_index.insert(item.GetLayoutObject(), i);
+    if (!result.is_new_entry && item.Type() == NGLayoutInlineItem::kOpenTag) {
+      std::swap(line_item_chunks_in_visual_order[i],
+                line_item_chunks_in_visual_order[result.stored_value->value]);
+    }
+  }
+
   line_item_chunks->Swap(line_item_chunks_in_visual_order);
 }
 
 // TODO(glebl): Add the support of clearance for inline floats.
 void NGInlineLayoutAlgorithm::LayoutAndPositionFloat(
     LayoutUnit end_position,
     LayoutObject* layout_object) {
   NGBlockNode* node = new NGBlockNode(layout_object);
 
   RefPtr<NGConstraintSpace> float_space =
@@ skipping 45 matching lines @@
   // 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);
 
   // 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());
   LayoutUnit inline_size;
   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 block_start;
+    LayoutUnit line_top;
     if (item.Type() == NGLayoutInlineItem::kText) {
       DCHECK(item.GetLayoutObject()->IsText());
-      const ComputedStyle* style = item.Style();
-      // 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);
-
-      // |InlineTextBoxPainter| sets the baseline at |top +
-      // ascent-of-primary-font|. Compute |top| to match.
-      NGLineHeightMetrics metrics(*style, baseline_type_);
-      block_start = -metrics.ascent;
-      metrics.AddLeading(style->ComputedLineHeightAsFixed());
-      text_builder.SetBlockSize(metrics.LineHeight());
-      line_box.UniteMetrics(metrics);
-
+      if (box->text_metrics.IsEmpty())
+        box->ComputeTextMetrics(item, baseline_type_);
+      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 (style->LineHeight().IsNegative())
+      if (box->include_used_fonts)
         AccumulateUsedFonts(item, line_item_chunk, &line_box);
+    } else if (item.Type() == NGLayoutInlineItem::kOpenTag) {
+      box = box_states_.OnOpenTag(item, &line_box, &text_builder);
+      continue;
+    } else if (item.Type() == NGLayoutInlineItem::kCloseTag) {
+      box = box_states_.OnCloseTag(item, &line_box, box);
+      continue;
     } else if (item.Type() == NGLayoutInlineItem::kAtomicInline) {
-      block_start = PlaceAtomicInline(item, &line_box, &text_builder);
+      line_top = PlaceAtomicInline(item, &line_box, box, &text_builder);
     } else if (item.Type() == NGLayoutInlineItem::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.
       container_builder_.AddOutOfFlowDescendant(
           // Absolute positioning blockifies the box's display type.
           // https://drafts.csswg.org/css-display/#transformations
           new NGBlockNode(item.GetLayoutObject()),
           NGStaticPosition::Create(ConstraintSpace().WritingMode(),
                                    ConstraintSpace().Direction(),
                                    NGPhysicalOffset()));
       continue;
     } else {
       continue;
     }
 
     RefPtr<NGPhysicalTextFragment> text_fragment = text_builder.ToTextFragment(
         line_item_chunk.index, line_item_chunk.start_offset,
         line_item_chunk.end_offset);
 
     NGLogicalOffset logical_offset(
         inline_size + current_opportunity_.InlineStartOffset() -
             ConstraintSpace().BfcOffset().inline_offset,
-        block_start);
+        line_top);
     line_box.AddChild(std::move(text_fragment), logical_offset);
     inline_size += line_item_chunk.inline_size;
   }
 
   if (line_box.Children().IsEmpty()) {
     return true;  // The line was empty.
   }
 
+  box_states_.OnEndPlaceItems(&line_box);
+
   // The baselines are always placed at pixel boundaries. Not doing so results
   // in incorrect layout of text decorations, most notably underlines.
   LayoutUnit baseline = content_size_ + line_box.Metrics().ascent;
   baseline = LayoutUnit(baseline.Round());
 
   // Check if the line fits into the constraint space in block direction.
   LayoutUnit line_bottom = baseline + line_box.Metrics().descent;
   if (!container_builder_.Children().IsEmpty() &&
       ConstraintSpace().AvailableSize().block_size != NGSizeIndefinite &&
       line_bottom > ConstraintSpace().AvailableSize().block_size) {
@@ skipping 34 matching lines @@
     NGLineHeightMetrics metrics(fallback_font->GetFontMetrics(),
                                 baseline_type_);
     metrics.AddLeading(fallback_font->GetFontMetrics().FixedLineSpacing());
     line_box->UniteMetrics(metrics);
   }
 }
 
 LayoutUnit NGInlineLayoutAlgorithm::PlaceAtomicInline(
     const NGLayoutInlineItem& 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();
 
   // 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()).SetBlockSize(block_size);
+  text_builder->SetSize({fragment.InlineSize(), block_size});
 
   // TODO(kojii): Add baseline position to NGPhysicalFragment.
-  LayoutBox* box = ToLayoutBox(item.GetLayoutObject());
+  LayoutBox* layout_box = ToLayoutBox(item.GetLayoutObject());
   LineDirectionMode line_direction_mode =
       IsHorizontalWritingMode() ? LineDirectionMode::kHorizontalLine
                                 : LineDirectionMode::kVerticalLine;
-  LayoutUnit baseline_offset(box->BaselinePosition(
+  LayoutUnit baseline_offset(layout_box->BaselinePosition(
       baseline_type_, IsFirstLine(), line_direction_mode));
-  line_box->UniteMetrics({baseline_offset, block_size - baseline_offset});
+
+  NGLineHeightMetrics metrics(baseline_offset, block_size - baseline_offset);
+  state->metrics.Unite(metrics);
 
   // TODO(kojii): Figure out what to do with OOF in NGLayoutResult.
   // Floats are ok because atomic inlines are BFC?
 
-  return -baseline_offset;
+  return -metrics.ascent;
 }
 
 void NGInlineLayoutAlgorithm::FindNextLayoutOpportunity() {
   NGLogicalOffset iter_offset = ConstraintSpace().BfcOffset();
   iter_offset.block_offset += content_size_;
   auto* iter = MutableConstraintSpace()->LayoutOpportunityIterator(iter_offset);
   NGLayoutOpportunity opportunity = iter->Next();
   if (!opportunity.IsEmpty())
     current_opportunity_ = opportunity;
 }
@@ skipping 27 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