Use Layout Opportunity Iterator to position new FC blocks.

third_party/WebKit/Source/core/layout/ng/ng_layout_algorithm.h

 // 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.
 
 #ifndef NGLayoutAlgorithm_h
 #define NGLayoutAlgorithm_h
 
 #include "core/CoreExport.h"
+#include "core/layout/ng/ng_floats_utils.h"
 #include "core/layout/ng/ng_fragment_builder.h"
 #include "core/layout/ng/ng_min_max_content_size.h"
 #include "platform/wtf/Allocator.h"
 #include "platform/wtf/Optional.h"
 
 namespace blink {
 
 class ComputedStyle;
 class NGConstraintSpace;
 class NGLayoutResult;
@@ skipping 38 matching lines @@
   const ComputedStyle& Style() const {
     DCHECK(node_);
     return node_->Style();
   }
 
   NGLogicalOffset ContainerBfcOffset() const {
     DCHECK(container_builder_.BfcOffset().has_value());
     return container_builder_.BfcOffset().value();
   }
 
+  // Positions pending floats starting from {@origin_block_offset} and relative
+  // to ContainerBfcOffset().
+  void PositionPendingFloats(LayoutUnit origin_block_offset) {

[ikilpatrick, 2017/04/18 13:19:56]

if there is another way to do this i'd prefer that, as this is very block-flow
specific... i.e. no other layout algorithms will use this. 

Could do the same thing as MaybeUpdateFragmentBfcOffset for now?

Or might be time to do this block/inline specific sub-class.

[Gleb Lanbin, 2017/04/18 17:30:20]

yes, I was thinking about that as well. Here are 4 options:

1) Make NGInlineLayoutAlgorithm to inherit NGBlockLayoutAlgorithm. That's
because NGInlineLayoutAlgorithm produces a block fragment as as result.

2) (SELECTED) Leave PositionPendingFloats in NGLayoutAlgorithm base class for
now but have an annotation that it should be only used by
NG{Block|Inline}Algorithms. Later we can decide what to do with them

3) Make PositionPendingFloats static. But that will make PositionPendingFloats
usage not very convenient. 

4) Create an interim base class for Block/Inline algorithms.

[ikilpatrick, 2017/04/18 21:04:11]

My preferred option here would be (4) in a follow up patch. We'll need to be
very principled about only simple methods in the base class.

+    DCHECK(container_builder_.BfcOffset())
+        << "Parent BFC offset should be known here";
+    const auto& floating_objects = container_builder_.UnpositionedFloats();
+    PositionFloats(origin_block_offset, ContainerBfcOffset().block_offset,
+                   floating_objects, MutableConstraintSpace());
+    container_builder_.MutablePositionedFloats().AppendVector(floating_objects);
+    container_builder_.MutableUnpositionedFloats().Clear();
+  }
+
   virtual NGInputNodeType* Node() const { return node_; }
 
   NGBreakTokenType* BreakToken() const { return break_token_; }
 
   Persistent<NGInputNodeType> node_;
   NGConstraintSpace* constraint_space_;
 
   // The break token from which we are currently resuming layout.
   NGBreakTokenType* break_token_;
 
   NGFragmentBuilder container_builder_;
 };
 
 }  // namespace blink
 
 #endif  // NGLayoutAlgorithm_h