Add support of leader_point in NGLayoutOpportunityIterator.

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_physical_constraint_space.h"
 #include "core/layout/ng/ng_units.h"
 #include "wtf/NonCopyingSort.h"
 
@@ skipping 132 matching lines @@
     opportunity.size.block_size = top_opportunity_block_size;
     return opportunity;
   }
   return NGLayoutOpportunity();
 }
 
 // Inserts the exclusion into the Layout Opportunity tree.
 void InsertExclusion(NGLayoutOpportunityTreeNode* node,
                      const NGLogicalRect* exclusion,
                      NGLayoutOpportunities& opportunities) {
+  // Base case: size of the exclusion is empty.
+  if (exclusion->size.IsEmpty())
+    return;
+
   // Base case: there is no node.
   if (!node)
     return;
 
   // Base case: exclusion is not in the node's constraint space.
   if (!exclusion->IsContained(node->opportunity))
     return;
 
   if (node->exclusion) {
     InsertExclusion(node->left, exclusion, opportunities);
@@ skipping 40 matching lines @@
     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;
 }
 
+void RunPreconditionChecks(const NGConstraintSpace& space,
+                           const NGLogicalOffset& origin_point,
+                           const NGLogicalOffset& leader_point) {
+  DCHECK_GE(origin_point, space.Offset())
+      << "Origin point" << origin_point
+      << " should lay below the constraint space's offset " << space.Offset();
+
+  DCHECK_GE(leader_point, space.Offset())
+      << "Leader point" << leader_point
+      << " should lay below the constraint space's offset " << space.Offset();
+}
+
+NGLogicalRect 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;
+
+  NGLogicalRect leader_exclusion;
+  leader_exclusion.offset = origin_point;
+  leader_exclusion.size = {inline_size, block_size};
+  return leader_exclusion;
+}
+
 }  // namespace
 
 NGLayoutOpportunityIterator::NGLayoutOpportunityIterator(
     NGConstraintSpace* space,
-    const NGLogicalOffset origin_point,
-    const NGLogicalOffset leader_point)
-    : constraint_space_(space), leader_point_(leader_point) {
+    const NGLogicalOffset& origin_point,
+    const NGLogicalOffset& leader_point)
+    : constraint_space_(space) {
+  RunPreconditionChecks(*space, origin_point, leader_point);
+
   // TODO(chrome-layout-team): Combine exclusions that shadow each other.
   auto& exclusions = constraint_space_->PhysicalSpace()->Exclusions();
   DCHECK(std::is_sorted(exclusions.begin(), exclusions.end(),
                         &CompareNGExclusionsByTopAsc))
       << "Exclusions are expected to be sorted by TOP";
 
   NGLayoutOpportunity initial_opportunity =
       CreateLayoutOpportunityFromConstraintSpace(*space, origin_point);
   opportunity_tree_root_ = new NGLayoutOpportunityTreeNode(initial_opportunity);
 
+  const NGLogicalRect leader_exclusion =
+      ToLeaderExclusion(origin_point, leader_point);
+  InsertExclusion(MutableOpportunityTreeRoot(), &leader_exclusion,
+                  opportunities_);
+
   for (const auto& exclusion : exclusions) {
     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);
 }
 
 }  // namespace blink