[LayoutNG] Remove derived constraint spaces from opportunity iterator.

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_constraint_space.h"
 #include "core/layout/ng/ng_fragment_builder.h"
 #include "core/layout/ng/ng_fragment.h"
 #include "core/layout/ng/ng_layout_opportunity_iterator.h"
@@ skipping 10 matching lines @@
     const NGMarginStrut& curr_margin_strut) {
   return std::max(prev_margin_strut.margin_block_end,
                   curr_margin_strut.margin_block_start) -
          std::max(prev_margin_strut.negative_margin_block_end.abs(),
                   curr_margin_strut.negative_margin_block_start.abs());
 }
 
 // Creates an exclusion from the fragment that will be placed in the provided
 // layout opportunity.
 NGExclusion* CreateExclusion(const NGFragment& fragment,
-                             const NGConstraintSpace* opportunity,
+                             const NGLogicalRect& opportunity,

[Gleb Lanbin, 2016/10/24 16:45:44]

use NGLayoutOpportunity and below.

[ikilpatrick, 2016/10/24 17:09:19]

Done.

                              LayoutUnit float_offset,
                              NGBoxStrut margins) {
-  LayoutUnit exclusion_top = opportunity->Offset().block_offset;
+  LayoutUnit exclusion_top = opportunity.offset.block_offset;
 
-  LayoutUnit exclusion_left = opportunity->Offset().inline_offset;
+  LayoutUnit exclusion_left = opportunity.offset.inline_offset;
   exclusion_left += float_offset;
 
   LayoutUnit exclusion_bottom = exclusion_top + fragment.BlockSize();
   LayoutUnit exclusion_right = exclusion_left + fragment.InlineSize();
 
   // Adjust to child's margin.
   exclusion_bottom += margins.BlockSum();
   exclusion_right += margins.InlineSum();
 
   return new NGExclusion(exclusion_top, exclusion_right, exclusion_bottom,
                          exclusion_left);
 }
 
 // Finds a layout opportunity for the fragment.
 // It iterates over all layout opportunities in the constraint space and returns
 // the first layout opportunity that is wider than the fragment or returns the
 // last one which is always the widest.
 //
 // @param space Constraint space that is used to find layout opportunity for
 //              the fragment.
 // @param fragment Fragment that needs to be placed.
 // @return Layout opportunity for the fragment.
-const NGConstraintSpace* FindLayoutOpportunityForFragment(
+const NGLogicalRect FindLayoutOpportunityForFragment(
     const Member<NGConstraintSpace>& space,
     const NGFragment& fragment) {
   NGLayoutOpportunityIterator* opportunity_iter = space->LayoutOpportunities();
-  const NGConstraintSpace* opportunity = nullptr;
-  while (const NGConstraintSpace* opportunity_candidate =
-             opportunity_iter->Next()) {
+  NGLogicalRect opportunity;
+  NGLogicalRect opportunity_candidate = opportunity_iter->Next();
+
+  while (!opportunity_candidate.IsEmpty()) {
     opportunity = opportunity_candidate;
     // Checking opportunity's block size is not necessary as a float cannot be
     // positioned on top of another float inside of the same constraint space.
-    if (opportunity->Size().inline_size > fragment.InlineSize())
+    if (opportunity.size.inline_size > fragment.InlineSize())
       break;
+
+    opportunity_candidate = opportunity_iter->Next();
   }
+
   return opportunity;
 }
 
 // Calculates the logical offset for opportunity.
 NGLogicalOffset CalculateLogicalOffsetForOpportunity(
-    const NGConstraintSpace* opportunity,
+    const NGLogicalRect& opportunity,
     NGBoxStrut border_padding,
     LayoutUnit float_offset,
     NGBoxStrut margins) {
   // TODO(layout-ng): create children_constraint_space with an offset for the
   // border and padding.
   // Offset from parent's border/padding.
   LayoutUnit inline_offset = border_padding.inline_start;
   LayoutUnit block_offset = border_padding.block_start;
 
   // Adjust to child's margin.
   inline_offset += margins.inline_start;
   block_offset += margins.block_start;
 
   // Offset from the opportunity's block/inline start.
-  inline_offset += opportunity->Offset().inline_offset;
-  block_offset += opportunity->Offset().block_offset;
+  inline_offset += opportunity.offset.inline_offset;
+  block_offset += opportunity.offset.block_offset;
 
   inline_offset += float_offset;
 
   return NGLogicalOffset(inline_offset, block_offset);
 }
 
 // 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.
@@ skipping 212 matching lines @@
       max_inline_size_, fragment.InlineSize() + child_margins.InlineSum() +
                             border_and_padding_.InlineSum());
   return NGLogicalOffset(inline_offset, block_offset);
 }
 
 NGLogicalOffset NGBlockLayoutAlgorithm::PositionFloatFragment(
     const NGFragment& fragment,
     NGBoxStrut margins) {
   // TODO(glebl@chromium.org): Support the top edge alignment rule.
   // Find a layout opportunity that will fit our float.
-  const NGConstraintSpace* opportunity = FindLayoutOpportunityForFragment(
+  const NGLogicalRect opportunity = FindLayoutOpportunityForFragment(
       constraint_space_for_children_, fragment);
-  DCHECK(opportunity) << "Opportunity is NULL but it shouldn't be";
+  DCHECK(!opportunity.IsEmpty()) << "Opportunity is empty but it shouldn't be";
 
   // Calculate the float offset if needed.
   LayoutUnit float_offset;
   if (current_child_->Style()->floating() == EFloat::Right) {
-    float_offset = opportunity->Size().inline_size - fragment.InlineSize();
+    float_offset = opportunity.size.inline_size - fragment.InlineSize();
   }
 
   // Add the float as an exclusion.
   NGExclusion* exclusion =
       CreateExclusion(fragment, opportunity, float_offset, margins);
   constraint_space_for_children_->AddExclusion(exclusion);
 
   return CalculateLogicalOffsetForOpportunity(opportunity, border_and_padding_,
                                               float_offset, margins);
 }
 
 void NGBlockLayoutAlgorithm::UpdateMarginStrut(const NGMarginStrut& from) {
   if (!is_fragment_margin_strut_block_start_updated_) {
     builder_->SetMarginStrutBlockStart(from);
     is_fragment_margin_strut_block_start_updated_ = true;
   }
   builder_->SetMarginStrutBlockEnd(from);
 }
 
 }  // namespace blink