Inline algorithm should take into account the wrapper's clearance line.

third_party/WebKit/Source/core/layout/ng/ng_block_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/ng_block_layout_algorithm.h"
 
 #include "core/layout/ng/inline/ng_inline_node.h"
 #include "core/layout/ng/ng_absolute_utils.h"
 #include "core/layout/ng/ng_block_child_iterator.h"
 #include "core/layout/ng/ng_box_fragment.h"
 #include "core/layout/ng/ng_constraint_space.h"
 #include "core/layout/ng/ng_constraint_space_builder.h"
 #include "core/layout/ng/ng_floats_utils.h"
 #include "core/layout/ng/ng_fragment.h"
 #include "core/layout/ng/ng_fragment_builder.h"
 #include "core/layout/ng/ng_layout_opportunity_iterator.h"
 #include "core/layout/ng/ng_length_utils.h"
 #include "core/layout/ng/ng_out_of_flow_layout_part.h"
 #include "core/layout/ng/ng_space_utils.h"
 #include "core/style/ComputedStyle.h"
 #include "platform/LengthFunctions.h"
 #include "wtf/Optional.h"
 
 namespace blink {
 namespace {
 
+// Adjusts {@code offset} to the clearance line.
+void AdjustToClearance(const WTF::Optional<LayoutUnit>& clearance_offset,
+                       NGLogicalOffset* offset) {
+  DCHECK(offset);
+  if (clearance_offset) {
+    offset->block_offset =
+        std::max(clearance_offset.value(), offset->block_offset);
+  }
+}
+
 // Returns if a child may be affected by its clear property. I.e. it will
 // actually clear a float.
 bool ClearanceMayAffectLayout(
     const NGConstraintSpace& space,
     const Vector<RefPtr<NGFloatingObject>>& unpositioned_floats,
     const ComputedStyle& child_style) {
   const NGExclusions& exclusions = *space.Exclusions();
   EClear clear = child_style.Clear();
   bool should_clear_left = (clear == EClear::kBoth || clear == EClear::kLeft);
   bool should_clear_right = (clear == EClear::kBoth || clear == EClear::kRight);
@@ skipping 19 matching lines @@
 
 // Whether we've run out of space in this flow. If so, there will be no work
 // left to do for this block in this fragmentainer.
 bool IsOutOfSpace(const NGConstraintSpace& space, LayoutUnit content_size) {
   return space.HasBlockFragmentation() &&
          content_size >= space.FragmentainerSpaceAvailable();
 }
 
 }  // namespace
 
+void MaybeUpdateFragmentBfcOffset(const NGConstraintSpace& space,
+                                  const NGLogicalOffset& offset,
+                                  NGFragmentBuilder* builder) {
+  DCHECK(builder);
+  if (!builder->BfcOffset()) {
+    NGLogicalOffset mutable_offset(offset);
+    AdjustToClearance(space.ClearanceOffset(), &mutable_offset);
+    builder->SetBfcOffset(mutable_offset);
+  }
+}
+
 NGBlockLayoutAlgorithm::NGBlockLayoutAlgorithm(NGBlockNode* node,
                                                NGConstraintSpace* space,
                                                NGBlockBreakToken* break_token)
     : NGLayoutAlgorithm(node, space, break_token),
       builder_(NGPhysicalFragment::kFragmentBox, node),
       space_builder_(constraint_space_) {}
 
 Optional<MinMaxContentSize> NGBlockLayoutAlgorithm::ComputeMinMaxContentSize()
     const {
   MinMaxContentSize sizes;
@@ skipping 37 matching lines @@
   LayoutUnit inline_offset =
       border_and_padding_.inline_start + curr_child_margins_.inline_start;
   LayoutUnit block_offset = content_size_;
   if (known_fragment_offset) {
     block_offset = known_fragment_offset.value().block_offset -
                    builder_.BfcOffset().value().block_offset;
   }
   return {inline_offset, block_offset};
 }
 
-void NGBlockLayoutAlgorithm::UpdateFragmentBfcOffset(
-    const NGLogicalOffset& offset) {
-  if (!builder_.BfcOffset()) {
-    NGLogicalOffset bfc_offset = offset;
-    if (ConstraintSpace().ClearanceOffset()) {
-      bfc_offset.block_offset = std::max(
-          ConstraintSpace().ClearanceOffset().value(), offset.block_offset);
-    }
-    builder_.SetBfcOffset(bfc_offset);
-  }
-}
-
 RefPtr<NGLayoutResult> NGBlockLayoutAlgorithm::Layout() {
   WTF::Optional<MinMaxContentSize> min_max_size;
   if (NeedMinMaxContentSize(ConstraintSpace(), Style()))
     min_max_size = ComputeMinMaxContentSize();
 
   border_and_padding_ = ComputeBorders(ConstraintSpace(), Style()) +
                         ComputePadding(ConstraintSpace(), Style());
 
   // TODO(layout-ng): For quirks mode, should we pass blockSize instead of -1?
   NGLogicalSize size(
@@ skipping 27 matching lines @@
   content_size_ = BreakToken() ? LayoutUnit() : border_and_padding_.block_start;
 
   curr_margin_strut_ = ConstraintSpace().MarginStrut();
   curr_bfc_offset_ = ConstraintSpace().BfcOffset();
 
   // Margins collapsing:
   //   Do not collapse margins between parent and its child if there is
   //   border/padding between them.
   if (border_and_padding_.block_start) {
     curr_bfc_offset_.block_offset += curr_margin_strut_.Sum();
-    UpdateFragmentBfcOffset(curr_bfc_offset_);
+    MaybeUpdateFragmentBfcOffset(ConstraintSpace(), curr_bfc_offset_,
+                                 &builder_);
     curr_margin_strut_ = NGMarginStrut();
   }
 
   // If a new formatting context hits the if branch above then the BFC offset is
   // still {} as the margin strut from the constraint space must also be empty.
   if (ConstraintSpace().IsNewFormattingContext()) {
-    UpdateFragmentBfcOffset(curr_bfc_offset_);
+    MaybeUpdateFragmentBfcOffset(ConstraintSpace(), curr_bfc_offset_,
+                                 &builder_);
     DCHECK_EQ(curr_margin_strut_, NGMarginStrut());
     DCHECK_EQ(builder_.BfcOffset().value(), NGLogicalOffset());
     curr_bfc_offset_ = {};
   }
 
   curr_bfc_offset_.block_offset += content_size_;
 
   while (child) {
     if (child->IsBlock()) {
       EPosition position = child->Style().GetPosition();
@@ skipping 41 matching lines @@
   size.block_size =
       ComputeBlockSizeForFragment(ConstraintSpace(), Style(), content_size_);
   builder_.SetBlockSize(size.block_size);
 
   // Layout our absolute and fixed positioned children.
   NGOutOfFlowLayoutPart(ConstraintSpace(), Style(), &builder_).Run();
 
   // Non-empty blocks always know their position in space:
   if (size.block_size) {
     curr_bfc_offset_.block_offset += curr_margin_strut_.Sum();
-    UpdateFragmentBfcOffset(curr_bfc_offset_);
+    MaybeUpdateFragmentBfcOffset(ConstraintSpace(), curr_bfc_offset_,
+                                 &builder_);
     PositionPendingFloats(curr_bfc_offset_.block_offset,
                           MutableConstraintSpace(), &builder_);
   }
 
   // Margins collapsing:
   //   Do not collapse margins between the last in-flow child and bottom margin
   //   of its parent if the parent has height != auto()
   if (!Style().LogicalHeight().IsAuto()) {
     // TODO(glebl): handle minLogicalHeight, maxLogicalHeight.
     curr_margin_strut_ = NGMarginStrut();
@@ skipping 28 matching lines @@
       child->IsBlock() && !is_floating &&
       !IsNewFormattingContextForBlockLevelChild(Style(), *child) &&
       ClearanceMayAffectLayout(ConstraintSpace(), builder_.UnpositionedFloats(),
                                child->Style());
 
   // Children which may clear a float need to force all the pending floats to
   // be positioned before layout. This also resolves the fragment's bfc offset.
   if (should_position_pending_floats) {
     LayoutUnit origin_point_block_offset =
         curr_bfc_offset_.block_offset + curr_margin_strut_.Sum();
-    UpdateFragmentBfcOffset(
-        {curr_bfc_offset_.inline_offset, origin_point_block_offset});
+    MaybeUpdateFragmentBfcOffset(
+        ConstraintSpace(),
+        {curr_bfc_offset_.inline_offset, origin_point_block_offset}, &builder_);
     PositionPendingFloats(origin_point_block_offset, MutableConstraintSpace(),
                           &builder_);
   }
 
   bool is_inflow = child->IsInline() || !is_floating;
 
   // Only inflow children (e.g. not floats) are included in the child's margin
   // strut as they do not participate in margin collapsing.
   if (is_inflow) {
     curr_bfc_offset_.inline_offset += curr_child_margins_.inline_start;
@@ skipping 12 matching lines @@
   bool should_collapse_margins =
       child->IsInline() ||
       (!is_floating &&
        IsNewFormattingContextForBlockLevelChild(Style(), *child));
 
   // Inline children or children which establish a block formatting context
   // collapse margins and position themselves immediately as they need to know
   // their BFC offset for fragmentation purposes.
   if (should_collapse_margins) {
     curr_bfc_offset_.block_offset += curr_margin_strut_.Sum();
-    UpdateFragmentBfcOffset(curr_bfc_offset_);
+    MaybeUpdateFragmentBfcOffset(ConstraintSpace(), curr_bfc_offset_,
+                                 &builder_);
     PositionPendingFloats(curr_bfc_offset_.block_offset,
                           MutableConstraintSpace(), &builder_);
     curr_margin_strut_ = {};
   }
 }
 
 void NGBlockLayoutAlgorithm::FinishChildLayout(
     NGLayoutInputNode* child,
     NGConstraintSpace* child_space,
     RefPtr<NGLayoutResult> layout_result) {
@@ skipping 31 matching lines @@
 
   // Determine the fragment's position in the parent space either by using
   // content_size_ or known fragment's BFC offset.
   WTF::Optional<NGLogicalOffset> bfc_offset;
   if (child_space->IsNewFormattingContext()) {
     DCHECK(builder_.BfcOffset());
     bfc_offset = curr_bfc_offset_;
   } else if (fragment.BfcOffset()) {
     // Fragment that knows its offset can be used to set parent's BFC position.
     curr_bfc_offset_.block_offset = fragment.BfcOffset().value().block_offset;
-    UpdateFragmentBfcOffset(curr_bfc_offset_);
+    MaybeUpdateFragmentBfcOffset(ConstraintSpace(), curr_bfc_offset_,
+                                 &builder_);
     PositionPendingFloats(curr_bfc_offset_.block_offset,
                           MutableConstraintSpace(), &builder_);
     bfc_offset = curr_bfc_offset_;
   } else if (builder_.BfcOffset()) {
     // Fragment doesn't know its offset but we can still calculate its BFC
     // position because the parent fragment's BFC is known.
     // Example:
     // BFC Offset is known here because of the padding.
     // <div style="padding: 1px">
     //   <div id="empty-div" style="margins: 1px"></div>
@@ skipping 87 matching lines @@
     NGLayoutInputNode* child) {
   DCHECK(child);
 
   const ComputedStyle& child_style = child->Style();
   bool is_new_bfc = IsNewFormattingContextForBlockLevelChild(Style(), *child);
   space_builder_.SetIsNewFormattingContext(is_new_bfc)
       .SetBfcOffset(curr_bfc_offset_);
 
   if (child->IsInline()) {
     // TODO(kojii): Setup space_builder_ appropriately for inline child.
-    space_builder_.SetBfcOffset(curr_bfc_offset_);
+    space_builder_.SetBfcOffset(curr_bfc_offset_)
+        .SetClearanceOffset(ConstraintSpace().ClearanceOffset());
     return space_builder_.ToConstraintSpace(
         FromPlatformWritingMode(Style().GetWritingMode()));
   }
 
   space_builder_
       .SetClearanceOffset(
           GetClearanceOffset(constraint_space_->Exclusions(), child_style))
       .SetIsShrinkToFit(ShouldShrinkToFit(Style(), child_style))
       .SetTextDirection(child_style.Direction());
 
@@ skipping 13 matching lines @@
       DCHECK(builder_.BfcOffset());
       space_available -= curr_bfc_offset_.block_offset;
     }
   }
   space_builder_.SetFragmentainerSpaceAvailable(space_available);
 
   return space_builder_.ToConstraintSpace(
       FromPlatformWritingMode(child_style.GetWritingMode()));
 }
 }  // namespace blink