Add container_block_offset,top_offset to NGFloatingObject.

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_constraint_space.h"
@@ skipping 69 matching lines @@
                                   const NGLogicalOffset& offset,
                                   NGFragmentBuilder* builder) {
   DCHECK(builder);
   if (!builder->BfcOffset()) {
     NGLogicalOffset mutable_offset(offset);
     AdjustToClearance(space.ClearanceOffset(), &mutable_offset);
     builder->SetBfcOffset(mutable_offset);
   }
 }
 
+void PositionPendingFloatsFromOffset(LayoutUnit origin_block_offset,
+                                     LayoutUnit from_block_offset,
+                                     NGFragmentBuilder* container_builder,
+                                     NGConstraintSpace* space) {
+  DCHECK(container_builder->BfcOffset())
+      << "Parent BFC offset should be known here";
+  const auto& floating_objects = container_builder->UnpositionedFloats();
+  container_builder->MutablePositionedFloats().AppendVector(
+      PositionFloats(origin_block_offset, from_block_offset,
+                     container_builder->BfcOffset().value().block_offset,
+                     floating_objects, space));
+  container_builder->MutableUnpositionedFloats().clear();
+}
+
 void PositionPendingFloats(LayoutUnit origin_block_offset,
                            NGFragmentBuilder* container_builder,
                            NGConstraintSpace* space) {
   DCHECK(container_builder->BfcOffset())
       << "Parent BFC offset should be known here";
-  const auto& floating_objects = container_builder->UnpositionedFloats();
-  container_builder->MutablePositionedFloats().AppendVector(PositionFloats(
-      origin_block_offset, container_builder->BfcOffset().value().block_offset,
-      floating_objects, space));
-  container_builder->MutableUnpositionedFloats().clear();
+  LayoutUnit from_block_offset =
+      container_builder->BfcOffset().value().block_offset;
+  PositionPendingFloatsFromOffset(origin_block_offset, from_block_offset,
+                                  container_builder, space);
 }
 
 NGBlockLayoutAlgorithm::NGBlockLayoutAlgorithm(NGBlockNode* node,
                                                NGConstraintSpace* space,
                                                NGBlockBreakToken* break_token)
     : NGLayoutAlgorithm(node, space, break_token),
       space_builder_(constraint_space_) {}
 
 Optional<MinMaxContentSize> NGBlockLayoutAlgorithm::ComputeMinMaxContentSize()
     const {
@@ skipping 277 matching lines @@
 
   // Determine the fragment's position in the parent space.
   WTF::Optional<NGLogicalOffset> child_bfc_offset;
   if (child_space.IsNewFormattingContext())
     child_bfc_offset = PositionNewFc(fragment, child_space);
   else if (fragment.BfcOffset())
     child_bfc_offset = PositionWithBfcOffset(fragment);
   else if (IsLegacyBlock(*child))
     child_bfc_offset = PositionLegacy(child_space);
   else if (container_builder_.BfcOffset())
-    child_bfc_offset = PositionWithParentBfc(fragment);
+    child_bfc_offset = PositionWithParentBfc(child_space, fragment);
 
   NGLogicalOffset logical_offset = CalculateLogicalOffset(child_bfc_offset);
 
   // Update margin strut.
   curr_margin_strut_ = fragment.EndMarginStrut();
   curr_margin_strut_.Append(curr_child_margins_.block_end);
 
   // Only modify content_size if BlockSize is not empty. It's needed to prevent
   // the situation when logical_offset is included in content_size for empty
   // blocks. Example:
@@ skipping 13 matching lines @@
 
 NGLogicalOffset NGBlockLayoutAlgorithm::PositionNewFc(
     const NGBoxFragment& fragment,
     const NGConstraintSpace& child_space) {
   // 1. Position all pending floats to a temporary space.
   RefPtr<NGConstraintSpace> tmp_space =
       NGConstraintSpaceBuilder(&child_space)
           .SetIsNewFormattingContext(false)
           .ToConstraintSpace(child_space.WritingMode());
   PositionFloats(curr_bfc_offset_.block_offset, curr_bfc_offset_.block_offset,
+                 curr_bfc_offset_.block_offset,
                  container_builder_.UnpositionedFloats(), tmp_space.Get());
 
   NGLogicalOffset origin_offset = curr_bfc_offset_;
   origin_offset.inline_offset += border_and_padding_.inline_start;
 
   // 2. Find an estimated layout opportunity for our fragment.
   NGLayoutOpportunity opportunity = FindLayoutOpportunityForFragment(
       tmp_space->Exclusions().get(), child_space.AvailableSize(), origin_offset,
       curr_child_margins_, fragment);
 
@@ skipping 29 matching lines @@
   DCHECK(fragment.BfcOffset());
   curr_bfc_offset_.block_offset = fragment.BfcOffset().value().block_offset;
   MaybeUpdateFragmentBfcOffset(ConstraintSpace(), curr_bfc_offset_,
                                &container_builder_);
   PositionPendingFloats(curr_bfc_offset_.block_offset, &container_builder_,
                         MutableConstraintSpace());
   return fragment.BfcOffset().value();
 }
 
 NGLogicalOffset NGBlockLayoutAlgorithm::PositionWithParentBfc(
+    const NGConstraintSpace& space,
     const NGBoxFragment& fragment) {
   // The child must be an in-flow zero-block-size fragment, use its end margin
   // strut for positioning.
   DCHECK(!fragment.BfcOffset());
   DCHECK_EQ(fragment.BlockSize(), LayoutUnit());
 
   NGMarginStrut margin_strut = fragment.EndMarginStrut();
   margin_strut.Append(curr_child_margins_.block_end);
 
   curr_bfc_offset_ +=
       {border_and_padding_.inline_start + curr_child_margins_.inline_start,
        margin_strut.Sum()};
+  AdjustToClearance(space.ClearanceOffset(), &curr_bfc_offset_);
+  PositionPendingFloatsFromOffset(
+      curr_bfc_offset_.block_offset, curr_bfc_offset_.block_offset,
+      &container_builder_, MutableConstraintSpace());
   return curr_bfc_offset_;
 }
 
 NGLogicalOffset NGBlockLayoutAlgorithm::PositionLegacy(
     const NGConstraintSpace& child_space) {
   AdjustToClearance(child_space.ClearanceOffset(), &curr_bfc_offset_);
   return curr_bfc_offset_;
 }
 
 void NGBlockLayoutAlgorithm::FinishFloatChildLayout(
@@ skipping 123 matching lines @@
     if (is_new_bfc) {
       space_available -= child_bfc_offset.block_offset;
     }
   }
   space_builder_.SetFragmentainerSpaceAvailable(space_available);
 
   return space_builder_.ToConstraintSpace(
       FromPlatformWritingMode(child_style.GetWritingMode()));
 }
 }  // namespace blink