Change NGLayoutOpportunityIterator constructor to work with const CS.

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/ng_absolute_utils.h"
 #include "core/layout/ng/ng_block_break_token.h"
 #include "core/layout/ng/ng_block_child_iterator.h"
 #include "core/layout/ng/ng_box_fragment.h"
@@ skipping 116 matching lines @@
 //
 // @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.
 // @return Layout opportunity for the fragment.
 const NGLayoutOpportunity FindLayoutOpportunityForFragment(
-    NGConstraintSpace* space,
+    const NGConstraintSpace* space,
     const NGFragment& fragment,
     const NGLogicalOffset& origin_point,
     const NGBoxStrut& margins) {
   NGLogicalOffset adjusted_origin_point =
       AdjustToTopEdgeAlignmentRule(*space, origin_point);
 
   NGLayoutOpportunityIterator opportunity_iter(space, adjusted_origin_point);
   NGLayoutOpportunity opportunity;
   NGLayoutOpportunity opportunity_candidate = opportunity_iter.Next();
 
@@ skipping 31 matching lines @@
   block_offset -= from_offset.block_offset;
   inline_offset -= from_offset.inline_offset;
 
   return NGLogicalOffset(inline_offset, block_offset);
 }
 
 // Calculates the relative position from {@code from_offset} of the
 // floating object that is requested to be positioned from {@code origin_point}.
 NGLogicalOffset PositionFloat(const NGLogicalOffset& origin_point,
                               const NGLogicalOffset& from_offset,
-                              NGFloatingObject* floating_object) {
-  NGConstraintSpace* float_space = floating_object->space.get();
+                              NGFloatingObject* floating_object,
+                              NGConstraintSpace* new_parent_space) {
+  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);
   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);
