Fix object ownership in ui/base/models.

components/bookmarks/browser/bookmark_model_unittest.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 "components/bookmarks/browser/bookmark_model.h"
 
 #include <stddef.h>
 #include <stdint.h>
 #include <set>
 #include <string>
 #include <utility>
 
 #include "base/base_paths.h"
 #include "base/command_line.h"
 #include "base/compiler_specific.h"
 #include "base/containers/hash_tables.h"
 #include "base/macros.h"
+#include "base/memory/ptr_util.h"
 #include "base/strings/string16.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/strings/string_split.h"
 #include "base/strings/string_util.h"
 #include "base/strings/utf_string_conversions.h"
 #include "base/time/time.h"
 #include "components/bookmarks/browser/bookmark_model_observer.h"
 #include "components/bookmarks/browser/bookmark_undo_delegate.h"
 #include "components/bookmarks/browser/bookmark_utils.h"
 #include "components/bookmarks/test/bookmark_test_helpers.h"
@@ skipping 94 matching lines @@
                       TestNode* parent) {
   while (*index < description.size()) {
     const std::string& element = description[*index];
     (*index)++;
     if (element == "[") {
       // Create a new folder and recurse to add all the children.
       // Folders are given a unique named by way of an ever increasing integer
       // value. The folders need not have a name, but one is assigned to help
       // in debugging.
       static int next_folder_id = 1;
-      TestNode* new_node = new TestNode(base::IntToString16(next_folder_id++),
-                                        BookmarkNode::FOLDER);
-      parent->Add(new_node, parent->child_count());
+      TestNode* new_node = parent->Add(
+          base::MakeUnique<TestNode>(base::IntToString16(next_folder_id++),
+                                     BookmarkNode::FOLDER),
+          parent->child_count());
       PopulateNodeImpl(description, index, new_node);
     } else if (element == "]") {
       // End the current folder.
       return;
     } else {
       // Add a new URL.
 
       // All tokens must be space separated. If there is a [ or ] in the name it
       // likely means a space was forgotten.
       DCHECK(element.find('[') == std::string::npos);
       DCHECK(element.find(']') == std::string::npos);
-      parent->Add(new TestNode(base::UTF8ToUTF16(element), BookmarkNode::URL),
+      parent->Add(base::MakeUnique<TestNode>(base::UTF8ToUTF16(element),
+                                             BookmarkNode::URL),
                   parent->child_count());
     }
   }
 }
 
 // Creates and adds nodes to parent based on description. description consists
 // of the following tokens (all space separated):
 //   [ : creates a new USER_FOLDER node. All elements following the [ until the
 //       next balanced ] is encountered are added as children to the node.
 //   ] : closes the last folder created by [ so that any further nodes are added
@@ skipping 261 matching lines @@
     EXPECT_EQ(grouped_changes_beginning_count,
               grouped_changes_beginning_count_);
     EXPECT_EQ(grouped_changes_ended_count, grouped_changes_ended_count_);
   }
 
   int AllNodesRemovedObserverCount() const { return all_bookmarks_removed_; }
 
   BookmarkPermanentNode* ReloadModelWithExtraNode() {
     model_->RemoveObserver(this);
 
-    BookmarkPermanentNode* extra_node = new BookmarkPermanentNode(100);
     BookmarkPermanentNodeList extra_nodes;
-    extra_nodes.push_back(extra_node);
+    extra_nodes.push_back(base::MakeUnique<BookmarkPermanentNode>(100));
+    BookmarkPermanentNode* extra_node = extra_nodes.back().get();
 
     std::unique_ptr<TestBookmarkClient> client(new TestBookmarkClient);
     client->SetExtraNodesToLoad(std::move(extra_nodes));
 
     model_ = TestBookmarkClient::CreateModelWithClient(std::move(client));
     model_->AddObserver(this);
     ClearCounts();
 
     if (model_->root_node()->GetIndexOf(extra_node) == -1)
       ADD_FAILURE();
@@ skipping 569 matching lines @@
 TEST_F(BookmarkModelTest, DISABLED_Sort) {
   // Populate the bookmark bar node with nodes for 'B', 'a', 'd' and 'C'.
   // 'C' and 'a' are folders.
   TestNode bbn;
   PopulateNodeFromString("B [ a ] d [ a ]", &bbn);
   const BookmarkNode* parent = model_->bookmark_bar_node();
   PopulateBookmarkNode(&bbn, model_.get(), parent);
 
   BookmarkNode* child1 = AsMutable(parent->GetChild(1));
   child1->SetTitle(ASCIIToUTF16("a"));
-  delete child1->Remove(child1->GetChild(0));
+  child1->Remove(child1->GetChild(0));
   BookmarkNode* child3 = AsMutable(parent->GetChild(3));
   child3->SetTitle(ASCIIToUTF16("C"));
-  delete child3->Remove(child3->GetChild(0));
+  child3->Remove(child3->GetChild(0));
 
   ClearCounts();
 
   // Sort the children of the bookmark bar node.
   model_->SortChildren(parent);
 
   // Make sure we were notified.
   AssertObserverCount(0, 0, 0, 0, 1, 0, 0, 1, 0);
 
   // Make sure the order matches (remember, 'a' and 'C' are folders and
@@ skipping 360 matching lines @@
     std::set<GURL> changed_page_urls;
     changed_page_urls.insert(kPageURL1);
     model_->OnFaviconsChanged(changed_page_urls, kFaviconURL12);
     ASSERT_EQ(2u, updated_nodes_.size());
     EXPECT_TRUE(WasNodeUpdated(node1));
     EXPECT_TRUE(WasNodeUpdated(node2));
   }
 }
 
 }  // namespace bookmarks