Fix object ownership in ui/base/models.

chrome/browser/ui/views/bookmarks/bookmark_editor_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 "chrome/browser/ui/views/bookmarks/bookmark_editor_view.h"
 
 #include <string>
 
 #include "base/logging.h"
+#include "base/memory/ptr_util.h"
 #include "base/strings/string_util.h"
 #include "base/strings/utf_string_conversions.h"
 #include "chrome/browser/bookmarks/bookmark_model_factory.h"
 #include "chrome/browser/profiles/profile.h"
 #include "chrome/browser/ui/bookmarks/bookmark_utils.h"
 #include "chrome/browser/ui/bookmarks/bookmark_utils_desktop.h"
 #include "chrome/browser/ui/browser_dialogs.h"
 #include "chrome/grit/generated_resources.h"
 #include "chrome/grit/locale_settings.h"
 #include "components/bookmarks/browser/bookmark_model.h"
@@ skipping 387 matching lines @@
       UserInputChanged();
     return;
   }
 
   new_folder_button_->SetEnabled(true);
 
   // Do this first, otherwise when we invoke SetModel with the real one
   // tree_view will try to invoke something on the model we just deleted.
   tree_view_->SetModel(NULL);
 
-  EditorNode* root_node = CreateRootNode();
-  tree_model_.reset(new EditorTreeModel(root_node));
+  tree_model_.reset(new EditorTreeModel(CreateRootNode()));
 
   tree_view_->SetModel(tree_model_.get());
   tree_view_->SetController(this);
 
   context_menu_runner_.reset();
 
   if (parent())
     ExpandAndSelect();
 }
 
@@ skipping 22 matching lines @@
   if (!parent) {
     NOTREACHED();
     return;
   }
 
   tree_view_->StartEditing(AddNewFolder(parent));
 }
 
 BookmarkEditorView::EditorNode* BookmarkEditorView::AddNewFolder(
     EditorNode* parent) {
-  EditorNode* new_node = new EditorNode(
-      l10n_util::GetStringUTF16(IDS_BOOKMARK_EDITOR_NEW_FOLDER_NAME), 0);
-  // |new_node| is now owned by |parent|.
-  tree_model_->Add(parent, new_node, parent->child_count());
-  return new_node;
+  return tree_model_->Add(
+      parent,
+      base::MakeUnique<EditorNode>(
+          l10n_util::GetStringUTF16(IDS_BOOKMARK_EDITOR_NEW_FOLDER_NAME), 0),
+      parent->child_count());
 }
 
 void BookmarkEditorView::ExpandAndSelect() {
   BookmarkExpandedStateTracker::Nodes expanded_nodes =
       bb_model_->expanded_state_tracker()->GetExpandedNodes();
   for (BookmarkExpandedStateTracker::Nodes::const_iterator i(
        expanded_nodes.begin()); i != expanded_nodes.end(); ++i) {
     EditorNode* editor_node =
         FindNodeWithID(tree_model_->GetRoot(), (*i)->id());
     if (editor_node)
       tree_view_->Expand(editor_node);
   }
 
   const BookmarkNode* to_select = parent_;
   if (details_.type == EditDetails::EXISTING_NODE)
     to_select = details_.existing_node->parent();
   int64_t folder_id_to_select = to_select->id();
   EditorNode* b_node =
       FindNodeWithID(tree_model_->GetRoot(), folder_id_to_select);
   if (!b_node)
     b_node = tree_model_->GetRoot()->GetChild(0);  // Bookmark bar node.
 
   tree_view_->SetSelectedNode(b_node);
 }
 
-BookmarkEditorView::EditorNode* BookmarkEditorView::CreateRootNode() {
-  EditorNode* root_node = new EditorNode(base::string16(), 0);
+std::unique_ptr<BookmarkEditorView::EditorNode>
+BookmarkEditorView::CreateRootNode() {
+  std::unique_ptr<EditorNode> root_node =
+      base::MakeUnique<EditorNode>(base::string16(), 0);
   const BookmarkNode* bb_root_node = bb_model_->root_node();
-  CreateNodes(bb_root_node, root_node);
+  CreateNodes(bb_root_node, root_node.get());
   DCHECK(root_node->child_count() >= 2 && root_node->child_count() <= 4);
   DCHECK_EQ(BookmarkNode::BOOKMARK_BAR, bb_root_node->GetChild(0)->type());
   DCHECK_EQ(BookmarkNode::OTHER_NODE, bb_root_node->GetChild(1)->type());
   if (root_node->child_count() >= 3)
     DCHECK_EQ(BookmarkNode::MOBILE, bb_root_node->GetChild(2)->type());
   return root_node;
 }
 
 void BookmarkEditorView::CreateNodes(const BookmarkNode* bb_node,
                                      BookmarkEditorView::EditorNode* b_node) {
   for (int i = 0; i < bb_node->child_count(); ++i) {
     const BookmarkNode* child_bb_node = bb_node->GetChild(i);
     if (child_bb_node->IsVisible() && child_bb_node->is_folder() &&
         bb_model_->client()->CanBeEditedByUser(child_bb_node)) {
-      EditorNode* new_b_node = new EditorNode(child_bb_node->GetTitle(),
-                                              child_bb_node->id());
-      b_node->Add(new_b_node, b_node->child_count());
+      EditorNode* new_b_node =
+          b_node->Add(base::MakeUnique<EditorNode>(child_bb_node->GetTitle(),
+                                                   child_bb_node->id()),
+                      b_node->child_count());
       CreateNodes(child_bb_node, new_b_node);
     }
   }
 }
 
 BookmarkEditorView::EditorNode* BookmarkEditorView::FindNodeWithID(
     BookmarkEditorView::EditorNode* node,
     int64_t id) {
   if (node->value == id)
     return node;
@@ skipping 128 matching lines @@
                              Profile* profile,
                              const BookmarkEditor::EditDetails& details,
                              BookmarkEditor::Configuration configuration) {
   DCHECK(profile);
   BookmarkEditorView* editor = new BookmarkEditorView(
       profile, details.parent_node, details, configuration);
   editor->Show(parent_window);
 }
 
 }  // namespace chrome