Reset constraint space's BFC offset if block creates a new FC

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_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_inline_node.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 {
 
-// Positions pending floats stored on the fragment builder starting from
-// {@code origin_point_block_offset}.
-void PositionPendingFloats(const LayoutUnit origin_point_block_offset,
-                           NGConstraintSpace* new_parent_space,
-                           NGFragmentBuilder* builder) {
-  DCHECK(builder->BfcOffset()) << "Parent BFC offset should be known here";
-  LayoutUnit bfc_block_offset = builder->BfcOffset().value().block_offset;
-
-  for (auto& floating_object : builder->UnpositionedFloats()) {
-    const auto* float_space = floating_object->space.get();
-    const NGConstraintSpace* original_parent_space =
-        floating_object->original_parent_space.get();
-
-    NGLogicalOffset origin_point = {float_space->BfcOffset().inline_offset,
-                                    origin_point_block_offset};
-    NGLogicalOffset from_offset = {
-        original_parent_space->BfcOffset().inline_offset, bfc_block_offset};
-
-    NGLogicalOffset float_fragment_offset = PositionFloat(
-        origin_point, from_offset, floating_object.get(), new_parent_space);
-    builder->AddFloatingObject(floating_object, float_fragment_offset);
-  }
-  builder->MutableUnpositionedFloats().clear();
-}
-
 // 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 147 matching lines @@
     curr_bfc_offset_.block_offset += curr_margin_strut_.Sum();
     UpdateFragmentBfcOffset(curr_bfc_offset_);
     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_);
     DCHECK_EQ(curr_margin_strut_, NGMarginStrut());
-    // TODO(glebl): Uncomment the line below once we add the fragmentation
-    // support for floats.
-    // DCHECK_EQ(builder_.BfcOffset().value(), NGLogicalOffset());
+    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().position();
       if (position == EPosition::kAbsolute || position == EPosition::kFixed) {
         // TODO(ikilpatrick): curr_margin_strut_ shouldn't be included if there
@@ skipping 143 matching lines @@
   NGBoxFragment fragment(
       ConstraintSpace().WritingMode(),
       toNGPhysicalBoxFragment(layout_result->PhysicalFragment().get()));
 
   // Pull out unpositioned floats to the current fragment. This may needed if
   // for example the child fragment could not position its floats because it's
   // empty and therefore couldn't determine its position in space.
   builder_.MutableUnpositionedFloats().appendVector(
       layout_result->UnpositionedFloats());
 
-  if (child->Type() == NGLayoutInputNode::kLegacyBlock &&
-      toNGBlockNode(child)->Style().isFloating()) {
+  if (child->IsBlock() && child->Style().isFloating()) {
+    NGLogicalOffset origin_offset = constraint_space_->BfcOffset();
+    origin_offset.inline_offset += border_and_padding_.inline_start;
     RefPtr<NGFloatingObject> floating_object = NGFloatingObject::Create(
-        child_space, constraint_space_, toNGBlockNode(child)->Style(),
-        curr_child_margins_, child_space->AvailableSize(),
+        child->Style(), child_space->WritingMode(),
+        child_space->AvailableSize(), origin_offset,
+        constraint_space_->BfcOffset(), curr_child_margins_,
         layout_result->PhysicalFragment().get());
     builder_.AddUnpositionedFloat(floating_object);
     // No need to postpone the positioning if we know the correct offset.
     if (builder_.BfcOffset()) {
       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.block_offset, MutableConstraintSpace(),
@@ skipping 138 matching lines @@
 
   LayoutUnit space_available;
   if (constraint_space_->HasBlockFragmentation()) {
     space_available = ConstraintSpace().FragmentainerSpaceAvailable();
     // If a block establishes a new formatting context we must know our
     // position in the formatting context, and are able to adjust the
     // fragmentation line.
     if (is_new_bfc) {
       DCHECK(builder_.BfcOffset());
       space_available -= curr_bfc_offset_.block_offset;
-      // TODO(glebl): We need to reset BFCOffset in ToConstraintSpace() after we
-      // started handling the fragmentation for floats.
-      space_builder_.SetBfcOffset(NGLogicalOffset());
     }
   }
   space_builder_.SetFragmentainerSpaceAvailable(space_available);
 
   return space_builder_.ToConstraintSpace(
       FromPlatformWritingMode(child_style.getWritingMode()));
 }
 }  // namespace blink