[LayoutNG] Float behavior simplification before larger patch.

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/inline/ng_inline_node.h"
 #include "core/layout/ng/ng_absolute_utils.h"
 #include "core/layout/ng/ng_block_child_iterator.h"
 #include "core/layout/ng/ng_constraint_space.h"
@@ skipping 73 matching lines @@
                                   NGFragmentBuilder* builder) {
   DCHECK(builder);
   if (!builder->BfcOffset()) {
     NGLogicalOffset bfc_offset = {space.BfcOffset().inline_offset,
                                   bfc_block_offset};
     AdjustToClearance(space.ClearanceOffset(), &bfc_offset);
     builder->SetBfcOffset(bfc_offset);
   }
 }
 
-void PositionPendingFloatsFromOffset(LayoutUnit origin_block_offset,
-                                     LayoutUnit from_block_offset,
-                                     NGFragmentBuilder* container_builder,
-                                     NGConstraintSpace* space) {
-  DCHECK(container_builder->BfcOffset())
-      << "Parent BFC offset should be known here";
-  const auto& unpositioned_floats = container_builder->UnpositionedFloats();
-  const auto positioned_floats =
-      PositionFloats(origin_block_offset, from_block_offset,
-                     container_builder->BfcOffset().value().block_offset,
-                     unpositioned_floats, space);
-  for (const auto& positioned_float : positioned_floats)
-    container_builder->AddPositionedFloat(positioned_float);
-
-  container_builder->MutableUnpositionedFloats().clear();
-}
-
 void PositionPendingFloats(LayoutUnit origin_block_offset,
                            NGFragmentBuilder* container_builder,
                            NGConstraintSpace* space) {
   DCHECK(container_builder->BfcOffset())
       << "Parent BFC offset should be known here";
-  LayoutUnit from_block_offset =
-      container_builder->BfcOffset().value().block_offset;
-  PositionPendingFloatsFromOffset(origin_block_offset, from_block_offset,
-                                  container_builder, space);
+
+  const auto& unpositioned_floats = container_builder->UnpositionedFloats();
+  const auto positioned_floats = PositionFloats(
+      origin_block_offset, container_builder->BfcOffset().value().block_offset,
+      unpositioned_floats, space);
+
+  for (const auto& positioned_float : positioned_floats)
+    container_builder->AddPositionedFloat(positioned_float);
+
+  container_builder->MutableUnpositionedFloats().clear();
 }
 
 NGBlockLayoutAlgorithm::NGBlockLayoutAlgorithm(NGBlockNode node,
                                                NGConstraintSpace* space,
                                                NGBlockBreakToken* break_token)
     : NGLayoutAlgorithm(node, space, break_token) {}
 
 Optional<MinMaxContentSize> NGBlockLayoutAlgorithm::ComputeMinMaxContentSize()
     const {
   MinMaxContentSize sizes;
@@ skipping 237 matching lines @@
   container_builder_.AddOutOfFlowChildCandidate(child, offset);
 }
 
 void NGBlockLayoutAlgorithm::HandleFloating(
     const NGPreviousInflowPosition& previous_inflow_position,
     NGBlockNode child,
     NGBlockBreakToken* token) {
   // Calculate margins in the BFC's writing mode.
   NGBoxStrut margins = CalculateMargins(child);
 
-  NGLogicalOffset origin_offset = constraint_space_->BfcOffset();
-  origin_offset.inline_offset += border_scrollbar_padding_.inline_start;
+  LayoutUnit origin_inline_offset =
+      constraint_space_->BfcOffset().inline_offset +
+      border_scrollbar_padding_.inline_start;
+
   RefPtr<NGUnpositionedFloat> unpositioned_float = NGUnpositionedFloat::Create(
-      child_available_size_, child_percentage_size_, origin_offset,
-      constraint_space_->BfcOffset(), margins, child, token);
+      child_available_size_, child_percentage_size_, origin_inline_offset,
+      constraint_space_->BfcOffset().inline_offset, margins, child, token);
   container_builder_.AddUnpositionedFloat(unpositioned_float);
 
   // If there is a break token for a float we must be resuming layout, we must
   // always know our position in the BFC.
   DCHECK(!token || container_builder_.BfcOffset());
 
   // No need to postpone the positioning if we know the correct offset.
   if (container_builder_.BfcOffset()) {
     // Adjust origin point to the margins of the last child.
     // Example: <div style="margin-bottom: 20px"><float></div>
@@ skipping 137 matching lines @@
 
   LayoutUnit child_bfc_offset_estimate =
       child_data.bfc_offset_estimate.block_offset;
 
   // 1. Position all pending floats to a temporary space.
   RefPtr<NGConstraintSpace> tmp_space =
       NGConstraintSpaceBuilder(&child_space)
           .SetIsNewFormattingContext(false)
           .ToConstraintSpace(child_space.WritingMode());
   PositionFloats(child_bfc_offset_estimate, child_bfc_offset_estimate,
-                 child_bfc_offset_estimate,
                  container_builder_.UnpositionedFloats(), tmp_space.Get());
 
   NGLogicalOffset origin_offset = {ConstraintSpace().BfcOffset().inline_offset +
                                        border_scrollbar_padding_.inline_start,
                                    child_bfc_offset_estimate};
   AdjustToClearance(
       GetClearanceOffset(ConstraintSpace().Exclusions(), child_style.Clear()),
       &origin_offset);
 
   // 2. Find an estimated layout opportunity for our fragment.
@@ skipping 53 matching lines @@
   DCHECK_EQ(fragment.BlockSize(), LayoutUnit());
 
   NGLogicalOffset child_bfc_offset = {
       ConstraintSpace().BfcOffset().inline_offset +
           border_scrollbar_padding_.inline_start +
           child_data.margins.inline_start,
       child_data.bfc_offset_estimate.block_offset +
           layout_result.EndMarginStrut().Sum()};
 
   AdjustToClearance(space.ClearanceOffset(), &child_bfc_offset);
-  PositionPendingFloatsFromOffset(
-      child_bfc_offset.block_offset, child_bfc_offset.block_offset,
-      &container_builder_, MutableConstraintSpace());
+  PositionPendingFloats(child_bfc_offset.block_offset, &container_builder_,
+                        MutableConstraintSpace());
   return child_bfc_offset;
 }
 
 void NGBlockLayoutAlgorithm::FinalizeForFragmentation() {
   LayoutUnit used_block_size =
       BreakToken() ? BreakToken()->UsedBlockSize() : LayoutUnit();
   LayoutUnit block_size = ComputeBlockSizeForFragment(
       ConstraintSpace(), Style(), used_block_size + content_size_);
 
   block_size -= used_block_size;
@@ skipping 99 matching lines @@
     if (is_new_fc) {
       space_available -= child_data.bfc_offset_estimate.block_offset;
     }
   }
   space_builder.SetFragmentainerSpaceAvailable(space_available);
 
   return space_builder.ToConstraintSpace(
       FromPlatformWritingMode(child_style.GetWritingMode()));
 }
 }  // namespace blink