Move NGLayoutOpportunityTreeNode off Oilpan

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 "wtf/NonCopyingSort.h"
 #include "wtf/text/StringBuilder.h"
 
@@ skipping 14 matching lines @@
 
   StringBuilder indent_builder;
   for (unsigned i = 0; i < indent; i++)
     indent_builder.append("\t");
 
   if (node->IsLeafNode())
     return;
 
   string_builder->append(indent_builder.toString());
   string_builder->append("Left:\t");
-  AppendNodeToString(node->left, string_builder, indent + 2);
+  AppendNodeToString(node->left.get(), string_builder, indent + 2);
   string_builder->append(indent_builder.toString());
   string_builder->append("Right:\t");
-  AppendNodeToString(node->right, string_builder, indent + 2);
+  AppendNodeToString(node->right.get(), string_builder, indent + 2);
   string_builder->append(indent_builder.toString());
   string_builder->append("Bottom:\t");
-  AppendNodeToString(node->bottom, string_builder, indent + 2);
+  AppendNodeToString(node->bottom.get(), string_builder, indent + 2);
 }
 
 // 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);
+  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(
     const NGConstraintSpace& space,
     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 = space.AvailableSize().block_size >= 0
@@ skipping 90 matching lines @@
     opportunity.offset.block_offset = parent_opportunity.BlockStartOffset();
     opportunity.size.inline_size = right_opportunity_inline_size;
     opportunity.size.block_size = parent_opportunity.BlockSize();
     return new NGLayoutOpportunityTreeNode(opportunity);
   }
   return nullptr;
 }
 
 void SplitNGLayoutOpportunityTreeNode(const NGLogicalRect& rect,
                                       NGLayoutOpportunityTreeNode* node) {
-  node->left = CreateLeftNGLayoutOpportunityTreeNode(node, rect);
-  node->right = CreateRightNGLayoutOpportunityTreeNode(node, rect);
-  node->bottom = CreateBottomNGLayoutOpportunityTreeNode(node, rect);
+  node->left.reset(CreateLeftNGLayoutOpportunityTreeNode(node, rect));
+  node->right.reset(CreateRightNGLayoutOpportunityTreeNode(node, rect));
+  node->bottom.reset(CreateBottomNGLayoutOpportunityTreeNode(node, rect));
 }
 
 // Gets/Creates the "TOP" positioned constraint space by splitting
 // the parent node with the exclusion.
 //
 // @param parent_opportunity Parent opportunity that is being split.
 // @param exclusion Exclusion existed in the parent node constraint space.
 // @return New node or nullptr if the new block size == 0.
 NGLayoutOpportunity GetTopSpace(const NGLayoutOpportunity& parent_opportunity,
                                 const NGLogicalRect& exclusion) {
@@ skipping 38 matching lines @@
     node->combined_exclusion = WTF::makeUnique<NGExclusion>(*exclusion);
     return;
   }
 
   DCHECK(!node->exclusions.isEmpty());
 
   if (node->combined_exclusion->MaybeCombineWith(*exclusion)) {
     SplitNGLayoutOpportunityTreeNode(node->combined_exclusion->rect, node);
     node->exclusions.push_back(exclusion);
   } else {
-    InsertExclusion(node->left, exclusion, opportunities);
-    InsertExclusion(node->bottom, exclusion, opportunities);
-    InsertExclusion(node->right, exclusion, opportunities);
+    InsertExclusion(node->left.get(), exclusion, opportunities);
+    InsertExclusion(node->bottom.get(), exclusion, opportunities);
+    InsertExclusion(node->right.get(), exclusion, opportunities);
   }
 }
 
 // Compares exclusions by their top position.
 bool CompareNGExclusionsByTopAsc(
     const std::unique_ptr<const NGExclusion>& lhs,
     const std::unique_ptr<const NGExclusion>& rhs) {
   return rhs->rect.offset.block_offset > lhs->rect.offset.block_offset;
 }
 
@@ skipping 43 matching lines @@
     : 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();
   DCHECK(std::is_sorted(exclusions->storage.begin(), exclusions->storage.end(),
                         &CompareNGExclusionsByTopAsc))
       << "Exclusions are expected to be sorted by TOP";
 
   NGLayoutOpportunity initial_opportunity =
       CreateLayoutOpportunityFromConstraintSpace(*constraint_space_, Offset());
-  opportunity_tree_root_ = new NGLayoutOpportunityTreeNode(initial_opportunity);
+  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(),
@@ skipping 17 matching lines @@
 #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