[LayoutNG] Simplify ng_absolute_utils.cc

ComputeAbsoluteHorizontal & ComputeAbsoluteVertical were almost
identical. This added with the many writing mode switches generated
a lot of code.

This collapses most of the functions within the utils file to work in
the logical writing-mode of the candidate.

Change-Id: Ic678d5b46858fea402eda9839d1eb580dc30f7d6
Reviewed-on: https://chromium-review.googlesource.com/c/chromium/src/+/1681180
Commit-Queue: Ian Kilpatrick <ikilpatrick@chromium.org>
Reviewed-by: David Grogan <dgrogan@chromium.org>
Reviewed-by: Aleks Totic <atotic@chromium.org>
Cr-Commit-Position: refs/heads/master@{#678511}

third_party/blink/renderer/core/layout/BUILD.gn

@@ -318,7 +318,6 @@ blink_core_sources("layout") {
     "ng/geometry/ng_fragment_geometry.h",
     "ng/geometry/ng_margin_strut.cc",
     "ng/geometry/ng_margin_strut.h",
-    "ng/geometry/ng_static_position.cc",
     "ng/geometry/ng_static_position.h",
     "ng/inline/empty_offset_mapping_builder.h",
     "ng/inline/layout_ng_text.h",

third_party/blink/renderer/core/layout/ng/geometry/ng_static_position.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 "third_party/blink/renderer/core/layout/ng/geometry/ng_static_position.h"
-
-namespace blink {
-
-LayoutUnit NGPhysicalStaticPosition::LeftInset(LayoutUnit container_size,
-                                               LayoutUnit width,
-                                               LayoutUnit margin_left,
-                                               LayoutUnit margin_right) const {
-  if (HasLeft())
-    return offset.left;
-  else
-    return offset.left - width - margin_left - margin_right;
-}
-
-LayoutUnit NGPhysicalStaticPosition::RightInset(LayoutUnit container_size,
-                                                LayoutUnit width,
-                                                LayoutUnit margin_left,
-                                                LayoutUnit margin_right) const {
-  if (HasLeft())
-    return container_size - offset.left - width - margin_left - margin_right;
-  else
-    return container_size - offset.left;
-}
-
-LayoutUnit NGPhysicalStaticPosition::TopInset(LayoutUnit container_size,
-                                              LayoutUnit height,
-                                              LayoutUnit margin_top,
-                                              LayoutUnit margin_bottom) const {
-  if (HasTop())
-    return offset.top;
-  else
-    return offset.top - height - margin_bottom - margin_top;
-}
-
-LayoutUnit NGPhysicalStaticPosition::BottomInset(
-    LayoutUnit container_size,
-    LayoutUnit height,
-    LayoutUnit margin_top,
-    LayoutUnit margin_bottom) const {
-  if (HasTop())
-    return container_size - offset.top - height - margin_top - margin_bottom;
-  else
-    return container_size - offset.top;
-}
-
-}  // namespace blink

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

@@ -42,50 +42,6 @@ struct CORE_EXPORT NGPhysicalStaticPosition {
   HorizontalEdge horizontal_edge;
   VerticalEdge vertical_edge;
 
-  // Left/Right/TopPosition functions map static position to inset of
-  // left/right/top edge wrt container space.
-  // The function arguments are required to solve the equation:
-  // contaner_size = left + margin_left + width + margin_right + right
-  LayoutUnit LeftInset(LayoutUnit container_size,
-                       LayoutUnit width,
-                       LayoutUnit margin_left,
-                       LayoutUnit margin_right) const;
-  LayoutUnit RightInset(LayoutUnit container_size,
-                        LayoutUnit width,
-                        LayoutUnit margin_left,
-                        LayoutUnit margin_right) const;
-  LayoutUnit TopInset(LayoutUnit container_size,
-                      LayoutUnit height,
-                      LayoutUnit margin_top,
-                      LayoutUnit margin_bottom) const;
-  LayoutUnit BottomInset(LayoutUnit container_size,
-                         LayoutUnit height,
-                         LayoutUnit margin_top,
-                         LayoutUnit margin_bottom) const;
-
-  LayoutUnit Left() const {
-    DCHECK(HasLeft());
-    return offset.left;
-  }
-
-  LayoutUnit Right() const {
-    DCHECK(!HasLeft());
-    return offset.left;
-  }
-
-  LayoutUnit Top() const {
-    DCHECK(HasTop());
-    return offset.top;
-  }
-
-  LayoutUnit Bottom() const {
-    DCHECK(!HasTop());
-    return offset.top;
-  }
-
-  bool HasLeft() const { return horizontal_edge == kLeft; }
-  bool HasTop() const { return vertical_edge == kTop; }
-
   NGLogicalStaticPosition ConvertToLogical(WritingMode writing_mode,
                                            TextDirection direction,
                                            const PhysicalSize& size) const {

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

@@ -17,69 +17,71 @@ namespace blink {
 class ComputedStyle;
 class LayoutObject;
 class NGConstraintSpace;
-struct NGPhysicalStaticPosition;
+struct NGLogicalStaticPosition;
 
-struct CORE_EXPORT NGAbsolutePhysicalPosition {
-  NGPhysicalBoxStrut inset;
-  PhysicalSize size;
-  NGPhysicalBoxStrut margins;
-  String ToString() const;
+struct CORE_EXPORT NGLogicalOutOfFlowPosition {
+  NGBoxStrut inset;
+  LogicalSize size;
+  NGBoxStrut margins;
 };
 
-// Implements <dialog> special case abspos static positining.
-// Returns new dialog top position if layout_dialog requires
-// <dialog> abspos centering.
+// Implements <dialog> static positioning.
+//
+// Returns new dialog top position if layout_dialog requires <dialog>
+// OOF-positioned centering.
 CORE_EXPORT base::Optional<LayoutUnit> ComputeAbsoluteDialogYPosition(
     const LayoutObject& layout_dialog,
     LayoutUnit height);
 
-// The following routines implement absolute size resolution algorithm.
+// The following routines implement the absolute size resolution algorithm.
 // https://www.w3.org/TR/css-position-3/#abs-non-replaced-width
 //
-// The size is computed as NGAbsolutePhysicalPosition.
+// The size is computed as |NGLogicalOutOfFlowPosition|.
 // It needs to be computed in 4 stages:
-// 1. If AbsoluteNeedsChildInlineSize compute estimated inline_size using
-//    MinMaxSize.ShrinkToFit.
-// 2. Compute part of PhysicalPosition that depends upon child inline size
-//    with ComputePartialAbsoluteWithChildInlineSize.
-// 3. If AbsoluteNeedsChildBlockSize compute estimated block_size by
+// 1. If |AbsoluteNeedsChildInlineSize| is true, compute estimated inline_size
+//    using |NGBlockNode::MinMaxSize|.
+// 2. Compute part of the |NGLogicalOutOfFlowPosition| which depends on the
+//    child inline-size with |ComputePartialAbsoluteWithChildInlineSize|.
+// 3. If |AbsoluteNeedsChildBlockSize| is true, compute estimated block_size by
 //    performing layout with the inline_size calculated from (2).
-// 4. Compute full PhysicalPosition by filling it in with parts that depend
-//    upon child's block_size.
+// 4. Compute the full |NGLogicalOutOfFlowPosition| with
+//    |ComputeFullAbsoluteWithChildBlockSize|.
 
-// True if ComputePartialAbsoluteWithChildInlineSize will need
-// estimated inline size.
+// Returns true if |ComputePartialAbsoluteWithChildInlineSize| will need an
+// estimated inline-size.
 CORE_EXPORT bool AbsoluteNeedsChildInlineSize(const ComputedStyle&);
 
-// True if ComputeFullAbsoluteWithChildBlockSize will need
-// estimated block size.
+// Returns true if |ComputeFullAbsoluteWithChildBlockSize| will need an
+// estimated block-size.
 CORE_EXPORT bool AbsoluteNeedsChildBlockSize(const ComputedStyle&);
 
-// Compute part of position that depends on child's inline_size.
-// replaced_size should be set if and only if element is replaced element.
-// Returns partially filled position.
-CORE_EXPORT NGAbsolutePhysicalPosition
+// Computes part of the absolute position which depends on the child's
+// inline-size.
+// |replaced_size| should be set if and only if element is replaced element.
+// Returns the partially filled position.
+CORE_EXPORT NGLogicalOutOfFlowPosition
 ComputePartialAbsoluteWithChildInlineSize(
     const NGConstraintSpace&,
     const ComputedStyle&,
     const NGBoxStrut& border_padding,
-    const NGPhysicalStaticPosition&,
+    const NGLogicalStaticPosition&,
     const base::Optional<MinMaxSize>& child_minmax,
     const base::Optional<LogicalSize>& replaced_size,
     const WritingMode container_writing_mode,
     const TextDirection container_direction);
 
-// Compute rest of PhysicalRect that depends on child's block_size.
+// Computes the rest of the absolute position which depends on child's
+// block-size.
 CORE_EXPORT void ComputeFullAbsoluteWithChildBlockSize(
     const NGConstraintSpace&,
     const ComputedStyle&,
     const NGBoxStrut& border_padding,
-    const NGPhysicalStaticPosition&,
+    const NGLogicalStaticPosition&,
     const base::Optional<LayoutUnit>& child_block_size,
     const base::Optional<LogicalSize>& replaced_size,
     const WritingMode container_writing_mode,
     const TextDirection container_direction,
-    NGAbsolutePhysicalPosition* position);
+    NGLogicalOutOfFlowPosition* position);
 
 }  // namespace blink
 

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

@@ -445,6 +445,7 @@ scoped_refptr<const NGLayoutResult> NGOutOfFlowLayoutPart::LayoutCandidate(
   const TextDirection default_direction = default_containing_block_.direction;
   const ComputedStyle& candidate_style = node.Style();
   const WritingMode candidate_writing_mode = candidate_style.GetWritingMode();
+  const TextDirection candidate_direction = candidate_style.Direction();
 
   LogicalSize container_content_size =
       container_info.ContentSize(candidate_style.GetPosition());
@@ -473,15 +474,18 @@ scoped_refptr<const NGLayoutResult> NGOutOfFlowLayoutPart::LayoutCandidate(
   NGLogicalStaticPosition static_position = candidate.static_position;
   static_position.offset -= container_info.container_offset;
 
-  NGPhysicalStaticPosition physical_static_position =
-      static_position.ConvertToPhysical(writing_mode_, default_direction,
-                                        container_physical_content_size);
+  NGLogicalStaticPosition candidate_static_position =
+      static_position
+          .ConvertToPhysical(writing_mode_, default_direction,
+                             container_physical_content_size)
+          .ConvertToLogical(candidate_writing_mode, candidate_direction,
+                            container_physical_content_size);
 
   // Need a constraint space to resolve offsets.
   NGConstraintSpace candidate_constraint_space =
       NGConstraintSpaceBuilder(writing_mode_, candidate_writing_mode,
                                /* is_new_fc */ true)
-          .SetTextDirection(candidate_style.Direction())
+          .SetTextDirection(candidate_direction)
           .SetAvailableSize(container_content_size)
           .SetPercentageResolutionSize(container_content_size)
           .ToConstraintSpace();
@@ -490,7 +494,7 @@ scoped_refptr<const NGLayoutResult> NGOutOfFlowLayoutPart::LayoutCandidate(
       freeze_scrollbars;
   do {
     scoped_refptr<const NGLayoutResult> layout_result =
-        Layout(node, candidate_constraint_space, physical_static_position,
+        Layout(node, candidate_constraint_space, candidate_static_position,
                container_content_size, container_info, only_layout);
 
     if (!freeze_scrollbars.has_value()) {
@@ -518,13 +522,14 @@ scoped_refptr<const NGLayoutResult> NGOutOfFlowLayoutPart::LayoutCandidate(
 scoped_refptr<const NGLayoutResult> NGOutOfFlowLayoutPart::Layout(
     NGBlockNode node,
     const NGConstraintSpace& candidate_constraint_space,
-    const NGPhysicalStaticPosition& physical_static_position,
+    const NGLogicalStaticPosition& candidate_static_position,
     LogicalSize container_content_size,
     const ContainingBlockInfo& container_info,
     const LayoutBox* only_layout) {
   const TextDirection default_direction = default_containing_block_.direction;
   const ComputedStyle& candidate_style = node.Style();
   const WritingMode candidate_writing_mode = candidate_style.GetWritingMode();
+  const TextDirection candidate_direction = candidate_style.Direction();
   const TextDirection container_direction = container_info.direction;
 
   PhysicalSize container_physical_content_size =
@@ -570,10 +575,10 @@ scoped_refptr<const NGLayoutResult> NGOutOfFlowLayoutPart::Layout(
                         candidate_constraint_space.AvailableSize().inline_size),
                     kIndefiniteSize};
   }
-  NGAbsolutePhysicalPosition node_position =
+  NGLogicalOutOfFlowPosition node_position =
       ComputePartialAbsoluteWithChildInlineSize(
           candidate_constraint_space, candidate_style, border_padding,
-          physical_static_position, min_max_size, replaced_size, writing_mode_,
+          candidate_static_position, min_max_size, replaced_size, writing_mode_,
           container_direction);
 
   // |should_be_considered_as_replaced| sets the inline-size.
@@ -596,11 +601,13 @@ scoped_refptr<const NGLayoutResult> NGOutOfFlowLayoutPart::Layout(
 
   ComputeFullAbsoluteWithChildBlockSize(
       candidate_constraint_space, candidate_style, border_padding,
-      physical_static_position, block_estimate, replaced_size, writing_mode_,
+      candidate_static_position, block_estimate, replaced_size, writing_mode_,
       container_direction, &node_position);
 
   NGBoxStrut inset =
-      node_position.inset.ConvertToLogical(writing_mode_, default_direction);
+      node_position.inset
+          .ConvertToPhysical(candidate_writing_mode, candidate_direction)
+          .ConvertToLogical(writing_mode_, default_direction);
 
   // |inset| is relative to the container's padding-box. Convert this to being
   // relative to the default container's border-box.
@@ -665,8 +672,7 @@ scoped_refptr<const NGLayoutResult> NGOutOfFlowLayoutPart::Layout(
 
   // Skip this step if we produced a fragment when estimating the block-size.
   if (!layout_result) {
-    block_estimate =
-        node_position.size.ConvertToLogical(candidate_writing_mode).block_size;
+    block_estimate = node_position.size.block_size;
     layout_result =
         GenerateFragment(node, container_content_size_in_candidate_writing_mode,
                          block_estimate, node_position);
@@ -682,8 +688,10 @@ scoped_refptr<const NGLayoutResult> NGOutOfFlowLayoutPart::Layout(
   // break if we set them here.
   if (!container_builder_->GetLayoutObject()
            ->Style()
-           ->IsDisplayFlexibleOrGridBox())
-    node.GetLayoutBox()->SetMargin(node_position.margins);
+           ->IsDisplayFlexibleOrGridBox()) {
+    node.GetLayoutBox()->SetMargin(node_position.margins.ConvertToPhysical(
+        candidate_writing_mode, candidate_direction));
+  }
 
   // Adjusting the offset for a dialog after layout is fine, since we cannot
   // have dialogs needing alignment inside block fragmentation.
@@ -729,13 +737,12 @@ scoped_refptr<const NGLayoutResult> NGOutOfFlowLayoutPart::GenerateFragment(
     NGBlockNode node,
     const LogicalSize& container_content_size_in_candidate_writing_mode,
     const base::Optional<LayoutUnit>& block_estimate,
-    const NGAbsolutePhysicalPosition& node_position) {
+    const NGLogicalOutOfFlowPosition& node_position) {
   // As the |block_estimate| is always in the node's writing mode, we
   // build the constraint space in the node's writing mode.
   WritingMode writing_mode = node.Style().GetWritingMode();
 
-  LayoutUnit inline_size =
-      node_position.size.ConvertToLogical(writing_mode).inline_size;
+  LayoutUnit inline_size = node_position.size.inline_size;
   LayoutUnit block_size =
       block_estimate
           ? *block_estimate

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

@@ -111,7 +111,7 @@ class CORE_EXPORT NGOutOfFlowLayoutPart {
 
   scoped_refptr<const NGLayoutResult> Layout(NGBlockNode,
                                              const NGConstraintSpace&,
-                                             const NGPhysicalStaticPosition&,
+                                             const NGLogicalStaticPosition&,
                                              LogicalSize container_content_size,
                                              const ContainingBlockInfo&,
                                              const LayoutBox* only_layout);
@@ -122,7 +122,7 @@ class CORE_EXPORT NGOutOfFlowLayoutPart {
       NGBlockNode node,
       const LogicalSize& container_content_size_in_child_writing_mode,
       const base::Optional<LayoutUnit>& block_estimate,
-      const NGAbsolutePhysicalPosition& node_position);
+      const NGLogicalOutOfFlowPosition& node_position);
 
   const NGConstraintSpace& container_space_;
   NGBoxFragmentBuilder* container_builder_;

third_party/blink/renderer/core/style/computed_style.h

@@ -1945,6 +1945,12 @@ class ComputedStyle : public ComputedStyleBase,
 
   // Offset utility functions.
   // Accessors for positioned object edges that take into account writing mode.
+  const Length& LogicalInlineStart() const {
+    return PhysicalBoundsToLogical().InlineStart();
+  }
+  const Length& LogicalInlineEnd() const {
+    return PhysicalBoundsToLogical().InlineEnd();
+  }
   const Length& LogicalLeft() const {
     return PhysicalBoundsToLogical().LineLeft();
   }