[LayoutNG] Implement more text-align values and BiDi base direction

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 230 matching lines @@
   // Up until this point, children are placed so that the dominant baseline is
   // at 0. Move them to the final baseline position, and set the logical top of
   // the line box to the line top.
   line_box.MoveChildrenInBlockDirection(baseline);
 
   NGLayoutOpportunity line_opp = FindLayoutOpportunityForLine();
 
   LayoutUnit inline_size = position;
   NGLogicalOffset offset(LogicalLeftOffset(line_opp),
                          baseline - box_states_.LineBoxState().metrics.ascent);
-  ApplyTextAlign(line_style, line_style.GetTextAlign(line_info->IsLastLine()),
+  ApplyTextAlign(line_style.GetTextAlign(line_info->IsLastLine()),
                  &offset.inline_offset, inline_size, line_opp.InlineSize());
 
   line_box.SetInlineSize(inline_size);
   container_builder_.AddChild(line_box.ToLineBoxFragment(), offset);
 
   max_inline_size_ = std::max(max_inline_size_, inline_size);
   content_size_ = ComputeContentSize(*line_info, line_bottom);
 
   return true;
 }
@@ skipping 42 matching lines @@
   text_builder->SetSize({fragment.InlineSize(), block_size});
   LayoutUnit line_top = item_result->margins.block_start - metrics.ascent;
   RefPtr<NGPhysicalTextFragment> text_fragment = text_builder->ToTextFragment(
       item_result->item_index, item_result->start_offset,
       item_result->end_offset);
   line_box->AddChild(std::move(text_fragment), {position, line_top});
 
   return box_states_.OnCloseTag(item, line_box, box, baseline_type_);
 }
 
-void NGInlineLayoutAlgorithm::ApplyTextAlign(const ComputedStyle& line_style,
-                                             ETextAlign text_align,
+void NGInlineLayoutAlgorithm::ApplyTextAlign(ETextAlign text_align,
                                              LayoutUnit* line_left,
                                              LayoutUnit inline_size,
                                              LayoutUnit available_width) {
-  switch (text_align) {
-    case ETextAlign::kRight:
-    case ETextAlign::kWebkitRight:
-      // Wide lines spill out of the block based off direction.
-      // So even if text-align is right, if direction is LTR, wide lines should
-      // overflow out of the right side of the block.
-      // TODO(kojii): Investigate how to handle trailing spaces.
-      if (inline_size < available_width || !line_style.IsLeftToRightDirection())
-        *line_left += available_width - inline_size;
-      break;
-    default:
-      // TODO(layout-dev): Implement.
-      // Refer to LayoutBlockFlow::UpdateLogicalWidthForAlignment().
-      break;
+  bool is_base_ltr = IsLtr(Node().BaseDirection());
+  // TODO(kojii): Investigate handling trailing spaces.
+  // Refer to LayoutBlockFlow::UpdateLogicalWidthForAlignment().
+  while (true) {
+    switch (text_align) {
+      case ETextAlign::kLeft:
+      case ETextAlign::kWebkitLeft:
+        // The direction of the block should determine what happens with wide
+        // lines. In particular with RTL blocks, wide lines should still spill
+        // out to the left.
+        if (!is_base_ltr && inline_size > available_width)
+          *line_left -= inline_size - available_width;
+        return;
+      case ETextAlign::kRight:
+      case ETextAlign::kWebkitRight:
+        // Wide lines spill out of the block based off direction.
+        // So even if text-align is right, if direction is LTR, wide lines
+        // should overflow out of the right side of the block.
+        if (inline_size < available_width || !is_base_ltr)
+          *line_left += available_width - inline_size;
+        return;
+      case ETextAlign::kCenter:
+      case ETextAlign::kWebkitCenter:
+        if (is_base_ltr) {
+          *line_left +=
+              std::max((available_width - inline_size) / 2, LayoutUnit());
+        } else {
+          *line_left += inline_size > available_width
+                            ? (available_width - inline_size)
+                            : (available_width - inline_size) / 2;

[eae, 2017/06/19 15:36:49]

Could you explain the math here please? If inline_size > available_width
(available_width - inline_size) would be negative, pushing the line outside of
the box. That doesn't seem right to me.

[kojii, 2017/06/20 03:52:20]

It's saying: "if RTL and overflow, do 'right' align", and if RTL right align
overflows, it pushes the line outside to left, as in ETextAlign::kRight does.

But I agree this is very hard to read, I had to read this section of
LayoutBlockFlow::UpdateLogicalWidthForAlignment() multiple times to understand.
I'll try to make it more readable with comments.

+        }
+        return;
+      case ETextAlign::kStart:
+        text_align = is_base_ltr ? ETextAlign::kLeft : ETextAlign::kRight;
+        continue;
+      case ETextAlign::kEnd:
+        text_align = is_base_ltr ? ETextAlign::kRight : ETextAlign::kLeft;
+        continue;
+      case ETextAlign::kJustify:
+        // TODO(kojii): Implement.
+        return;
+    }
+    NOTREACHED();
+    return;
   }
 }
 
 LayoutUnit NGInlineLayoutAlgorithm::ComputeContentSize(
     const NGLineInfo& line_info,
     LayoutUnit line_bottom) {
   LayoutUnit content_size = line_bottom;
 
   const Vector<NGInlineItem>& items = Node().Items();
   const NGInlineItemResults& line_items = line_info.Results();
@@ skipping 62 matching lines @@
   // Margin struts shouldn't need to be passed through like this once we've
   // removed LayoutInline splitting.
   if (!container_builder_.BfcOffset()) {
     container_builder_.SetEndMarginStrut(ConstraintSpace().MarginStrut());
   }
 
   return container_builder_.ToBoxFragment();
 }
 
 }  // namespace blink