[LayoutNG] Remove derived constraint spaces from opportunity iterator.

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"
 
 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.append(node->space);
+    opportunities.append(node->layout_area);
   CollectAllOpportunities(node->left, opportunities);
   CollectAllOpportunities(node->bottom, opportunities);
   CollectAllOpportunities(node->right, opportunities);
 }
 
 // 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);
 }
 
 // Whether the exclusion is out of bounds of the LayoutNG constraint space.
-bool IsExclusionWithinSpace(const NGConstraintSpace& space,
+bool IsExclusionWithinSpace(const NGLogicalRect& layout_area,

[Gleb Lanbin, 2016/10/21 21:06:58]

let's stick with "layout opportunity" name? i.e.
bool IsExclusionWithinLayoutOpportunity(const NGLayoutOpportunity& opportunity,
..

[ikilpatrick, 2016/10/21 21:45:27]

Done.

                             const NGExclusion& exclusion) {
-  LayoutUnit left = space.Offset().inline_offset;
-  LayoutUnit top = space.Offset().block_offset;
-  LayoutUnit right = left + space.Size().inline_size;
-  LayoutUnit bottom = top + space.Size().block_size;
+  LayoutUnit left = layout_area.offset.inline_offset;
+  LayoutUnit top = layout_area.offset.block_offset;
+  LayoutUnit right = left + layout_area.size.inline_size;
+  LayoutUnit bottom = top + layout_area.size.block_size;
 
   return !(exclusion.Right() <= left || exclusion.Bottom() <= top ||
            exclusion.Left() >= right || exclusion.Top() >= bottom);
 }
 
 // Creates the *BOTTOM* positioned Layout Opportunity tree node by splitting
 // the parent node with the exclusion.
 //
 // @param parent_node Node that needs to be split.
 // @param exclusion Exclusion existed in the parent node constraint space.
 // @return New node or nullptr if the new block size == 0.
 NGLayoutOpportunityTreeNode* CreateBottomNGLayoutOpportunityTreeNode(
     const NGLayoutOpportunityTreeNode* parent_node,
     const NGExclusion& exclusion) {
-  const NGConstraintSpace& parent_space = *parent_node->space;
-  LayoutUnit left = parent_space.Offset().inline_offset;
+  const NGLogicalRect& parent_layout_area = parent_node->layout_area;

[Gleb Lanbin, 2016/10/21 21:06:58]

const NGLayoutOpportunity& parent_opportunity 

[ikilpatrick, 2016/10/21 21:45:27]

Done.

+  LayoutUnit left = parent_layout_area.offset.inline_offset;
   LayoutUnit top = exclusion.Bottom();
-  LayoutUnit right = left + parent_space.Size().inline_size;
-  LayoutUnit bottom =
-      parent_space.Offset().block_offset + parent_space.Size().block_size;
+  LayoutUnit right = left + parent_layout_area.size.inline_size;
+  LayoutUnit bottom = parent_layout_area.offset.block_offset +
+                      parent_layout_area.size.block_size;
 
   NGEdge exclusion_edge = {exclusion.Left(), exclusion.Right()};
   LayoutUnit block_size = bottom - top;
   if (block_size > 0) {
-    auto* space =
-        new NGConstraintSpace(parent_space, NGLogicalOffset(left, top),
-                              NGLogicalSize(right - left, block_size));
-    return new NGLayoutOpportunityTreeNode(space, exclusion_edge);
+    NGLogicalRect layout_area(left, top, right - left, block_size);
+    return new NGLayoutOpportunityTreeNode(layout_area, exclusion_edge);
   }
   return nullptr;
 }
 
 // Creates the *LEFT* positioned Layout Opportunity tree node by splitting
 // the parent node with the exclusion.
 //
 // @param parent_node Node that needs to be split.
 // @param exclusion Exclusion existed in the parent node constraint space.
 // @return New node or nullptr if the new inline size == 0 or the parent's
 // exclusion edge doesn't limit the new node's constraint space.
 NGLayoutOpportunityTreeNode* CreateLeftNGLayoutOpportunityTreeNode(
     const NGLayoutOpportunityTreeNode* parent_node,
     const NGExclusion& exclusion) {
-  const NGConstraintSpace& parent_space = *parent_node->space;
-  LayoutUnit left = parent_space.Offset().inline_offset;
-  LayoutUnit top = parent_space.Offset().block_offset;
+  const NGLogicalRect& parent_layout_area = parent_node->layout_area;
+  LayoutUnit left = parent_layout_area.offset.inline_offset;
+  LayoutUnit top = parent_layout_area.offset.block_offset;
   LayoutUnit right = exclusion.Left();
-  LayoutUnit bottom = top + parent_space.Size().block_size;
+  LayoutUnit bottom = top + parent_layout_area.size.block_size;
 
   NGEdge node_edge = {left, right};
   LayoutUnit inline_size = right - left;
   if (inline_size > 0 &&
       IsOverlapping(parent_node->exclusion_edge, node_edge)) {
-    auto* space =
-        new NGConstraintSpace(parent_space, NGLogicalOffset(left, top),
-                              NGLogicalSize(inline_size, bottom - top));
-    return new NGLayoutOpportunityTreeNode(space);
+    NGLogicalRect layout_area(left, top, inline_size, bottom - top);
+    return new NGLayoutOpportunityTreeNode(layout_area);
   }
   return nullptr;
 }
 
 // Creates the *RIGHT* positioned Layout Opportunity tree node by splitting
 // the parent node with the exclusion.
 //
 // @param parent_node Node that needs to be split.
 // @param exclusion Exclusion existed in the parent node constraint space.
 // @return New node or nullptr if the new inline size == 0 or the parent's
 // exclusion edge doesn't limit the new node's constraint space.
 NGLayoutOpportunityTreeNode* CreateRightNGLayoutOpportunityTreeNode(
     const NGLayoutOpportunityTreeNode* parent_node,
     const NGExclusion& exclusion) {
-  const NGConstraintSpace& parent_space = *parent_node->space;
+  const NGLogicalRect& parent_layout_area = parent_node->layout_area;
   LayoutUnit left = exclusion.Right();
-  LayoutUnit top = parent_space.Offset().block_offset;
-  LayoutUnit right =
-      parent_space.Offset().inline_offset + parent_space.Size().inline_size;
-  LayoutUnit bottom = top + parent_space.Size().block_size;
+  LayoutUnit top = parent_layout_area.offset.block_offset;
+  LayoutUnit right = parent_layout_area.offset.inline_offset +
+                     parent_layout_area.size.inline_size;
+  LayoutUnit bottom = top + parent_layout_area.size.block_size;
 
   NGEdge node_edge = {left, right};
   LayoutUnit inline_size = right - left;
   if (inline_size > 0 &&
       IsOverlapping(parent_node->exclusion_edge, node_edge)) {
-    auto* space =
-        new NGConstraintSpace(parent_space, NGLogicalOffset(left, top),
-                              NGLogicalSize(inline_size, bottom - top));
-    return new NGLayoutOpportunityTreeNode(space);
+    NGLogicalRect layout_area(left, top, inline_size, bottom - top);
+    return new NGLayoutOpportunityTreeNode(layout_area);
   }
   return nullptr;
 }
 
 // Gets/Creates the "TOP" positioned constraint space by splitting
 // the parent node with the exclusion.
 //
 // @param parent_node Node that needs to be split.
 // @param exclusion Exclusion existed in the parent node constraint space.
 // @return New node or nullptr if the new block size == 0.
-NGConstraintSpace* GetTopSpace(const NGConstraintSpace& space,
-                               const NGExclusion& exclusion) {
-  LayoutUnit left = space.Offset().inline_offset;
-  LayoutUnit top = space.Offset().block_offset;
-  LayoutUnit right = left + space.Size().inline_size;
+NGLogicalRect GetTopSpace(const NGLogicalRect& rect,
+                          const NGExclusion& exclusion) {
+  LayoutUnit left = rect.offset.inline_offset;
+  LayoutUnit top = rect.offset.block_offset;
+  LayoutUnit right = left + rect.size.inline_size;
   LayoutUnit bottom = exclusion.Top();
 
   LayoutUnit block_size = bottom - top;
   if (block_size > 0)
-    return new NGConstraintSpace(space, NGLogicalOffset(left, top),
-                                 NGLogicalSize(right - left, block_size));
-  return nullptr;
+    return NGLogicalRect(left, top, right - left, block_size);
+
+  return NGLogicalRect();
 }
 
 // Inserts the exclusion into the Layout Opportunity tree.
 void InsertExclusion(NGLayoutOpportunityTreeNode* node,
                      const NGExclusion* exclusion,
                      NGLayoutOpportunities& opportunities) {
   // Base case: exclusion is not in the node's constraint space.
-  if (!IsExclusionWithinSpace(*node->space, *exclusion))
+  if (!IsExclusionWithinSpace(node->layout_area, *exclusion))
     return;
 
   if (node->exclusion) {
     InsertExclusion(node->left, exclusion, opportunities);
     InsertExclusion(node->bottom, exclusion, opportunities);
     InsertExclusion(node->right, exclusion, opportunities);
     return;
   }
 
   // Split the current node.
   node->left = CreateLeftNGLayoutOpportunityTreeNode(node, *exclusion);
   node->right = CreateRightNGLayoutOpportunityTreeNode(node, *exclusion);
   node->bottom = CreateBottomNGLayoutOpportunityTreeNode(node, *exclusion);
 
-  if (auto* topSpace = GetTopSpace(*node->space, *exclusion))
-    opportunities.append(topSpace);
+  NGLogicalRect top_layout_opp = GetTopSpace(node->layout_area, *exclusion);
+  if (!top_layout_opp.IsEmpty())
+    opportunities.append(top_layout_opp);
+
   node->exclusion = exclusion;
 }
 
 // Compares exclusions by their top position.
 bool CompareNGExclusionsByTopAsc(const Member<const NGExclusion>& lhs,
                                  const Member<const NGExclusion>& rhs) {
   return rhs->Top() > lhs->Top();
 }
 
 // Compares Layout Opportunities by Start Point.
 // Start point is a TopLeft position from where inline content can potentially
 // start positioning itself.
-bool CompareNGLayoutOpportunitesByStartPoint(
-    const Member<const NGLayoutOpportunity>& lhs,
-    const Member<const NGLayoutOpportunity>& rhs) {
+bool CompareNGLayoutOpportunitesByStartPoint(const NGLogicalRect& lhs,
+                                             const NGLogicalRect& rhs) {
   // sort by TOP.
-  if (rhs->Offset().block_offset > lhs->Offset().block_offset) {
+  if (rhs.offset.block_offset > lhs.offset.block_offset) {
     return true;
   }
-  if (rhs->Offset().block_offset < lhs->Offset().block_offset) {
+  if (rhs.offset.block_offset < lhs.offset.block_offset) {
     return false;
   }
 
   // TOP is the same -> Sort by LEFT
-  if (rhs->Offset().inline_offset > lhs->Offset().inline_offset) {
+  if (rhs.offset.inline_offset > lhs.offset.inline_offset) {
     return true;
   }
-  if (rhs->Offset().inline_offset < lhs->Offset().inline_offset) {
+  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;
+  return rhs.size.inline_size < lhs.size.inline_size;
 }
 
 }  // namespace
 
 NGLayoutOpportunityIterator::NGLayoutOpportunityIterator(
     NGConstraintSpace* space,
     unsigned clear,
     bool for_inline_or_bfc)
     : constraint_space_(space) {
   // 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";
 
-  opportunity_tree_root_ = new NGLayoutOpportunityTreeNode(space);
+  opportunity_tree_root_ = new NGLayoutOpportunityTreeNode(
+      NGLogicalRect(space->Offset().inline_offset, space->Offset().block_offset,
+                    space->Size().inline_size, space->Size().block_size));
+
   for (const auto exclusion : exclusions) {
     InsertExclusion(opportunity_tree_root_, exclusion, opportunities_);
   }
   CollectAllOpportunities(opportunity_tree_root_, opportunities_);
   std::sort(opportunities_.begin(), opportunities_.end(),
             &CompareNGLayoutOpportunitesByStartPoint);
   opportunity_iter_ = opportunities_.begin();
 }
 
-const NGConstraintSpace* NGLayoutOpportunityIterator::Next() {
+const NGLogicalRect* NGLayoutOpportunityIterator::Next() {

[ikilpatrick, 2016/10/21 20:24:10]

?

[Gleb Lanbin, 2016/10/21 21:06:58]

yes, this iterator needs to be fixed. you can just return a copy of 
NGLogicalRect for now.

   if (opportunity_iter_ == opportunities_.end())
     return nullptr;
-  auto* opportunity = opportunity_iter_->get();
+  auto* opportunity = opportunity_iter_;
   opportunity_iter_++;
   return opportunity;
 }
 
 }  // namespace blink