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

third_party/WebKit/Source/core/layout/ng/ng_layout_opportunity_iterator.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_layout_opportunity_iterator.h"
 #include "core/layout/ng/ng_constraint_space.h"
 #include "core/layout/ng/ng_exclusion.h"
 #include "wtf/NonCopyingSort.h"
 #include "wtf/text/StringBuilder.h"
 
@@ skipping 37 matching lines @@
     return;
   if (node->IsLeafNode())
     opportunities.push_back(node->opportunity);
   CollectAllOpportunities(node->left.get(), opportunities);
   CollectAllOpportunities(node->bottom.get(), opportunities);
   CollectAllOpportunities(node->right.get(), opportunities);
 }
 
 // Creates layout opportunity from the provided space and the origin point.
 NGLayoutOpportunity CreateLayoutOpportunityFromConstraintSpace(
-    const NGConstraintSpace& space,
+    const NGLogicalSize& size,
     const NGLogicalOffset& origin_point) {
   NGLayoutOpportunity opportunity;
   // TODO(glebl): Perhaps fix other methods (e.g IsContained) instead of using
   // INT_MAX here.
-  opportunity.size.block_size = space.AvailableSize().block_size >= 0
-                                    ? space.AvailableSize().block_size
-                                    : LayoutUnit(INT_MAX);
-  opportunity.size.inline_size = space.AvailableSize().inline_size >= 0
-                                     ? space.AvailableSize().inline_size
-                                     : LayoutUnit(INT_MAX);
+  opportunity.size.block_size =
+      size.block_size >= 0 ? size.block_size : LayoutUnit(INT_MAX);
+  opportunity.size.inline_size =
+      size.inline_size >= 0 ? size.inline_size : LayoutUnit(INT_MAX);
 
   // adjust to the origin_point.
   opportunity.offset += origin_point;
   return opportunity;
 }
 
 // Whether 2 edges overlap with each other.
 bool IsOverlapping(const NGEdge& edge1, const NGEdge& edge2) {
   return std::max(edge1.start, edge2.start) <= std::min(edge1.end, edge2.end);
 }
@@ skipping 190 matching lines @@
   NGExclusion leader_exclusion;
   leader_exclusion.rect.offset = origin_point;
   leader_exclusion.rect.size = {inline_size, block_size};
   return leader_exclusion;
 }
 
 }  // namespace
 
 NGLayoutOpportunityIterator::NGLayoutOpportunityIterator(
     const NGConstraintSpace* space,
+    const NGLogicalSize& available_size,
     const WTF::Optional<NGLogicalOffset>& opt_offset,
     const WTF::Optional<NGLogicalOffset>& opt_leader_point)
     : constraint_space_(space),
       offset_(opt_offset ? opt_offset.value() : space->BfcOffset()) {
   // TODO(chrome-layout-team): Combine exclusions that shadow each other.
   auto& exclusions = constraint_space_->Exclusions();
   DCHECK(std::is_sorted(exclusions->storage.begin(), exclusions->storage.end(),
                         &CompareNGExclusionsByTopAsc))
       << "Exclusions are expected to be sorted by TOP";
 
   NGLayoutOpportunity initial_opportunity =
-      CreateLayoutOpportunityFromConstraintSpace(*constraint_space_, Offset());
+      CreateLayoutOpportunityFromConstraintSpace(available_size, Offset());
   opportunity_tree_root_.reset(
       new NGLayoutOpportunityTreeNode(initial_opportunity));
 
   if (opt_leader_point) {
     const NGExclusion leader_exclusion =
         ToLeaderExclusion(Offset(), opt_leader_point.value());
     InsertExclusion(MutableOpportunityTreeRoot(), &leader_exclusion,
                     opportunities_);
   }
 
@@ skipping 19 matching lines @@
 #ifndef NDEBUG
 void NGLayoutOpportunityIterator::ShowLayoutOpportunityTree() const {
   StringBuilder string_builder;
   string_builder.append("\n.:: LayoutOpportunity Tree ::.\n\nRoot Node: ");
   AppendNodeToString(opportunity_tree_root_.get(), &string_builder);
   fprintf(stderr, "%s\n", string_builder.toString().utf8().data());
 }
 #endif
 
 }  // namespace blink