[LayoutNG] Float behavior simplification before larger patch.

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"
 #include "core/layout/ng/ng_constraint_space_builder.h"
 #include "core/layout/ng/ng_layout_opportunity_iterator.h"
 #include "core/layout/ng/ng_layout_result.h"
@@ skipping 17 matching lines @@
         std::max(adjusted_block_offset,
                  space.Exclusions()->last_left_float->rect.BlockStartOffset());
   if (space.Exclusions()->last_right_float)
     adjusted_block_offset =
         std::max(adjusted_block_offset,
                  space.Exclusions()->last_right_float->rect.BlockStartOffset());
   return adjusted_offset;
 }
 
 NGLayoutOpportunity FindLayoutOpportunityForFloat(
+    const NGLogicalOffset& origin_offset,
     const NGConstraintSpace& space,
     const NGUnpositionedFloat& unpositioned_float,
     LayoutUnit inline_size) {
   NGLogicalOffset adjusted_origin_point =
-      AdjustToTopEdgeAlignmentRule(space, unpositioned_float.origin_offset);
+      AdjustToTopEdgeAlignmentRule(space, origin_offset);
   WTF::Optional<LayoutUnit> clearance_offset =
       GetClearanceOffset(space.Exclusions(), unpositioned_float.ClearType());
 
   AdjustToClearance(clearance_offset, &adjusted_origin_point);
 
   return FindLayoutOpportunityForFragment(
       space.Exclusions().get(), unpositioned_float.available_size,
       adjusted_origin_point, unpositioned_float.margins,
       {inline_size, LayoutUnit()});
 }
 
 // Calculates the logical offset for opportunity.
 NGLogicalOffset CalculateLogicalOffsetForOpportunity(
     const NGLayoutOpportunity& opportunity,
     const LayoutUnit float_offset,
+    const LayoutUnit parent_bfc_block_offset,
     const NGUnpositionedFloat* unpositioned_float) {
   DCHECK(unpositioned_float);
   auto margins = unpositioned_float->margins;
   // Adjust to child's margin.
   NGLogicalOffset result = margins.InlineBlockStartOffset();
 
   // Offset from the opportunity's block/inline start.
   result += opportunity.offset;
 
   // Adjust to float: right offset if needed.
   result.inline_offset += float_offset;
 
-  result -= unpositioned_float->from_offset;
+  result -= {unpositioned_float->bfc_inline_offset, parent_bfc_block_offset};
+
   return result;
 }
 
 // Creates an exclusion from the fragment that will be placed in the provided
 // layout opportunity.
 NGExclusion CreateExclusion(const NGFragment& fragment,
                             const NGLayoutOpportunity& opportunity,
                             const LayoutUnit float_offset,
                             const NGBoxStrut& margins,
                             NGExclusion::Type exclusion_type) {
   NGExclusion exclusion;
   exclusion.type = exclusion_type;
   NGLogicalRect& rect = exclusion.rect;
   rect.offset = opportunity.offset;
   rect.offset.inline_offset += float_offset;
 
   rect.size.inline_size = fragment.InlineSize() + margins.InlineSum();
   rect.size.block_size = fragment.BlockSize() + margins.BlockSum();
   return exclusion;
 }
 
 // Updates the Floating object's offsets.
 NGLogicalOffset CalculateFloatingObjectPaintOffset(
     const NGConstraintSpace& new_parent_space,
     const NGLogicalOffset& float_logical_offset,
     const NGUnpositionedFloat& unpositioned_float) {
-  LayoutUnit inline_offset = unpositioned_float.from_offset.inline_offset -
+  LayoutUnit inline_offset = unpositioned_float.bfc_inline_offset -
                              new_parent_space.BfcOffset().inline_offset +
                              float_logical_offset.inline_offset;
-  DCHECK(unpositioned_float.parent_bfc_block_offset);
-  LayoutUnit block_offset = unpositioned_float.from_offset.block_offset -
-                            unpositioned_float.parent_bfc_block_offset.value() +
-                            float_logical_offset.block_offset;
+  LayoutUnit block_offset = float_logical_offset.block_offset;
   return {inline_offset, block_offset};
 }
 
+// TODO(ikilpatrick): origin_block_offset looks wrong for fragmentation here.
 WTF::Optional<LayoutUnit> CalculateFragmentationOffset(
+    const LayoutUnit origin_block_offset,
     const NGUnpositionedFloat& unpositioned_float,
     const NGConstraintSpace& parent_space) {
   const ComputedStyle& style = unpositioned_float.node.Style();
   DCHECK(FromPlatformWritingMode(style.GetWritingMode()) ==
          parent_space.WritingMode());
 
   if (parent_space.HasBlockFragmentation()) {
-    return parent_space.FragmentainerSpaceAvailable() -
-           unpositioned_float.origin_offset.block_offset;
+    return parent_space.FragmentainerSpaceAvailable() - origin_block_offset;
   }
 
   return WTF::nullopt;
 }
 
 // Creates a constraint space for an unpositioned float.
 RefPtr<NGConstraintSpace> CreateConstraintSpaceForFloat(
     const NGUnpositionedFloat& unpositioned_float,
     NGConstraintSpace* parent_space,
     WTF::Optional<LayoutUnit> fragmentation_offset = WTF::nullopt) {
@@ skipping 64 matching lines @@
   RefPtr<NGPhysicalBoxFragment> fragment =
       ToNGPhysicalBoxFragment(layout_result->PhysicalFragment().Get());
   unpositioned_float->fragment = fragment;
 
   DCHECK(fragment->BreakToken()->IsFinished());
 
   return NGBoxFragment(parent_space->WritingMode(), fragment.Get())
       .InlineSize();
 }
 
