Add ClearanceOffset to LayoutNG Constraint space.

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/ng_absolute_utils.h"
 #include "core/layout/ng/ng_block_break_token.h"
 #include "core/layout/ng/ng_box_fragment.h"
 #include "core/layout/ng/ng_column_mapper.h"
@@ skipping 23 matching lines @@
       FromPlatformWritingMode(child_style.getWritingMode());
   // Whether the child and the containing block are parallel to each other.
   // Example: vertical-rl and vertical-lr
   bool is_in_parallel_flow =
       IsParallelWritingMode(parent_space.WritingMode(), child_writing_mode);
 
   return child_style.display() == EDisplay::InlineBlock ||
          child_style.isFloating() || !is_in_parallel_flow;
 }
 
-// Updates the fragment's BFC offset if it's not already set.
-void UpdateFragmentBfcOffset(const NGLogicalOffset& offset,
-                             NGFragmentBuilder* builder) {
-  if (!builder->BfcOffset())
-    builder->SetBfcOffset(offset);
+// Returns max of 2 {@code WTF::Optional} values.
+template <typename T>
+WTF::Optional<T> OptionalMax(const WTF::Optional<T>& value1,
+                             const WTF::Optional<T>& value2) {
+  if (value1 && value2) {
+    return std::max(value1.value(), value2.value());
+  } else if (value1) {
+    return value1;
+  }
+  return value2;
 }
 
-// Adjusts content_size to respect the CSS "clear" property.
-// Picks up the maximum between left/right exclusions and content_size depending
-// on the value of style.clear() property.
-void AdjustToClearance(const std::shared_ptr<NGExclusions>& exclusions,
-                       const ComputedStyle& style,
-                       const NGLogicalOffset& from_offset,
-                       LayoutUnit* content_size) {
-  DCHECK(content_size) << "content_size cannot be null here";
+WTF::Optional<LayoutUnit> GetClearanceOffset(
+    const std::shared_ptr<NGExclusions>& exclusions,
+    const ComputedStyle& style) {
   const NGExclusion* right_exclusion = exclusions->last_right_float;
   const NGExclusion* left_exclusion = exclusions->last_left_float;
 
-  LayoutUnit left_block_end_offset = *content_size;
+  WTF::Optional<LayoutUnit> left_offset;
   if (left_exclusion) {
-    left_block_end_offset = std::max(
-        left_exclusion->rect.BlockEndOffset() - from_offset.block_offset,
-        *content_size);
+    left_offset = left_exclusion->rect.BlockEndOffset();
   }
-  LayoutUnit right_block_end_offset = *content_size;
+  WTF::Optional<LayoutUnit> right_offset;
   if (right_exclusion) {
-    right_block_end_offset = std::max(
-        right_exclusion->rect.BlockEndOffset() - from_offset.block_offset,
-        *content_size);
+    right_offset = right_exclusion->rect.BlockEndOffset();
   }
 
   switch (style.clear()) {
     case EClear::kNone:
-      return;  // nothing to do here.
+      return WTF::nullopt;  // nothing to do here.
     case EClear::kLeft:
-      *content_size = left_block_end_offset;
-      break;
+      return left_offset;
     case EClear::kRight:
-      *content_size = right_block_end_offset;
-      break;
+      return right_offset;
     case EClear::kBoth:
-      *content_size = std::max(left_block_end_offset, right_block_end_offset);
-      break;
+      return OptionalMax<LayoutUnit>(left_offset, right_offset);
     default:
       ASSERT_NOT_REACHED();
   }
+  return WTF::nullopt;
 }
 
 // Creates an exclusion from the fragment that will be placed in the provided
 // layout opportunity.
 NGExclusion CreateExclusion(const NGFragment& fragment,
                             const NGLayoutOpportunity& opportunity,
                             const LayoutUnit float_offset,
                             const NGBoxStrut& margins,
                             NGExclusion::Type exclusion_type) {
   NGExclusion exclusion;
@@ skipping 249 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<MinAndMaxContentSizes> sizes;
   if (NeedMinAndMaxContentSizes(ConstraintSpace(), Style()))
     sizes = ComputeMinAndMaxContentSizes();
 
   border_and_padding_ =
       ComputeBorders(Style()) + ComputePadding(ConstraintSpace(), Style());
 
   LayoutUnit inline_size =
       ComputeInlineSizeForFragment(ConstraintSpace(), Style(), sizes);
@@ skipping 41 matching lines @@
   }
 
   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_, builder_.get());
+    UpdateFragmentBfcOffset(curr_bfc_offset_);
     curr_margin_strut_ = NGMarginStrut();
   }
 
   // Block that establishes a new BFC knows its BFC offset == {}
   // 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_, builder_.get());
