CS of out-of-flow positioned objects should have is_new_fc == true

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_block_child_iterator.h"
 #include "core/layout/ng/ng_box_fragment.h"
@@ skipping 169 matching lines @@
 
   // 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_);
     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_);
-    DCHECK_EQ(builder_.BfcOffset().value(), NGLogicalOffset());
     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());
+    curr_bfc_offset_ = {};
   }
 
   curr_bfc_offset_.block_offset += content_size_;
 
   while (child) {
     if (child->Type() == NGLayoutInputNode::kLegacyBlock) {
       NGBlockNode* current_block_child = toNGBlockNode(child);
       EPosition position = current_block_child->Style().position();
       if (position == EPosition::kAbsolute || position == EPosition::kFixed) {
         NGLogicalOffset offset = {border_and_padding_.inline_start,
@@ skipping 131 matching lines @@
   // 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()) {
     RefPtr<NGFloatingObject> floating_object = NGFloatingObject::Create(
         child_space, constraint_space_, toNGBlockNode(child)->Style(),
-        curr_child_margins_, layout_result->PhysicalFragment().get());
+        curr_child_margins_, child_space->AvailableSize(),
+        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(),
                             &builder_);
@@ skipping 109 matching lines @@
   if (!child_style.isFloating()) {
     ApplyAutoMargins(space, child_style, child_inline_size, &margins);
   }
   return margins;
 }
 
 RefPtr<NGConstraintSpace> NGBlockLayoutAlgorithm::CreateConstraintSpaceForChild(
     NGLayoutInputNode* child) {
   DCHECK(child);
 
-  if (child->Type() == NGLayoutInputNode::kLegacyInline) {
+  const ComputedStyle& child_style = child->Style();
+  bool is_new_bfc =
+      IsNewFormattingContextForBlockLevelChild(ConstraintSpace(), child_style);
+  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_);
     return space_builder_.ToConstraintSpace(
         FromPlatformWritingMode(Style().getWritingMode()));
   }
 
-  const ComputedStyle& child_style = toNGBlockNode(child)->Style();
-
-  bool is_new_bfc = IsNewFormattingContextForInFlowBlockLevelChild(
-      ConstraintSpace(), child_style);
-  space_builder_.SetIsNewFormattingContext(is_new_bfc)
-      .SetBfcOffset(curr_bfc_offset_)
+  space_builder_
       .SetClearanceOffset(
           GetClearanceOffset(constraint_space_->Exclusions(), child_style))
       .SetIsShrinkToFit(ShouldShrinkToFit(ConstraintSpace(), child_style))
       .SetTextDirection(child_style.direction());
 
   // Float's margins are not included in child's space because:
   // 1) Floats do not participate in margins collapsing.
   // 2) Floats margins are used separately to calculate floating exclusions.
   space_builder_.SetMarginStrut(child_style.isFloating() ? NGMarginStrut()
                                                          : curr_margin_strut_);
 
   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