Top down version of algorithm to position margins and floats in LayoutNG

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_units.h"
 #include "wtf/NonCopyingSort.h"
 
 namespace blink {
 namespace {
 
 // Collects all opportunities from leaves of Layout Opportunity spatial tree.
 void CollectAllOpportunities(const NGLayoutOpportunityTreeNode* node,
                              NGLayoutOpportunities& opportunities) {
   if (!node)
     return;
   if (node->IsLeafNode())
     opportunities.push_back(node->opportunity);
   CollectAllOpportunities(node->left, opportunities);
   CollectAllOpportunities(node->bottom, opportunities);
   CollectAllOpportunities(node->right, opportunities);
 }
 
 // Creates layout opportunity from the provided space and the origin point.
 NGLayoutOpportunity CreateLayoutOpportunityFromConstraintSpace(
     const NGConstraintSpace& space,
     const NGLogicalOffset& origin_point) {
   NGLayoutOpportunity opportunity;
-  opportunity.offset = space.Offset();
-  opportunity.size = space.AvailableSize();
+  // TODO(glebl): Perhaps fix other methods (e.g IsContained) instead of using
+  // INT_MAX here.
+  opportunity.size.block_size = space.AvailableSize().block_size >= 0
+                                    ? space.AvailableSize().block_size
+                                    : LayoutUnit(INT_MAX);
+  opportunity.size.inline_size = space.AvailableSize().inline_size >= 0
+                                     ? space.AvailableSize().inline_size
+                                     : LayoutUnit(INT_MAX);
 
   // adjust to the origin_point.
   opportunity.offset += origin_point;
-  opportunity.size.inline_size -= origin_point.inline_offset;
-  opportunity.size.block_size -= origin_point.block_offset;
   return opportunity;
 }
 
 // Whether 2 edges overlap with each other.
 bool IsOverlapping(const NGEdge& edge1, const NGEdge& edge2) {
   return std::max(edge1.start, edge2.start) <= std::min(edge1.end, edge2.end);
 }
 
 // Creates the *BOTTOM* positioned Layout Opportunity tree node by splitting
 // the parent node with the exclusion.
@@ skipping 159 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 WTF::Optional<NGLogicalOffset>& opt_origin_point,
-    const WTF::Optional<NGLogicalOffset>& opt_leader_point) {
-  if (opt_origin_point) {
-    NGLogicalOffset origin_point = opt_origin_point.value();
-    DCHECK_GE(origin_point, space.Offset())
-        << "Origin point " << origin_point
-        << " should lay below the constraint space's offset " << space.Offset();
-  }
-
-  if (opt_leader_point) {
-    NGLogicalOffset leader_point = opt_leader_point.value();
-    DCHECK_GE(leader_point, space.Offset())
-        << "Leader point " << leader_point
-        << " should lay below the constraint space's offset " << space.Offset();
-  }
-}
-
 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(
     NGConstraintSpace* space,
     const WTF::Optional<NGLogicalOffset>& opt_origin_point,
     const WTF::Optional<NGLogicalOffset>& opt_leader_point)
     : constraint_space_(space) {
-  RunPreconditionChecks(*space, opt_origin_point, opt_leader_point);
-
   // TODO(chrome-layout-team): Combine exclusions that shadow each other.
   auto& exclusions = constraint_space_->Exclusions();
   DCHECK(std::is_sorted(exclusions->storage.begin(), exclusions->storage.end(),
                         &CompareNGExclusionsByTopAsc))
       << "Exclusions are expected to be sorted by TOP";
 
   NGLogicalOffset origin_point =
       opt_origin_point ? opt_origin_point.value() : NGLogicalOffset();
   NGLayoutOpportunity initial_opportunity =
       CreateLayoutOpportunityFromConstraintSpace(*space, origin_point);
@@ skipping 19 matching lines @@
 
 const NGLayoutOpportunity NGLayoutOpportunityIterator::Next() {
   if (opportunity_iter_ == opportunities_.end())
     return NGLayoutOpportunity();
   auto* opportunity = opportunity_iter_;
   opportunity_iter_++;
   return NGLayoutOpportunity(*opportunity);
 }
 
 }  // namespace blink