fix leak in RTree::Remove()

ui/gfx/geometry/r_tree.cc

 // Copyright 2014 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 "ui/gfx/geometry/r_tree.h"
 
 #include <algorithm>
 #include <limits>
 
 #include "base/logging.h"
@@ skipping 609 matching lines @@
   Node* node = it->second;
   // Remove this node from the map.
   record_map_.erase(it);
   // Now remove it from the RTree.
   RemoveNode(node);
   delete node;
 
   // Lastly check the root. If it has only one non-leaf child, delete it and
   // replace it with its child.
   if (root_->count() == 1 && root_->level() > 0) {
-    scoped_ptr<Node> new_root(root_->RemoveAndReturnLastChild());
-    root_.swap(new_root);
+    root_ = root_->RemoveAndReturnLastChild();
   }
 }
 
 void RTree::Query(const Rect& query_rect,
                   base::hash_set<intptr_t>* matches_out) const {
   root_->Query(query_rect, matches_out);
 }
 
 void RTree::Clear() {
   record_map_.clear();
@@ skipping 67 matching lines @@
   // parent.
   DCHECK(parent);
   // Should always be a leaf that had the record.
   DCHECK_EQ(parent->level(), 0);
   ScopedVector<Node> orphans;
   Node* child = node;
 
   // Traverse up the tree, removing the child from each parent and deleting
   // parent nodes, until we either encounter the root of the tree or a parent
   // that still has sufficient children.
-  while (parent && parent->RemoveChild(child, &orphans) < min_children_) {
-    if (child != node) {
+  while (parent) {
+    size_t children_remaining = parent->RemoveChild(child, &orphans);
+    if (child != node)
       delete child;
-    }
+
+    if (children_remaining >= min_children_)
+      break;
+
     child = parent;
     parent = parent->parent();
   }
 
   // If we stopped deleting nodes up the tree before encountering the root,
   // we'll need to fix up the bounds from the first parent we didn't delete
   // up to the root.
   if (parent) {
     parent->RecomputeBounds();
   }
 
   // Now re-insert each of the orphaned nodes back into the tree.
   for (size_t i = 0; i < orphans.size(); ++i) {
     int starting_level = -1;
     InsertNode(orphans[i], &starting_level);
   }
 
   // Clear out the orphans list without deleting any of the children, as they
   // have been re-inserted into the tree.
   orphans.weak_clear();
 }
 
 }  // namespace gfx