Change NGLayoutOpportunityIterator API to work with list of exclusions

third_party/WebKit/Source/core/layout/ng/ng_layout_opportunity_iterator.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_layout_opportunity_iterator.h"
 #include "core/layout/ng/ng_constraint_space.h"
 #include "core/layout/ng/ng_exclusion.h"
 #include "platform/wtf/NonCopyingSort.h"
 #include "platform/wtf/text/StringBuilder.h"
 
@@ skipping 35 matching lines @@
                              NGLayoutOpportunities& opportunities) {
   if (!node)
     return;
   if (node->IsLeafNode())
     opportunities.push_back(node->opportunity);
   CollectAllOpportunities(node->left.get(), opportunities);
   CollectAllOpportunities(node->bottom.get(), opportunities);
   CollectAllOpportunities(node->right.get(), opportunities);
 }
 
-// Creates layout opportunity from the provided space and the origin point.
-NGLayoutOpportunity CreateLayoutOpportunityFromConstraintSpace(
+// Creates layout opportunity from the provided size and the origin point.
+NGLayoutOpportunity CreateInitialOpportunity(
     const NGLogicalSize& size,
     const NGLogicalOffset& origin_point) {
   NGLayoutOpportunity opportunity;
   // TODO(glebl): Perhaps fix other methods (e.g IsContained) instead of using
   // INT_MAX here.
   opportunity.size.block_size =
       size.block_size >= 0 ? size.block_size : LayoutUnit(INT_MAX);
   opportunity.size.inline_size =
       size.inline_size >= 0 ? size.inline_size : LayoutUnit(INT_MAX);
 
@@ skipping 182 matching lines @@
   if (rhs.offset.inline_offset > lhs.offset.inline_offset) {
     return true;
   }
   if (rhs.offset.inline_offset < lhs.offset.inline_offset) {
     return false;
   }
 
   // TOP and LEFT are the same -> Sort by width
   return rhs.size.inline_size < lhs.size.inline_size;
 }
-
-NGExclusion ToLeaderExclusion(const NGLogicalOffset& origin_point,
-                              const NGLogicalOffset& leader_point) {
-  LayoutUnit inline_size =
-      leader_point.inline_offset - origin_point.inline_offset;
-  LayoutUnit block_size = leader_point.block_offset - origin_point.block_offset;
-
-  NGExclusion leader_exclusion;
-  leader_exclusion.rect.offset = origin_point;
-  leader_exclusion.rect.size = {inline_size, block_size};
-  return leader_exclusion;
-}
-
 }  // namespace
 
 NGLayoutOpportunityIterator::NGLayoutOpportunityIterator(
-    const NGConstraintSpace* space,
+    const NGExclusions* exclusions,
     const NGLogicalSize& available_size,
-    const WTF::Optional<NGLogicalOffset>& opt_offset,
-    const WTF::Optional<NGLogicalOffset>& opt_leader_point)
-    : constraint_space_(space),
-      offset_(opt_offset ? opt_offset.value() : space->BfcOffset()) {
-  // TODO(chrome-layout-team): Combine exclusions that shadow each other.
-  auto& exclusions = constraint_space_->Exclusions();
+    const NGLogicalOffset& offset)
+    : offset_(offset) {
+  DCHECK(exclusions);
   DCHECK(std::is_sorted(exclusions->storage.begin(), exclusions->storage.end(),
                         &CompareNGExclusionsByTopAsc))
       << "Exclusions are expected to be sorted by TOP";
 
   NGLayoutOpportunity initial_opportunity =
-      CreateLayoutOpportunityFromConstraintSpace(available_size, Offset());
+      CreateInitialOpportunity(available_size, Offset());
   opportunity_tree_root_.reset(
       new NGLayoutOpportunityTreeNode(initial_opportunity));
 
-  if (opt_leader_point) {
-    const NGExclusion leader_exclusion =
-        ToLeaderExclusion(Offset(), opt_leader_point.value());
-    InsertExclusion(MutableOpportunityTreeRoot(), &leader_exclusion,
-                    opportunities_);
-  }
-
   for (const auto& exclusion : exclusions->storage) {
     InsertExclusion(MutableOpportunityTreeRoot(), exclusion.get(),
                     opportunities_);
   }
   CollectAllOpportunities(OpportunityTreeRoot(), opportunities_);
   std::sort(opportunities_.begin(), opportunities_.end(),
             &CompareNGLayoutOpportunitesByStartPoint);
 
   opportunity_iter_ = opportunities_.begin();
 }
 
 const NGLayoutOpportunity NGLayoutOpportunityIterator::Next() {
   if (opportunity_iter_ == opportunities_.end())
     return NGLayoutOpportunity();
   auto* opportunity = opportunity_iter_;
   opportunity_iter_++;
   return NGLayoutOpportunity(*opportunity);
 }
 
 #ifndef NDEBUG
 void NGLayoutOpportunityIterator::ShowLayoutOpportunityTree() const {
   StringBuilder string_builder;
   string_builder.Append("\n.:: LayoutOpportunity Tree ::.\n\nRoot Node: ");
   AppendNodeToString(opportunity_tree_root_.get(), &string_builder);
   fprintf(stderr, "%s\n", string_builder.ToString().Utf8().Data());
 }
 #endif
 
 }  // namespace blink