[LayoutNG] Remove derived constraint spaces from opportunity iterator.

third_party/WebKit/Source/core/layout/ng/ng_layout_opportunity_tree_node.h

 // 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.
 
 #ifndef NGLayoutOpportunityTreeNode_h
 #define NGLayoutOpportunityTreeNode_h
 
 #include "platform/heap/Handle.h"
 #include "core/layout/ng/ng_units.h"
 
 namespace blink {
 
 // 3 node R-Tree that represents available space(left, bottom, right) or
 // layout opportunity after the parent spatial rectangle is split by the
 // exclusion rectangle.
 struct NGLayoutOpportunityTreeNode
     : public GarbageCollected<NGLayoutOpportunityTreeNode> {
   // Default constructor.
   // Creates a Layout Opportunity tree node that is limited by it's own edge
   // from above.
-  // @param space Constraint space associated with this node.
-  NGLayoutOpportunityTreeNode(const NGConstraintSpace* space) : space(space) {
-    exclusion_edge.start = space->Offset().inline_offset;
-    exclusion_edge.end = exclusion_edge.start + space->Size().inline_size;
+  // @param layout_area The layout area for this node.
+  NGLayoutOpportunityTreeNode(const NGLogicalRect layout_area)
+      : layout_area(layout_area) {
+    exclusion_edge.start = layout_area.offset.inline_offset;
+    exclusion_edge.end = exclusion_edge.start + layout_area.size.inline_size;
   }
 
   // Constructor that creates a node with explicitly set exclusion edge.
   // @param space Constraint space associated with this node.
   // @param exclusion_edge Edge that limits this node's space from above.
-  NGLayoutOpportunityTreeNode(NGConstraintSpace* space, NGEdge exclusion_edge)
-      : space(space), exclusion_edge(exclusion_edge) {}
-
-  // Constraint space that is associated with this node.
-  Member<const NGConstraintSpace> space;
+  NGLayoutOpportunityTreeNode(const NGLogicalRect layout_area,
+                              NGEdge exclusion_edge)
+      : layout_area(layout_area), exclusion_edge(exclusion_edge) {}
 
   // Children of the node.
   Member<NGLayoutOpportunityTreeNode> left;
   Member<NGLayoutOpportunityTreeNode> bottom;
   Member<NGLayoutOpportunityTreeNode> right;
 
-  // Exclusion that split apart this layout opportunity.
+  // Exclusion that split apart this layout area.
   Member<const NGExclusion> exclusion;
 
-  // Edge that limits this layout opportunity from above.
+  // The top layout area associated with this node.
+  NGLogicalRect layout_area;

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

I renamed this area, as if it has an exclusion it really isn't a layout
opportunity? More than happy to rename back :)

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

how about this

struct NGLayoutOpportunityTreeNode(const NGLayoutOpportunity* opportunity) :
layout_area(opportunity) {}

NGLayoutOpportunity* Opportunity() {
  if (IsLeafNode()) return layout_area_.get();
  return nullptr;
}

private:
  std::unique_ptr<NGLayoutOpportunity> layout_area_;

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

Renamed back to opportunity for now.

+
+  // Edge that limits this layout area from above.
   NGEdge exclusion_edge;
 
   // Whether this node is a leaf node.
-  // The node is a leaf if it doen't have an exclusion that splits it apart.
+  // The node is a leaf if it doesn't have an exclusion that splits it apart.
   bool IsLeafNode() const { return !exclusion; }
 
   DEFINE_INLINE_TRACE() {
-    visitor->trace(space);
     visitor->trace(left);
     visitor->trace(bottom);
     visitor->trace(right);
     visitor->trace(exclusion);
   }
 };
 
 }  // namespace blink
 #endif  // NGLayoutOpportunityTreeNode_h