[LayoutNG] Cleanup computing margins/border/padding in NGLineBreaker

1. Padding for atomic inline isn't used. Removed computing it.
2. Both converting to NGBoxStrut and then to NGLineBoxStrut
   should use the same writing-mode. Added ng_length_utils
   functions for the two conversions to occur at the same
   place.

Bug: 636993
Cq-Include-Trybots: luci.chromium.try:linux_layout_tests_layout_ng
Change-Id: I3deace37ae5334af0f919d4c557effe067328da9
Reviewed-on: https://chromium-review.googlesource.com/1181004
Commit-Queue: Koji Ishii <kojii@chromium.org>
Reviewed-by: Christian Biesinger <cbiesinger@chromium.org>
Reviewed-by: Emil A Eklund <eae@chromium.org>
Cr-Commit-Position: refs/heads/master@{#586218}

third_party/blink/renderer/core/layout/ng/geometry/ng_box_strut.cc

@@ -49,8 +49,6 @@ NGPhysicalBoxStrut NGBoxStrut::ConvertToPhysical(
   }
 }
 
-// Converts physical dimensions to logical ones per
-// https://drafts.csswg.org/css-writing-modes-3/#logical-to-physical
 NGBoxStrut NGPhysicalBoxStrut::ConvertToLogical(WritingMode writing_mode,
                                                 TextDirection direction) const {
   NGBoxStrut strut;
@@ -74,6 +72,13 @@ NGBoxStrut NGPhysicalBoxStrut::ConvertToLogical(WritingMode writing_mode,
   return strut;
 }
 
+NGLineBoxStrut NGPhysicalBoxStrut::ConvertToLineLogical(
+    WritingMode writing_mode,
+    TextDirection direction) const {
+  return NGLineBoxStrut(ConvertToLogical(writing_mode, direction),
+                        IsFlippedLinesWritingMode(writing_mode));
+}
+
 String NGBoxStrut::ToString() const {
   return String::Format("Inline: (%d %d) Block: (%d %d)", inline_start.ToInt(),
                         inline_end.ToInt(), block_start.ToInt(),

third_party/blink/renderer/core/layout/ng/geometry/ng_box_strut.h

@@ -130,7 +130,14 @@ struct CORE_EXPORT NGPhysicalBoxStrut {
                      LayoutUnit left)
       : top(top), right(right), bottom(bottom), left(left) {}
 
+  // Converts physical dimensions to logical ones per
+  // https://drafts.csswg.org/css-writing-modes-3/#logical-to-physical
   NGBoxStrut ConvertToLogical(WritingMode, TextDirection) const;
+
+  // Converts physical dimensions to line-relative logical ones per
+  // https://drafts.csswg.org/css-writing-modes-3/#line-directions
+  NGLineBoxStrut ConvertToLineLogical(WritingMode, TextDirection) const;
+
   NGPixelSnappedPhysicalBoxStrut SnapToDevicePixels() const;
 
   LayoutUnit HorizontalSum() const { return left + right; }

third_party/blink/renderer/core/layout/ng/inline/ng_inline_item_result.h

@@ -50,7 +50,8 @@ struct CORE_EXPORT NGInlineItemResult {
   // NGLayoutResult for atomic inline items.
   scoped_refptr<NGLayoutResult> layout_result;
 
-  // Margins, borders, and padding for atomic inline items and open tags.
+  // Margins, borders, and padding for open tags.
+  // Margins are set for atomic inlines too.
   NGLineBoxStrut margins;
   NGLineBoxStrut borders;
   NGLineBoxStrut padding;

third_party/blink/renderer/core/layout/ng/inline/ng_line_breaker.cc

@@ -782,14 +782,12 @@ void NGLineBreaker::HandleAtomicInline(const NGInlineItem& item) {
                                    : sizes.max_size;
   }
 
+  // For the inline layout purpose, only inline-margins are needed, computed for
+  // the line's writing-mode.
   DCHECK(item.Style());
   const ComputedStyle& style = *item.Style();
-  bool is_flipped_lines = style.IsFlippedLinesWritingMode();
-  item_result->margins = NGLineBoxStrut(
-      ComputeMarginsForVisualContainer(constraint_space_, style),
-      IsFlippedLinesWritingMode(constraint_space_.GetWritingMode()));
-  item_result->padding = NGLineBoxStrut(
-      ComputePadding(constraint_space_, style), is_flipped_lines);
+  item_result->margins =
+      ComputeLineMarginsForVisualContainer(constraint_space_, style);
   item_result->inline_size += item_result->margins.InlineSum();
 
   if (state_ == LineBreakState::kLeading)
@@ -915,14 +913,10 @@ bool NGLineBreaker::ComputeOpenTagResult(
   if (item.ShouldCreateBoxFragment() &&
       (style.HasBorder() || style.HasPadding() ||
        (style.HasMargin() && item_result->has_edge))) {
-    bool is_flipped_lines = style.IsFlippedLinesWritingMode();
-    item_result->borders = NGLineBoxStrut(
-        ComputeBorders(constraint_space, style), is_flipped_lines);
-    item_result->padding = NGLineBoxStrut(
-        ComputePadding(constraint_space, style), is_flipped_lines);
+    item_result->borders = ComputeLineBorders(constraint_space, style);
+    item_result->padding = ComputeLinePadding(constraint_space, style);
     if (item_result->has_edge) {
-      item_result->margins = NGLineBoxStrut(
-          ComputeMarginsForSelf(constraint_space, style), is_flipped_lines);
+      item_result->margins = ComputeLineMarginsForSelf(constraint_space, style);
       item_result->inline_size = item_result->margins.inline_start +
                                  item_result->borders.inline_start +
                                  item_result->padding.inline_start;

third_party/blink/renderer/core/layout/ng/ng_length_utils.cc

@@ -638,11 +638,12 @@ NGBoxStrut ComputeMarginsFor(const NGConstraintSpace& constraint_space,
       .ConvertToLogical(compute_for.GetWritingMode(), compute_for.Direction());
 }
 
-NGBoxStrut ComputeMarginsForVisualContainer(
+NGLineBoxStrut ComputeLineMarginsForVisualContainer(
     const NGConstraintSpace& constraint_space,
     const ComputedStyle& style) {
   return ComputePhysicalMargins(constraint_space, style)
-      .ConvertToLogical(constraint_space.GetWritingMode(), TextDirection::kLtr);
+      .ConvertToLineLogical(constraint_space.GetWritingMode(),
+                            TextDirection::kLtr);
 }
 
 NGBoxStrut ComputeMarginsForSelf(const NGConstraintSpace& constraint_space,
@@ -651,6 +652,13 @@ NGBoxStrut ComputeMarginsForSelf(const NGConstraintSpace& constraint_space,
       .ConvertToLogical(style.GetWritingMode(), style.Direction());
 }
 
+NGLineBoxStrut ComputeLineMarginsForSelf(
+    const NGConstraintSpace& constraint_space,
+    const ComputedStyle& style) {
+  return ComputePhysicalMargins(constraint_space, style)
+      .ConvertToLineLogical(style.GetWritingMode(), style.Direction());
+}
+
 NGBoxStrut ComputeMinMaxMargins(const ComputedStyle& parent_style,
                                 NGLayoutInputNode child) {
   // An inline child just produces line-boxes which don't have any margins.
@@ -704,6 +712,12 @@ NGBoxStrut ComputeBorders(const NGConstraintSpace& constraint_space,
   return ComputeBorders(constraint_space, node.Style());
 }
 
+NGLineBoxStrut ComputeLineBorders(const NGConstraintSpace& constraint_space,
+                                  const ComputedStyle& style) {
+  return NGLineBoxStrut(ComputeBorders(constraint_space, style),
+                        style.IsFlippedLinesWritingMode());
+}
+
 NGBoxStrut ComputePadding(const NGConstraintSpace& constraint_space,
                           const ComputedStyle& style) {
   // If we are producing an anonymous fragment (e.g. a column) we shouldn't
@@ -744,6 +758,12 @@ NGBoxStrut ComputePadding(const NGConstraintSpace& constraint_space,
   return padding;
 }
 
+NGLineBoxStrut ComputeLinePadding(const NGConstraintSpace& constraint_space,
+                                  const ComputedStyle& style) {
+  return NGLineBoxStrut(ComputePadding(constraint_space, style),
+                        style.IsFlippedLinesWritingMode());
+}
+
 void ResolveInlineMargins(const ComputedStyle& style,
                           const ComputedStyle& containing_block_style,
                           LayoutUnit available_inline_size,

third_party/blink/renderer/core/layout/ng/ng_length_utils.h

@@ -149,21 +149,29 @@ CORE_EXPORT LayoutUnit ResolveUsedColumnGap(LayoutUnit available_size,
 // Compute physical margins.
 CORE_EXPORT NGPhysicalBoxStrut ComputePhysicalMargins(const NGConstraintSpace&,
                                                       const ComputedStyle&);
+
 // Compute margins for the specified NGConstraintSpace.
 CORE_EXPORT NGBoxStrut ComputeMarginsFor(const NGConstraintSpace&,
                                          const ComputedStyle&,
                                          const NGConstraintSpace& compute_for);
-// Compute margins for the NGConstraintSpace.
-CORE_EXPORT NGBoxStrut ComputeMarginsForContainer(const NGConstraintSpace&,
-                                                  const ComputedStyle&);
-// Compute margins for the NGConstraintSpace in the visual order.
-CORE_EXPORT NGBoxStrut
-ComputeMarginsForVisualContainer(const NGConstraintSpace&,
-                                 const ComputedStyle&);
+
 // Compute margins for the style owner.
 CORE_EXPORT NGBoxStrut ComputeMarginsForSelf(const NGConstraintSpace&,
                                              const ComputedStyle&);
 
+// Compute line logical margins for the style owner.
+//
+// The "line" versions compute line-relative logical values. See NGLineBoxStrut
+// for more details.
+CORE_EXPORT NGLineBoxStrut ComputeLineMarginsForSelf(const NGConstraintSpace&,
+                                                     const ComputedStyle&);
+
+// Compute line logical margins for the constraint space, in the visual order
+// (always assumes LTR, ignoring the direction) for inline layout algorithm.
+CORE_EXPORT NGLineBoxStrut
+ComputeLineMarginsForVisualContainer(const NGConstraintSpace&,
+                                     const ComputedStyle&);
+
 // Compute margins for a child during the min-max size calculation.
 CORE_EXPORT NGBoxStrut ComputeMinMaxMargins(const ComputedStyle& parent_style,
                                             NGLayoutInputNode child);
@@ -174,12 +182,18 @@ CORE_EXPORT NGBoxStrut ComputeBorders(const NGConstraintSpace&,
 CORE_EXPORT NGBoxStrut ComputeBorders(const NGConstraintSpace&,
                                       const NGLayoutInputNode);
 
+CORE_EXPORT NGLineBoxStrut ComputeLineBorders(const NGConstraintSpace&,
+                                              const ComputedStyle&);
+
 CORE_EXPORT NGBoxStrut ComputePadding(const NGConstraintSpace&,
                                       const ComputedStyle&);
 
 CORE_EXPORT NGBoxStrut ComputePadding(const NGConstraintSpace&,
                                       const NGLayoutInputNode);
 
+CORE_EXPORT NGLineBoxStrut ComputeLinePadding(const NGConstraintSpace&,
+                                              const ComputedStyle&);
+
 // Convert inline margins from computed to used values. This will resolve 'auto'
 // values and over-constrainedness. This uses the available size from the
 // constraint space and inline size to compute the margins that are auto, if