[LayoutNG] Handle empty inlines and border edges

third_party/WebKit/Source/core/layout/ng/inline/ng_inline_node.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_node.h"
 
 #include "core/layout/BidiRun.h"
 #include "core/layout/LayoutBlockFlow.h"
 #include "core/layout/LayoutObject.h"
 #include "core/layout/LayoutText.h"
@@ skipping 19 matching lines @@
 #include "platform/fonts/shaping/HarfBuzzShaper.h"
 #include "platform/wtf/text/CharacterNames.h"
 
 namespace blink {
 
 namespace {
 
 struct FragmentPosition {
   NGLogicalOffset offset;
   LayoutUnit inline_size;
+  NGBorderEdges border_edges;
 };
 
 // Create BidiRuns from a list of NGPhysicalFragment.
 // Produce a FragmentPosition map to place InlineBoxes.
 void CreateBidiRuns(BidiRunList<BidiRun>* bidi_runs,
                     const Vector<RefPtr<NGPhysicalFragment>>& children,
                     const NGConstraintSpace& constraint_space,
                     NGLogicalOffset parent_offset,
                     const Vector<NGInlineItem>& items,
                     const Vector<unsigned, 32>& text_offsets,
@@ skipping 28 matching lines @@
       // One LayoutText may produce multiple text fragments that they can't
       // be set to a map.
       positions_for_bidi_runs_out->push_back(FragmentPosition{
           fragment.Offset() + parent_offset, fragment.InlineSize()});
     } else {
       DCHECK_EQ(child->Type(), NGPhysicalFragment::kFragmentBox);
       NGPhysicalBoxFragment* physical_fragment =
           ToNGPhysicalBoxFragment(child.Get());
       NGBoxFragment fragment(constraint_space.WritingMode(), physical_fragment);
       NGLogicalOffset child_offset = fragment.Offset() + parent_offset;
-      CreateBidiRuns(bidi_runs, physical_fragment->Children(), constraint_space,
-                     child_offset, items, text_offsets,
-                     positions_for_bidi_runs_out, positions_out);
+      if (physical_fragment->Children().size()) {
+        CreateBidiRuns(bidi_runs, physical_fragment->Children(),
+                       constraint_space, child_offset, items, text_offsets,
+                       positions_for_bidi_runs_out, positions_out);
+      } else {
+        // An empty inline needs a BidiRun for itself.
+        LayoutObject* layout_object = physical_fragment->GetLayoutObject();
+        BidiRun* run = new BidiRun(0, 1, 0, LineLayoutItem(layout_object));
+        bidi_runs->AddRun(run);
+      }
       // Store box fragments in a map by LineLayoutItem.
       positions_out->Set(LineLayoutItem(child->GetLayoutObject()),
-                         FragmentPosition{child_offset, fragment.InlineSize()});
+                         FragmentPosition{child_offset, fragment.InlineSize(),
+                                          fragment.BorderEdges()});
     }
   }
 }
 
 // Set the geometry to InlineBoxes by using the FragmentPosition map.
 // When the map doesn't provide positions; i.e., when InlineFlowBox doesn't have
 // corresponding box fragment, compute the union of children.
 unsigned PlaceInlineBoxChildren(
     InlineFlowBox* parent,
     const Vector<FragmentPosition, 32>& positions_for_bidi_runs,
     const HashMap<LineLayoutItem, FragmentPosition>& positions,
     unsigned text_index = 0,
     bool set_parent_position_from_children = false) {
   LayoutUnit logical_left = LayoutUnit::Max();
   LayoutUnit logical_right = LayoutUnit::Min();
   LayoutUnit logical_top = LayoutUnit::Max();
   for (InlineBox* inline_box = parent->FirstChild(); inline_box;
        inline_box = inline_box->NextOnLine()) {
     if (inline_box->IsInlineFlowBox()) {
+      InlineFlowBox* flow_box = ToInlineFlowBox(inline_box);
       const auto& iter = positions.find(inline_box->GetLineLayoutItem());
       if (iter != positions.end()) {
         const FragmentPosition& position = iter->value;
         inline_box->SetLogicalLeft(position.offset.inline_offset);
         inline_box->SetLogicalTop(position.offset.block_offset);
         inline_box->SetLogicalWidth(position.inline_size);
+        flow_box->SetEdges(position.border_edges.line_left,
+                           position.border_edges.line_right);
       }
 
-      text_index = PlaceInlineBoxChildren(ToInlineFlowBox(inline_box),
-                                          positions_for_bidi_runs, positions,
-                                          text_index, iter == positions.end());
+      text_index =
+          PlaceInlineBoxChildren(flow_box, positions_for_bidi_runs, positions,
+                                 text_index, iter == positions.end());
     } else {
       const FragmentPosition& position = positions_for_bidi_runs[text_index++];
       inline_box->SetLogicalLeft(position.offset.inline_offset);
       inline_box->SetLogicalTop(position.offset.block_offset);
       inline_box->SetLogicalWidth(position.inline_size);
       if (inline_box->GetLineLayoutItem().IsBox()) {
         LineLayoutBox box(inline_box->GetLineLayoutItem());
         box.SetLocation(inline_box->Location());
       }
     }
@@ skipping 354 matching lines @@
     current_text->SetTextInternal(
         Text(current_offset, Data().text_content_.length()).ToString().Impl());
   }
 }
 
 String NGInlineNode::ToString() const {
   return String::Format("NGInlineNode");
 }
 
 }  // namespace blink