Fix object ownership in ui/base/models.

ui/views/controls/tree/tree_view.cc

 // Copyright (c) 2012 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/views/controls/tree/tree_view.h"
 
 #include <algorithm>
 
 #include "base/i18n/rtl.h"
+#include "base/memory/ptr_util.h"
 #include "base/message_loop/message_loop.h"
 #include "ui/accessibility/ax_view_state.h"
 #include "ui/base/ime/input_method.h"
 #include "ui/base/resource/resource_bundle.h"
 #include "ui/events/event.h"
 #include "ui/events/keycodes/keyboard_codes.h"
 #include "ui/gfx/canvas.h"
 #include "ui/gfx/geometry/rect.h"
 #include "ui/gfx/geometry/rect_conversions.h"
 #include "ui/gfx/image/image.h"
@@ skipping 109 matching lines @@
 
   CancelEdit();
 
   model_ = model;
   selected_node_ = NULL;
   icons_.clear();
   if (model_) {
     model_->AddObserver(this);
     model_->GetIcons(&icons_);
 
-    root_.RemoveAll();
+    root_.DeleteAll();
     ConfigureInternalNode(model_->GetRoot(), &root_);
     LoadChildren(&root_);
     root_.set_is_expanded(true);
     if (root_shown_)
       selected_node_ = &root_;
     else if (root_.child_count())
       selected_node_ = root_.GetChild(0);
   }
   DrawnNodesChanged();
 }
@@ skipping 272 matching lines @@
 
 void TreeView::TreeNodesAdded(TreeModel* model,
                               TreeModelNode* parent,
                               int start,
                               int count) {
   InternalNode* parent_node =
       GetInternalNodeForModelNode(parent, DONT_CREATE_IF_NOT_LOADED);
   if (!parent_node || !parent_node->loaded_children())
     return;
   for (int i = 0; i < count; ++i) {
-    InternalNode* child = new InternalNode;
-    ConfigureInternalNode(model_->GetChild(parent, start + i), child);
-    parent_node->Add(child, start + i);
+    std::unique_ptr<InternalNode> child = base::MakeUnique<InternalNode>();
+    ConfigureInternalNode(model_->GetChild(parent, start + i), child.get());
+    parent_node->Add(std::move(child), start + i);
   }
   if (IsExpanded(parent))
     DrawnNodesChanged();
 }
 
 void TreeView::TreeNodesRemoved(TreeModel* model,
                                 TreeModelNode* parent,
                                 int start,
                                 int count) {
   InternalNode* parent_node =
       GetInternalNodeForModelNode(parent, DONT_CREATE_IF_NOT_LOADED);
   if (!parent_node || !parent_node->loaded_children())
     return;
   bool reset_selection = false;
   for (int i = 0; i < count; ++i) {
     InternalNode* child_removing = parent_node->GetChild(start);
     if (selected_node_ && selected_node_->HasAncestor(child_removing))
       reset_selection = true;
-    delete parent_node->Remove(child_removing);
+    parent_node->Remove(child_removing);
   }
   if (reset_selection) {
     // selected_node_ is no longer valid (at the time we enter this function
     // its model_node() is likely deleted). Explicitly NULL out the field
     // rather than invoking SetSelectedNode() otherwise, we'll try and use a
     // deleted value.
     selected_node_ = NULL;
     TreeModelNode* to_select = parent;
     if (parent == root_.model_node() && !root_shown_) {
       to_select = model_->GetChildCount(parent) > 0 ?
@@ skipping 196 matching lines @@
   }
   return true;
 }
 
 void TreeView::LoadChildren(InternalNode* node) {
   DCHECK_EQ(0, node->child_count());
   DCHECK(!node->loaded_children());
   node->set_loaded_children(true);
   for (int i = 0, child_count = model_->GetChildCount(node->model_node());
        i < child_count; ++i) {
-    InternalNode* child = new InternalNode;
-    ConfigureInternalNode(model_->GetChild(node->model_node(), i), child);
-    node->Add(child, node->child_count());
+    std::unique_ptr<InternalNode> child = base::MakeUnique<InternalNode>();
+    ConfigureInternalNode(model_->GetChild(node->model_node(), i), child.get());
+    node->Add(std::move(child), node->child_count());
   }
 }
 
 void TreeView::ConfigureInternalNode(TreeModelNode* model_node,
                                      InternalNode* node) {
   node->Reset(model_node);
   UpdateNodeTextWidth(node);
 }
 
 void TreeView::UpdateNodeTextWidth(InternalNode* node) {
@@ skipping 406 matching lines @@
   if (!is_expanded_)
     return max_width;
   for (int i = 0; i < child_count(); ++i) {
     max_width = std::max(max_width,
                          GetChild(i)->GetMaxWidth(indent, depth + 1));
   }
   return max_width;
 }
 
 }  // namespace views