Fragment that establishes new BFC knows it's BFC offset in parent 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 26 matching lines @@
   bool is_in_parallel_flow =
       (parent_space.WritingMode() == kHorizontalTopBottom) ==
       (child_writing_mode == kHorizontalTopBottom);
 
   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,
-                             const NGConstraintSpace& space,
                              NGFragmentBuilder* builder) {
-  NGLogicalOffset fragment_offset =
-      space.IsNewFormattingContext() ? space.BfcOffset() : offset;
   if (!builder->BfcOffset())
-    builder->SetBfcOffset(fragment_offset);
+    builder->SetBfcOffset(offset);
 }
 
 // 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";
@@ skipping 255 matching lines @@
         ComputeMinAndMaxContentContribution(block_child->Style(), child_minmax);
 
     sizes.min_content = std::max(sizes.min_content, child_sizes.min_content);
     sizes.max_content = std::max(sizes.max_content, child_sizes.max_content);
   }
 
   sizes.max_content = std::max(sizes.min_content, sizes.max_content);
   return sizes;
 }
 
-NGLogicalOffset NGBlockLayoutAlgorithm::CalculateRelativeOffset(
-    const NGBoxFragment& fragment) {
+NGLogicalOffset NGBlockLayoutAlgorithm::CalculateLogicalOffset(
+    const WTF::Optional<NGLogicalOffset>& known_fragment_offset) {
   LayoutUnit inline_offset =
       border_and_padding_.inline_start + curr_child_margins_.inline_start;
   LayoutUnit block_offset = content_size_;
-  if (fragment.BfcOffset()) {
-    block_offset = fragment.BfcOffset().value().block_offset -
+  if (known_fragment_offset) {
+    block_offset = known_fragment_offset.value().block_offset -
                    builder_->BfcOffset().value().block_offset;
   }
   return {inline_offset, block_offset};
 }
 
 RefPtr<NGPhysicalFragment> NGBlockLayoutAlgorithm::Layout() {
   WTF::Optional<MinAndMaxContentSizes> sizes;
   if (NeedMinAndMaxContentSizes(ConstraintSpace(), Style()))
     sizes = ComputeMinAndMaxContentSizes();
 
@@ skipping 104 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_, ConstraintSpace(),
-                            builder_.get());
+    UpdateFragmentBfcOffset(curr_bfc_offset_, builder_.get());
     PositionPendingFloats(curr_bfc_offset_, 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 49 matching lines @@
       NGLogicalOffset origin_point = curr_bfc_offset_;
       // Adjust origin point to the margins of the last child.
       // Example: <div style="margin-bottom: 20px"><float></div>
       //          <div style="margin-bottom: 30px"></div>
       origin_point.block_offset += curr_margin_strut_.Sum();
       PositionPendingFloats(origin_point, builder_.get());
     }
     return;
   }
 
-  // Fragment that knows its offset can be used to set parent's BFC position.
-  if (fragment.BfcOffset()) {
+  // 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 (CurrentChildConstraintSpace().IsNewFormattingContext()) {
+    curr_bfc_offset_.block_offset += curr_margin_strut_.Sum();
+    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_, ConstraintSpace(),
-                            builder_.get());
+    bfc_offset = curr_bfc_offset_;
+  }
+  if (bfc_offset) {
+    UpdateFragmentBfcOffset(curr_bfc_offset_, builder_.get());
     PositionPendingFloats(curr_bfc_offset_, builder_.get());
   }
-  NGLogicalOffset fragment_offset = CalculateRelativeOffset(fragment);
+  NGLogicalOffset logical_offset = CalculateLogicalOffset(bfc_offset);
 
   if (fragmentainer_mapper_)
-    fragmentainer_mapper_->ToVisualOffset(fragment_offset);
+    fragmentainer_mapper_->ToVisualOffset(logical_offset);
   else
-    fragment_offset.block_offset -= PreviousBreakOffset();
+    logical_offset.block_offset -= PreviousBreakOffset();
 
   // Update margin strut.
   curr_margin_strut_ = fragment.EndMarginStrut();
   curr_margin_strut_.Append(curr_child_margins_.block_end);
 
-  content_size_ = fragment.BlockSize() + fragment_offset.block_offset;
+  content_size_ = fragment.BlockSize() + logical_offset.block_offset;
   max_inline_size_ =
       std::max(max_inline_size_, fragment.InlineSize() +
                                      curr_child_margins_.InlineSum() +
                                      border_and_padding_.InlineSum());
 
-  builder_->AddChild(std::move(physical_fragment), fragment_offset);
+  builder_->AddChild(std::move(physical_fragment), logical_offset);
 }
 
 bool NGBlockLayoutAlgorithm::ProceedToNextUnfinishedSibling(
     NGPhysicalFragment* child_fragment) {
   DCHECK(current_child_);
   NGBlockNode* finished_child = toNGBlockNode(current_child_);
   current_child_ = current_child_->NextSibling();
   if (!ConstraintSpace().HasBlockFragmentation() && !fragmentainer_mapper_)
     return true;
   // If we're resuming layout after a fragmentainer break, we need to skip
@@ skipping 177 matching lines @@
   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
   if (current_child_style.clear() != EClear::kNone) {
     curr_bfc_offset_.block_offset += curr_margin_strut_.Sum();
-    UpdateFragmentBfcOffset(curr_bfc_offset_, ConstraintSpace(),
-                            builder_.get());
+    UpdateFragmentBfcOffset(curr_bfc_offset_, builder_.get());
     // 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_, builder_.get());
     AdjustToClearance(constraint_space_->Exclusions(), current_child_style,
                       builder_->BfcOffset().value(), &content_size_);
   }
 
@@ skipping 10 matching lines @@
   curr_bfc_offset_.inline_offset += border_and_padding_.inline_start;
   if (ConstraintSpace().IsNewFormattingContext()) {
     curr_bfc_offset_.inline_offset += curr_child_margins_.inline_start;
   }
   space_builder_->SetBfcOffset(curr_bfc_offset_);
 
   return space_builder_->ToConstraintSpace();
 }
 
 }  // namespace blink