[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)
+      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();

[ikilpatrick, 2017/03/16 18:26:16]

oh you may need to perform a std::move?

i.e.

return std::move(node->Layout(constraint_space.get()));

[kojii, 2017/03/16 19:16:33]

raw pointers should not need std::move(), nor copy elision, nor NRVO, no?

+}
+
 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 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)

[ikilpatrick, 2017/03/16 18:26:15]

.nit, block_size, but fine with cleaning up later.

[kojii, 2017/03/16 19:16:33]

This one is really a line height, not a block size, just passed to
SetBlockSize()...maybe I should create a TextFragmentBuilder with line-relative
terminologies?

Changed to |line_height| to clarify that this is not physical height but logical
line 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_;
+      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);
     fragments_.push_back(std::move(text_fragment));
 
     NGLogicalOffset logical_offset(
         line_box_data.inline_size + current_opportunity_.InlineStartOffset() -
             ConstraintSpace().BfcOffset().inline_offset,
-        top);
+        block_start);
     offsets_.push_back(logical_offset);
     line_box_data.inline_size += line_item_chunk.inline_size;
   }
   DCHECK_EQ(fragments_.size(), offsets_.size());
 
   if (fragment_start_index == fragments_.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|

[ikilpatrick, 2017/03/16 18:26:16]

it'd also be nice if we had all the information in the fragments, and could
perform the copy inside NGInlineNode eventually.

[kojii, 2017/03/16 19:16:33]

Yes, that's the plan. All information -- line_top, text_top, text_bottom, and
line_bottom. Legacy also has selection_top, selection_bottom, I need to read a
bit more code on selection_{top|bottom} for what it does differently from
text_{top|bottom}. The plan is to have them in LineBoxFragment, so that paint
can use them without relying on LayoutObject tree.

We also need baseline position, but this is needed for box, since all boxes have
synthesized baseline position. This is in my queue.

With all of them in fragments, I'll eliminate keeping LineBoxData and Fragment
to match later in 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 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