-  float_space->AddExclusion(exclusion);
+  new_parent_space->AddExclusion(exclusion);
 
   return CalculateLogicalOffsetForOpportunity(opportunity, float_offset,
                                               from_offset, floating_object);
 }
 
 // Updates the Floating Object's left offset from the provided parent_space
 // and {@code floating_object}'s space and margins.
 void UpdateFloatingObjectLeftOffset(
     const NGConstraintSpace& new_parent_space,
     const Persistent<NGFloatingObject>& floating_object,
     const NGLogicalOffset& float_logical_offset) {
   // TODO(glebl): We should use physical offset here.
   floating_object->left_offset =
       floating_object->original_parent_space->BfcOffset().inline_offset -
       new_parent_space.BfcOffset().inline_offset +
       float_logical_offset.inline_offset;
 }
 
 // Positions pending floats stored on the fragment builder starting from
 // {@code origin_point_block_offset}.
 void PositionPendingFloats(const LayoutUnit origin_point_block_offset,
-                           const NGConstraintSpace& new_parent_space,
+                           NGConstraintSpace* new_parent_space,
                            NGFragmentBuilder* builder) {
   DCHECK(builder->BfcOffset()) << "Parent BFC offset should be known here";
   LayoutUnit bfc_block_offset = builder->BfcOffset().value().block_offset;
 
   for (auto& floating_object : builder->UnpositionedFloats()) {
-    NGConstraintSpace* float_space = floating_object->space.get();
+    const auto* float_space = floating_object->space.get();
     const NGConstraintSpace* original_parent_space =
         floating_object->original_parent_space.get();
 
     NGLogicalOffset origin_point = {float_space->BfcOffset().inline_offset,
                                     origin_point_block_offset};
     NGLogicalOffset from_offset = {
         original_parent_space->BfcOffset().inline_offset, bfc_block_offset};
 
-    NGLogicalOffset float_fragment_offset =
-        PositionFloat(origin_point, from_offset, floating_object);
+    NGLogicalOffset float_fragment_offset = PositionFloat(
+        origin_point, from_offset, floating_object, new_parent_space);
     builder->AddFloatingObject(floating_object, float_fragment_offset);
-    UpdateFloatingObjectLeftOffset(new_parent_space, floating_object,
+    UpdateFloatingObjectLeftOffset(*new_parent_space, floating_object,
                                    float_fragment_offset);
   }
   builder->MutableUnpositionedFloats().clear();
 }
 
 // Whether an in-flow block-level child creates a new formatting context.
 //
 // This will *NOT* check the following cases:
 //  - The child is out-of-flow, e.g. floating or abs-pos.
 //  - The child is a inline-level, e.g. "display: inline-block".
@@ skipping 226 matching lines @@
       ComputeBlockSizeForFragment(ConstraintSpace(), Style(), content_size_);
   builder_.SetBlockSize(block_size);
 
   // Layout our absolute and fixed positioned children.
   NGOutOfFlowLayoutPart(ConstraintSpace(), Style(), &builder_).Run();
 
   // Non-empty blocks always know their position in space:
   if (block_size) {
     curr_bfc_offset_.block_offset += curr_margin_strut_.Sum();
     UpdateFragmentBfcOffset(curr_bfc_offset_);
-    PositionPendingFloats(curr_bfc_offset_.block_offset, ConstraintSpace(),
-                          &builder_);
+    PositionPendingFloats(curr_bfc_offset_.block_offset,
+                          MutableConstraintSpace(), &builder_);
   }
 
   // Margins collapsing:
   //   Do not collapse margins between the last in-flow child and bottom margin
   //   of its parent if the parent has height != auto()
   if (!Style().logicalHeight().isAuto()) {
     // TODO(glebl): handle minLogicalHeight, maxLogicalHeight.
     curr_margin_strut_ = NGMarginStrut();
   }
   builder_.SetEndMarginStrut(curr_margin_strut_);
@@ skipping 37 matching lines @@
 
   // Pull out unpositioned floats to the current fragment. This may needed if
   // for example the child fragment could not position its floats because it's
   // empty and therefore couldn't determine its position in space.
   builder_.MutableUnpositionedFloats().appendVector(
       layout_result->UnpositionedFloats());
 
   if (child->Type() == NGLayoutInputNode::kLegacyBlock &&
       toNGBlockNode(child)->Style().isFloating()) {
     NGFloatingObject* floating_object = new NGFloatingObject(
-        layout_result->PhysicalFragment().get(), child_space, constraint_space_,
-        toNGBlockNode(child), toNGBlockNode(child)->Style(),
-        curr_child_margins_);
+        child_space, constraint_space_, toNGBlockNode(child)->Style(),
+        curr_child_margins_, layout_result->PhysicalFragment().get());
     builder_.AddUnpositionedFloat(floating_object);
     // No need to postpone the positioning if we know the correct offset.
     if (builder_.BfcOffset()) {
       NGLogicalOffset origin_point = curr_bfc_offset_;
       // Adjust origin point to the margins of the last child.
       // Example: <div style="margin-bottom: 20px"><float></div>
       //          <div style="margin-bottom: 30px"></div>
       origin_point.block_offset += curr_margin_strut_.Sum();
-      PositionPendingFloats(origin_point.block_offset, ConstraintSpace(),
+      PositionPendingFloats(origin_point.block_offset, MutableConstraintSpace(),
                             &builder_);
     }
     return;
   }
 
   // Determine the fragment's position in the parent space either by using
   // content_size_ or known fragment's BFC offset.
   WTF::Optional<NGLogicalOffset> bfc_offset;
   if (child_space->IsNewFormattingContext()) {
     // TODO(ikilpatrick): We may need to place ourself within the BFC
@@ skipping 10 matching lines @@
     // 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>
     bfc_offset = curr_bfc_offset_;
     bfc_offset.value().block_offset += curr_margin_strut_.Sum();
   }
   if (bfc_offset) {
     UpdateFragmentBfcOffset(curr_bfc_offset_);
-    PositionPendingFloats(curr_bfc_offset_.block_offset, ConstraintSpace(),
-                          &builder_);
+    PositionPendingFloats(curr_bfc_offset_.block_offset,
+                          MutableConstraintSpace(), &builder_);
   }
   NGLogicalOffset logical_offset = CalculateLogicalOffset(bfc_offset);
 
   // Update margin strut.
   curr_margin_strut_ = fragment.EndMarginStrut();
   curr_margin_strut_.Append(curr_child_margins_.block_end);
 
   // Only modify content_size if BlockSize is not empty. It's needed to prevent
   // the situation when logical_offset is included in content_size for empty
   // blocks. Example:
@@ skipping 74 matching lines @@
 RefPtr<NGConstraintSpace> NGBlockLayoutAlgorithm::CreateConstraintSpaceForChild(
     NGLayoutInputNode* child) {
   DCHECK(child);
 
   if (child->Type() == NGLayoutInputNode::kLegacyInline) {
     // TODO(kojii): Setup space_builder_ appropriately for inline child.
 
     // Margins collapsing: Inline block.
     curr_bfc_offset_.block_offset += curr_margin_strut_.Sum();
     UpdateFragmentBfcOffset(curr_bfc_offset_);
-    PositionPendingFloats(curr_bfc_offset_.block_offset, ConstraintSpace(),
-                          &builder_);
+    PositionPendingFloats(curr_bfc_offset_.block_offset,
+                          MutableConstraintSpace(), &builder_);
     curr_margin_strut_ = {};
 
     return space_builder_.ToConstraintSpace(
         FromPlatformWritingMode(Style().getWritingMode()));
   }
 
   NGBlockNode* block_child = toNGBlockNode(child);
   const ComputedStyle& child_style = block_child->Style();
 
   // Calculate margins in parent's writing mode.
@@ skipping 12 matching lines @@
   // - Position all pending floats since the fragment's BFC offset is known.
   // - Set the clearance offset on the constraint space's builder.
   if (child_style.clear() != EClear::kNone) {
     curr_bfc_offset_.block_offset += curr_margin_strut_.Sum();
     UpdateFragmentBfcOffset(curr_bfc_offset_);
     // Only collapse margins if it's an adjoining block with clearance.
     if (!content_size_) {
       curr_margin_strut_ = NGMarginStrut();
       curr_child_margins_.block_start = LayoutUnit();
     }
-    PositionPendingFloats(curr_bfc_offset_.block_offset, ConstraintSpace(),
-                          &builder_);
+    PositionPendingFloats(curr_bfc_offset_.block_offset,
+                          MutableConstraintSpace(), &builder_);
     WTF::Optional<LayoutUnit> clearance_offset =
         GetClearanceOffset(constraint_space_->Exclusions(), child_style);
     space_builder_.SetClearanceOffset(clearance_offset);
   }
 
   // Set estimated BFC offset to the next child's constraint space.
   curr_bfc_offset_ = builder_.BfcOffset() ? builder_.BfcOffset().value()
                                           : ConstraintSpace().BfcOffset();
   curr_bfc_offset_.block_offset += content_size_;
   curr_bfc_offset_.inline_offset += border_and_padding_.inline_start;
@@ skipping 22 matching lines @@
       DCHECK(builder_.BfcOffset());
       space_available -= curr_bfc_offset_.block_offset;
     }
   }
   space_builder_.SetFragmentainerSpaceAvailable(space_available);
 
   return space_builder_.ToConstraintSpace(
       FromPlatformWritingMode(child_style.getWritingMode()));
 }
 }  // namespace blink