+    UpdateFragmentBfcOffset(curr_bfc_offset_);
     DCHECK_EQ(builder_->BfcOffset().value(), NGLogicalOffset());
     DCHECK_EQ(curr_margin_strut_, NGMarginStrut());
   }
 
   curr_bfc_offset_.block_offset += content_size_;
 
   while (current_child_) {
     if (current_child_->Type() == NGLayoutInputNode::kLegacyBlock) {
       NGBlockNode* current_block_child = toNGBlockNode(current_child_);
       EPosition position = current_block_child->Style().position();
@@ skipping 39 matching lines @@
   block_size =
       ComputeBlockSizeForFragment(ConstraintSpace(), Style(), content_size_);
   builder_->SetBlockSize(block_size);
 
   // Layout our absolute and fixed positioned children.
   NGOutOfFlowLayoutPart(Style(), builder_.get()).Run();
 
   // Non-empty blocks always know their position in space:
   if (block_size) {
     curr_bfc_offset_.block_offset += curr_margin_strut_.Sum();
-    UpdateFragmentBfcOffset(curr_bfc_offset_, builder_.get());
+    UpdateFragmentBfcOffset(curr_bfc_offset_);
     PositionPendingFloats(curr_bfc_offset_.block_offset, ConstraintSpace(),
                           builder_.get());
   }
 
   // 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 71 matching lines @@
     // 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>
     bfc_offset = curr_bfc_offset_;
     bfc_offset.value().block_offset += curr_margin_strut_.Sum();
   }
   if (bfc_offset) {
-    UpdateFragmentBfcOffset(curr_bfc_offset_, builder_.get());
+    UpdateFragmentBfcOffset(curr_bfc_offset_);
     PositionPendingFloats(curr_bfc_offset_.block_offset, ConstraintSpace(),
                           builder_.get());
   }
   NGLogicalOffset logical_offset = CalculateLogicalOffset(bfc_offset);
 
   if (fragmentainer_mapper_)
     fragmentainer_mapper_->ToVisualOffset(logical_offset);
   else
     logical_offset.block_offset -= PreviousBreakOffset();
 
@@ skipping 201 matching lines @@
   bool is_new_bfc = IsNewFormattingContextForInFlowBlockLevelChild(
       ConstraintSpace(), current_child_style);
   space_builder_->SetIsNewFormattingContext(is_new_bfc)
       .SetIsShrinkToFit(
           ShouldShrinkToFit(ConstraintSpace(), CurrentChildStyle()))
       .SetTextDirection(current_child_style.direction());
   LayoutUnit space_available = SpaceAvailableForCurrentChild();
   space_builder_->SetFragmentainerSpaceAvailable(space_available);
 
   // Clearance :
-  // - Collapse margins
-  // - Update curr_bfc_offset and parent BFC offset if needed.
-  // - Position all pending floats as position is known now.
-  // TODO(glebl): Fix the use case with clear: left and an intruding right.
-  // https://software.hixie.ch/utilities/js/live-dom-viewer/saved/4847
+  // - *Always* collapse margins and update *container*'s BFC offset.
+  // - Position all pending floats since the fragment's BFC offset is known.
+  // - Set the clearance offset on the constraint space's builder.
   if (current_child_style.clear() != EClear::kNone) {
     curr_bfc_offset_.block_offset += curr_margin_strut_.Sum();
-    UpdateFragmentBfcOffset(curr_bfc_offset_, builder_.get());
+    UpdateFragmentBfcOffset(curr_bfc_offset_);
     // Only collapse margins if it's an adjoining block with clearance.
     if (!content_size_) {
       curr_margin_strut_ = NGMarginStrut();
       curr_child_margins_.block_start = LayoutUnit();
     }
     PositionPendingFloats(curr_bfc_offset_.block_offset, ConstraintSpace(),
                           builder_.get());
-    AdjustToClearance(constraint_space_->Exclusions(), current_child_style,
-                      builder_->BfcOffset().value(), &content_size_);
+    WTF::Optional<LayoutUnit> clearance_offset = GetClearanceOffset(
+        constraint_space_->Exclusions(), current_child_style);
+    space_builder_->SetClearanceOffset(clearance_offset);
   }
 
   // Set estimated BFC offset to the next child's constraint space.
   curr_bfc_offset_ = builder_->BfcOffset() ? builder_->BfcOffset().value()
                                            : ConstraintSpace().BfcOffset();
   curr_bfc_offset_.block_offset += content_size_;
   curr_bfc_offset_.inline_offset += border_and_padding_.inline_start;
 
   // Floats margins are not included in child's CS because
   // 1) Floats do not participate in margins collapsing
   // 2) Floats margins are used separately to calculate floating exclusions.
   if (!CurrentChildStyle().isFloating()) {
     curr_bfc_offset_.inline_offset += curr_child_margins_.inline_start;
     // Append the current margin strut with child's block start margin.
     // Non empty border/padding use cases are handled inside of the child's
     // layout.
     curr_margin_strut_.Append(curr_child_margins_.block_start);
     space_builder_->SetMarginStrut(curr_margin_strut_);
   }
 
   space_builder_->SetBfcOffset(curr_bfc_offset_);
 
   return space_builder_->ToConstraintSpace(
       FromPlatformWritingMode(current_child_style.getWritingMode()));
 }
-
 }  // namespace blink