[LayoutNG] Handle empty inlines and border edges

third_party/WebKit/Source/core/layout/ng/inline/ng_inline_box_state.cc

 // Copyright 2017 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_box_state.h"
 
+#include "core/layout/ng/inline/ng_inline_item_result.h"
 #include "core/layout/ng/inline/ng_inline_node.h"
 #include "core/layout/ng/inline/ng_line_box_fragment_builder.h"
 #include "core/layout/ng/inline/ng_text_fragment_builder.h"
 #include "core/layout/ng/ng_fragment_builder.h"
 #include "core/layout/ng/ng_layout_result.h"
 #include "core/style/ComputedStyle.h"
 
 namespace blink {
 
 void NGInlineBoxState::ComputeTextMetrics(const ComputedStyle& style,
@@ skipping 14 matching lines @@
   item.GetFallbackFonts(&fallback_fonts, start, end);
   for (const auto& fallback_font : fallback_fonts) {
     NGLineHeightMetrics fallback_metrics(fallback_font->GetFontMetrics(),
                                          baseline_type);
     fallback_metrics.AddLeading(
         fallback_font->GetFontMetrics().FixedLineSpacing());
     metrics.Unite(fallback_metrics);
   }
 }
 
-void NGInlineBoxState::SetNeedsBoxFragment(
-    LayoutUnit position,
-    LayoutUnit borders_paddings_block_start,
-    LayoutUnit borders_paddings_block_height) {
-  needs_box_fragment = true;
-  line_left_position = position;
-  this->borders_paddings_block_start = borders_paddings_block_start;
-  this->borders_paddings_block_height = borders_paddings_block_height;
-}
-
 NGInlineBoxState* NGInlineLayoutStateStack::OnBeginPlaceItems(
     const ComputedStyle* line_style,
     FontBaseline baseline_type) {
   if (stack_.IsEmpty()) {
     // For the first line, push a box state for the line itself.
     stack_.resize(1);
     NGInlineBoxState* box = &stack_.back();
     box->fragment_start = 0;
   } else {
     // For the following lines, clear states that are not shared across lines.
     for (auto& box : stack_) {
       box.fragment_start = 0;
       box.metrics = NGLineHeightMetrics();
+      // Existing box states are wrapped boxes, and hence no left edges.
+      box.border_edges.line_left = false;
       DCHECK(box.pending_descendants.IsEmpty());
     }
   }
 
   // Initialize the box state for the line box.
   NGInlineBoxState& line_box = LineBoxState();
   line_box.style = line_style;
 
   // 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.
@@ skipping 11 matching lines @@
   box->fragment_start = line_box->Children().size();
   box->item = &item;
   box->style = item.Style();
   return box;
 }
 
 NGInlineBoxState* NGInlineLayoutStateStack::OnCloseTag(
     const NGInlineItem& item,
     NGLineBoxFragmentBuilder* line_box,
     NGInlineBoxState* box,
-    FontBaseline baseline_type,
-    LayoutUnit position) {
-  EndBoxState(box, line_box, baseline_type, position);
+    FontBaseline baseline_type) {
+  EndBoxState(box, line_box, baseline_type);
   // TODO(kojii): When the algorithm restarts from a break token, the stack may
   // underflow. We need either synthesize a missing box state, or push all
   // parents on initialize.
   stack_.pop_back();
   return &stack_.back();
 }
 
 void NGInlineLayoutStateStack::OnEndPlaceItems(
     NGLineBoxFragmentBuilder* line_box,
     FontBaseline baseline_type,
     LayoutUnit position) {
   for (auto it = stack_.rbegin(); it != stack_.rend(); ++it) {
     NGInlineBoxState* box = &(*it);
-    EndBoxState(box, line_box, baseline_type, position);
+    box->line_right_position = position;
+    EndBoxState(box, line_box, baseline_type);
   }
 
   if (!box_placeholders_.IsEmpty())
     CreateBoxFragments(line_box);
 
   DCHECK(!LineBoxState().metrics.IsEmpty());
   line_box->SetMetrics(LineBoxState().metrics);
 }
 
 void NGInlineLayoutStateStack::EndBoxState(NGInlineBoxState* box,
                                            NGLineBoxFragmentBuilder* line_box,
-                                           FontBaseline baseline_type,
-                                           LayoutUnit position) {
+                                           FontBaseline baseline_type) {
   if (box->needs_box_fragment)
-    AddBoxFragmentPlaceholder(box, line_box, baseline_type, position);
+    AddBoxFragmentPlaceholder(box, line_box, baseline_type);
 
   PositionPending position_pending =
       ApplyBaselineShift(box, line_box, baseline_type);
 
   // Unite the metrics to the parent box.
   if (position_pending == kPositionNotPending && box != stack_.begin()) {
     box[-1].metrics.Unite(box->metrics);
   }
 }
 
+void NGInlineBoxState::SetNeedsBoxFragment(
+    const NGInlineItem& item,
+    const NGInlineItemResult& item_result,
+    LayoutUnit position) {
+  needs_box_fragment = true;
+  line_left_position = position + item_result.margins.inline_start;
+  borders_paddings_block_start = item_result.borders_paddings_block_start;
+  borders_paddings_block_end = item_result.borders_paddings_block_end;
+  // We have left edge on open tag, and if the box is not a continuation.
+  // TODO(kojii): Needs review when we change SplitInlines().
+  bool has_line_left_edge = item.Style()->IsLeftToRightDirection()
+                                ? item.HasStartEdge()
+                                : item.HasEndEdge();
+  border_edges = {true, false, true, has_line_left_edge};
+}
+
+void NGInlineBoxState::SetLineRightForBoxFragment(
+    const NGInlineItem& item,
+    const NGInlineItemResult& item_result,
+    LayoutUnit position) {
+  DCHECK(needs_box_fragment);
+  line_right_position = position - item_result.margins.inline_end;
+  // We have right edge on close tag, and if the box does not have a
+  // continuation.
+  // TODO(kojii): Needs review when we change SplitInlines().
+  border_edges.line_right = item.Style()->IsLeftToRightDirection()
+                                ? item.HasEndEdge()
+                                : item.HasStartEdge();
+}
+
 // Crete a placeholder for a box fragment.
 // We keep a flat list of fragments because it is more suitable for operations
 // such as ApplyBaselineShift. Later, CreateBoxFragments() creates box fragments
 // from placeholders.
 void NGInlineLayoutStateStack::AddBoxFragmentPlaceholder(
     NGInlineBoxState* box,
     NGLineBoxFragmentBuilder* line_box,
-    FontBaseline baseline_type,
-    LayoutUnit position) {
-  if (box->fragment_start == line_box->Children().size()) {
-    // Don't create a placeholder if the inline box is empty.
+    FontBaseline baseline_type) {
+  LayoutUnit inline_size = box->line_right_position - box->line_left_position;
+  if (box->fragment_start == line_box->Children().size() && inline_size <= 0) {
+    // Don't create a box if the inline box is "empty".
+    // Inline boxes with inline margins/borders/paddings are not "empty",
+    // but background doesn't make difference in this context.
     // Whether to create this box or not affects layout when the line contains
     // only this box, since this box participates the line height.
-    // TODO(kojii): Testing indicates that we should create a box if it has
-    // borders, but not for backgrounds. But creating such a RootInlineBox needs
-    // additional code. The plan is to enable such line box when NG paint is
-    // enabled.
     return;
   }
 
   // The inline box should have the height of the font metrics without the
   // line-height property. Compute from style because |box->metrics| includes
   // the line-height property.
   DCHECK(box->style);
   const ComputedStyle& style = *box->style;
   NGLineHeightMetrics metrics(style, baseline_type);
 
   // Extend the block direction of the box by borders and paddings. Inline
   // direction is already included into positions in NGLineBreaker.
   NGLogicalRect bounds(
       box->line_left_position,
-      -metrics.ascent - box->borders_paddings_block_start,
-      position - box->line_left_position,
-      metrics.LineHeight() + box->borders_paddings_block_height);
+      -metrics.ascent - box->borders_paddings_block_start, inline_size,
+      metrics.LineHeight() + box->borders_paddings_block_start +
+          box->borders_paddings_block_end);
 
   // The start is marked only in BoxFragmentPlaceholder, while end is marked
   // in both BoxFragmentPlaceholder and the list itself.
   // With a list of 4 text fragments:
   // |  0  |  1  |  2  |  3  |
   // |text0|text1|text2|text3|
   // By adding a BoxFragmentPlaceholder(2,4) (end is exclusive), it becomes:
   // |  0  |  1  |  2  |  3  |  4  |
   // |text0|text1|text2|text3|null |
   // The "null" is added to the list to compute baseline shift of the box
   // separately from text fragments.
   unsigned fragment_end = line_box->Children().size();
-  box_placeholders_.push_back(BoxFragmentPlaceholder{
-      box->fragment_start, fragment_end, box->item, bounds.size});
+  box_placeholders_.push_back(
+      BoxFragmentPlaceholder{box->fragment_start, fragment_end, box->item,
+                             bounds.size, box->border_edges});
   line_box->AddChild(nullptr, bounds.offset);
 }
 
 // Create box fragments and construct a tree from the placeholders.
 void NGInlineLayoutStateStack::CreateBoxFragments(
     NGLineBoxFragmentBuilder* line_box) {
   DCHECK(!box_placeholders_.IsEmpty());
 
   Vector<RefPtr<NGPhysicalFragment>> children =
       std::move(line_box->MutableChildren());
@@ skipping 14 matching lines @@
     for (unsigned i = placeholder.fragment_start; i < placeholder.fragment_end;
          i++) {
       if (RefPtr<NGPhysicalFragment>& child = children[i]) {
         box.AddChild(std::move(child), offsets[i] - box_offset);
         DCHECK(!children[i]);
       }
     }
 
     box.SetWritingMode(line_box->WritingMode());
     box.SetDirection(placeholder.item->Direction());
+    // Inline boxes have block start/end borders, even when its containing block
+    // was fragmented. Fragmenting a line box in block direction is not
+    // supported today.
+    box.SetBorderEdges(placeholder.border_edges);
     box.SetSize(placeholder.size);
     // TODO(kojii): Overflow size should be computed from children.
     box.SetOverflowSize(placeholder.size);
     RefPtr<NGLayoutResult> layout_result = box.ToBoxFragment();
     DCHECK(!children[placeholder.fragment_end]);
     children[placeholder.fragment_end] =
         std::move(layout_result->MutablePhysicalFragment());
   }
   box_placeholders_.clear();
 
@@ skipping 100 matching lines @@
           box->fragment_start, fragment_end, box->metrics, vertical_align});
       return kPositionPending;
   }
   box->metrics.Move(baseline_shift);
   line_box->MoveChildrenInBlockDirection(baseline_shift, box->fragment_start,
                                          fragment_end);
   return kPositionNotPending;
 }
 
 }  // namespace blink