Use Layout Opportunity Iterator to position new FC blocks.

third_party/WebKit/Source/core/layout/ng/ng_block_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 NGBlockLayoutAlgorithm_h
 #define NGBlockLayoutAlgorithm_h
 
 #include "core/CoreExport.h"
 #include "core/layout/ng/geometry/ng_margin_strut.h"
 #include "core/layout/ng/ng_block_break_token.h"
 #include "core/layout/ng/ng_block_node.h"
+#include "core/layout/ng/ng_box_fragment.h"
 #include "core/layout/ng/ng_constraint_space_builder.h"
 #include "core/layout/ng/ng_layout_algorithm.h"
 #include "platform/wtf/RefPtr.h"
 
 namespace blink {
 
 class NGConstraintSpace;
 class NGLayoutResult;
 
 // Updates the fragment's BFC offset if it's not already set.
 void MaybeUpdateFragmentBfcOffset(const NGConstraintSpace&,
                                   const NGLogicalOffset&,
                                   NGFragmentBuilder* builder);
 
+// Positions pending floats starting from {@origin_block_offset} and relative
+// to container's BFC offset.
+void PositionPendingFloats(LayoutUnit origin_block_offset,
+                           NGFragmentBuilder* container_builder,
+                           NGConstraintSpace* space);
+
 // A class for general block layout (e.g. a <div> with no special style).
 // Lays out the children in sequence.
 class CORE_EXPORT NGBlockLayoutAlgorithm
     : public NGLayoutAlgorithm<NGBlockNode, NGBlockBreakToken> {
  public:
   // Default constructor.
   // @param node The input node to perform layout upon.
   // @param space The constraint space which the algorithm should generate a
   //              fragment within.
   // @param break_token The break token from which the layout should start.
   NGBlockLayoutAlgorithm(NGBlockNode* node,
                          NGConstraintSpace* space,
                          NGBlockBreakToken* break_token = nullptr);
 
   Optional<MinMaxContentSize> ComputeMinMaxContentSize() const override;
   virtual RefPtr<NGLayoutResult> Layout() override;
 
  private:
   NGBoxStrut CalculateMargins(NGLayoutInputNode* child,
                               const NGConstraintSpace& space);
 
   // Creates a new constraint space for the current child.
-  RefPtr<NGConstraintSpace> CreateConstraintSpaceForChild(NGLayoutInputNode*);
-  void PrepareChildLayout(NGLayoutInputNode*);
-  void FinishChildLayout(NGLayoutInputNode*,
-                         NGConstraintSpace*,
-                         RefPtr<NGLayoutResult>);
+  RefPtr<NGConstraintSpace> CreateConstraintSpaceForChild(
+      const NGLogicalOffset& child_bfc_offset,
+      NGLayoutInputNode*);
+
+  // @return Estimated BFC offset for the "to be layout" child.
+  NGLogicalOffset PrepareChildLayout(NGLayoutInputNode*);
+
+  void FinishChildLayout(const NGConstraintSpace*, NGLayoutResult*);
+
+  // Positions the fragment that establishes a new formatting context.
+  //
+  // This uses Layout Opportunity iterator to position the fragment.
+  // That's because an element that establishes a new block formatting context
+  // must not overlap the margin box of any floats in the same block formatting
+  // context as the element itself.
+  //
+  // So if necessary, we clear the new BFC by placing it below any preceding
+  // floats or place it adjacent to such floats if there is sufficient space.
+  //
+  // Example:
+  // <div id="container">
+  //   <div id="float"></div>
+  //   <div id="new-fc" style="margin-top: 20px;"></div>
+  // </div>
+  // 1) If #new-fc is small enough to fit the available space right from #float
+  //    then it will be placed there and we collapse its margin.
+  // 2) If #new-fc is too big then we need to clear its position and place it
+  //    below #float ignoring its vertical margin.
+  NGLogicalOffset PositionNewFc(const NGBoxFragment&,
+                                const NGConstraintSpace& child_space);
+
+  // Positions the fragment that knows its BFC offset.
+  NGLogicalOffset PositionWithBfcOffset(const NGBoxFragment&);
+
+  // Positions using the parent BFC offset.
+  // Fragment doesn't know its offset but we can still calculate its BFC
+  // position because the parent fragment's BFC is known.
+  // Example:
+  //   BFC Offset is known here because of the padding.
+  //   <div style="padding: 1px">
+  //     <div id="empty-div" style="margins: 1px"></div>
+  NGLogicalOffset PositionWithParentBfc();
+
+  void FinishFloatChildLayout(const ComputedStyle&,
+                              const NGConstraintSpace&,
+                              const NGLayoutResult*);
 
   // Final adjustments before fragment creation. We need to prevent the
   // fragment from crossing fragmentainer boundaries, and rather create a break
   // token if we're out of space.
   void FinalizeForFragmentation();
 
   // Calculates logical offset for the current fragment using either
   // {@code content_size_} when the fragment doesn't know it's offset
   // or {@code known_fragment_offset} if the fragment knows it's offset
   // @return Fragment's offset relative to the fragment's parent.
   NGLogicalOffset CalculateLogicalOffset(
       const WTF::Optional<NGLogicalOffset>& known_fragment_offset);
 
   NGConstraintSpaceBuilder space_builder_;
 
   NGBoxStrut border_and_padding_;
   LayoutUnit content_size_;
   LayoutUnit max_inline_size_;
   // MarginStrut for the previous child.
   NGMarginStrut curr_margin_strut_;
   NGLogicalOffset curr_bfc_offset_;
   NGBoxStrut curr_child_margins_;
 };
 
 }  // namespace blink
 
 #endif  // NGBlockLayoutAlgorithm_h