-NGPositionedFloat PositionFloat(NGUnpositionedFloat* unpositioned_float,
+NGPositionedFloat PositionFloat(LayoutUnit origin_block_offset,
+                                LayoutUnit parent_bfc_block_offset,
+                                NGUnpositionedFloat* unpositioned_float,
                                 NGConstraintSpace* new_parent_space) {
   DCHECK(unpositioned_float);
   LayoutUnit inline_size = ComputeInlineSizeForUnpositionedFloat(
       new_parent_space, unpositioned_float);
 
+  NGLogicalOffset origin_offset = {unpositioned_float->origin_bfc_inline_offset,
+                                   origin_block_offset};
+
   // Find a layout opportunity that will fit our float.
   NGLayoutOpportunity opportunity = FindLayoutOpportunityForFloat(
-      *new_parent_space, *unpositioned_float, inline_size);
+      origin_offset, *new_parent_space, *unpositioned_float, inline_size);
 
 #if DCHECK_IS_ON()
   bool is_same_writing_mode =
       FromPlatformWritingMode(
           unpositioned_float->node.Style().GetWritingMode()) ==
       new_parent_space->WritingMode();
 #endif
 
   RefPtr<NGPhysicalBoxFragment> physical_fragment;
   // We should only have a fragment if its writing mode is different, i.e. it
   // can't fragment.
   if (unpositioned_float->fragment) {
 #if DCHECK_IS_ON()
     DCHECK(!is_same_writing_mode);
 #endif
     physical_fragment = unpositioned_float->fragment.value();
   } else {
 #if DCHECK_IS_ON()
     DCHECK(is_same_writing_mode);
 #endif
     WTF::Optional<LayoutUnit> fragmentation_offset =
-        CalculateFragmentationOffset(*unpositioned_float, *new_parent_space);
+        CalculateFragmentationOffset(origin_block_offset, *unpositioned_float,
+                                     *new_parent_space);
 
     RefPtr<NGConstraintSpace> space = CreateConstraintSpaceForFloat(
         *unpositioned_float, new_parent_space, fragmentation_offset);
     RefPtr<NGLayoutResult> layout_result = unpositioned_float->node.Layout(
         space.Get(), unpositioned_float->token.Get());
     physical_fragment =
         ToNGPhysicalBoxFragment(layout_result->PhysicalFragment().Get());
   }
 
   NGBoxFragment float_fragment(new_parent_space->WritingMode(),
@@ skipping 19 matching lines @@
   }
 
   // Add the float as an exclusion.
   const NGExclusion exclusion = CreateExclusion(
       float_fragment, opportunity, float_offset, unpositioned_float->margins,
       unpositioned_float->IsRight() ? NGExclusion::Type::kFloatRight
                                     : NGExclusion::Type::kFloatLeft);
   new_parent_space->AddExclusion(exclusion);
 
   NGLogicalOffset logical_offset = CalculateLogicalOffsetForOpportunity(
-      opportunity, float_offset, unpositioned_float);
+      opportunity, float_offset, parent_bfc_block_offset, unpositioned_float);
   NGLogicalOffset paint_offset = CalculateFloatingObjectPaintOffset(
       *new_parent_space, logical_offset, *unpositioned_float);
 
   return NGPositionedFloat(std::move(physical_fragment), logical_offset,
                            paint_offset);
 }
 
 const Vector<NGPositionedFloat> PositionFloats(
     LayoutUnit origin_block_offset,
-    LayoutUnit from_block_offset,
-    LayoutUnit parent_bfc_offset,
+    LayoutUnit parent_bfc_block_offset,
     const Vector<RefPtr<NGUnpositionedFloat>>& unpositioned_floats,
     NGConstraintSpace* space) {
   Vector<NGPositionedFloat> positioned_floats;
   positioned_floats.ReserveCapacity(unpositioned_floats.size());
 
   for (auto& unpositioned_float : unpositioned_floats) {
-    unpositioned_float->origin_offset.block_offset = origin_block_offset;
-    unpositioned_float->from_offset.block_offset = from_block_offset;
-    unpositioned_float->parent_bfc_block_offset = parent_bfc_offset;
-    positioned_floats.push_back(PositionFloat(unpositioned_float.Get(), space));
+    positioned_floats.push_back(PositionFloat(origin_block_offset,
+                                              parent_bfc_block_offset,
+                                              unpositioned_float.Get(), space));
   }
 
   return positioned_floats;
 }
 
 }  // namespace blink