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

third_party/WebKit/Source/core/layout/ng/ng_floats_utils.cc

 // Copyright 2017 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_floats_utils.h"
 
 #include "core/layout/ng/ng_box_fragment.h"
 
 namespace blink {
 namespace {
@@ skipping 22 matching lines @@
 // the first layout opportunity that is wider than the fragment or returns the
 // last one which is always the widest.
 //
 // @param space Constraint space that is used to find layout opportunity for
 //              the fragment.
 // @param fragment Fragment that needs to be placed.
 // @param origin_point {@code space}'s offset relative to the space that
 //                     establishes a new formatting context that we're currently
 //                     in and where all our exclusions reside.
 // @param margins Margins of the fragment.
+// @param available_size Available size used by the layout opportunity iterator.
 // @return Layout opportunity for the fragment.
 const NGLayoutOpportunity FindLayoutOpportunityForFragment(
     const NGConstraintSpace* space,
     const NGFragment& fragment,
     const NGLogicalOffset& origin_point,

[ikilpatrick, 2017/03/24 21:17:34]

so what i was imagining is that the caller to this (PositionFloat) would adjust
this argument for the inline_size, and that inline_size adjustment would live on
NGFloatingObject.

[Gleb Lanbin, 2017/03/24 21:49:36]

Acknowledged.

-    const NGBoxStrut& margins) {
+    const NGBoxStrut& margins,
+    const NGLogicalSize& available_size) {
   NGLogicalOffset adjusted_origin_point =
       AdjustToTopEdgeAlignmentRule(*space, origin_point);
 
-  NGLayoutOpportunityIterator opportunity_iter(space, adjusted_origin_point);
+  NGLayoutOpportunityIterator opportunity_iter(space, available_size,
+                                               adjusted_origin_point);
   NGLayoutOpportunity opportunity;
   NGLayoutOpportunity opportunity_candidate = opportunity_iter.Next();
 
   while (!opportunity_candidate.IsEmpty()) {
     opportunity = opportunity_candidate;
     // Checking opportunity's block size is not necessary as a float cannot be
     // positioned on top of another float inside of the same constraint space.
     auto fragment_inline_size = fragment.InlineSize() + margins.InlineSum();
     if (opportunity.size.inline_size >= fragment_inline_size)
       break;
@@ skipping 70 matching lines @@
   const auto* float_space = floating_object->space.get();
   DCHECK(floating_object->fragment) << "Fragment cannot be null here";
 
   // TODO(ikilpatrick): The writing mode switching here looks wrong.
   NGBoxFragment float_fragment(
       float_space->WritingMode(),
       toNGPhysicalBoxFragment(floating_object->fragment.get()));
 
   // Find a layout opportunity that will fit our float.
   const NGLayoutOpportunity opportunity = FindLayoutOpportunityForFragment(
-      float_space, float_fragment, origin_point, floating_object->margins);
+      new_parent_space, float_fragment, origin_point, floating_object->margins,

[ikilpatrick, 2017/03/24 21:17:34]

from above: e.g.

NGLogicalOffset adjusted_point({origin_point.inline_offset +
floating_object->inline_offset_adjustment, origin_point.block_offset});

[Gleb Lanbin, 2017/03/24 21:49:36]

I find this additional adjustment a bit confusing. We already store float's
constraint space at FloatingObject that has BfcOffset that we can use to compute
our origin_point. Lets wait for the fragmentation support for floats which may
remove "space" from FloatingObject and make it use inline_offset_adjustment
instead.

+      floating_object->available_size);
   DCHECK(!opportunity.IsEmpty()) << "Opportunity is empty but it shouldn't be";
 
   // Calculate the float offset if needed.
   LayoutUnit float_offset;
   if (floating_object->exclusion_type == NGExclusion::kFloatRight) {
     LayoutUnit float_margin_box_inline_size =
         float_fragment.InlineSize() + floating_object->margins.InlineSum();
     float_offset = opportunity.size.inline_size - float_margin_box_inline_size;
   }
 
   // Add the float as an exclusion.
   const NGExclusion exclusion = CreateExclusion(
       float_fragment, opportunity, float_offset, floating_object->margins,
       floating_object->exclusion_type);
   new_parent_space->AddExclusion(exclusion);
 
   NGLogicalOffset logical_offset = CalculateLogicalOffsetForOpportunity(
       opportunity, float_offset, from_offset, floating_object);
   UpdateFloatingObjectLeftOffset(*new_parent_space, logical_offset,
                                  floating_object);
   return logical_offset;
 }
 }  // namespace blink