Stop passing raw pointers to DictionaryValue::Set, part 2

chrome/browser/bookmarks/managed_bookmark_service_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/managed/managed_bookmark_service.h"
 
 #include <memory>
 #include <utility>
 
 #include "base/macros.h"
@@ skipping 25 matching lines @@
 
 class ManagedBookmarkServiceTest : public testing::Test {
  public:
   ManagedBookmarkServiceTest() : managed_(NULL), model_(NULL) {}
   ~ManagedBookmarkServiceTest() override {}
 
   void SetUp() override {
     prefs_ = profile_.GetTestingPrefService();
     ASSERT_FALSE(prefs_->HasPrefPath(bookmarks::prefs::kManagedBookmarks));
 
+    // TODO(crbug.com/697817): Convert SetManagedPrefs to take a unique_ptr.
     prefs_->SetManagedPref(bookmarks::prefs::kManagedBookmarks,
-                           CreateTestTree());
+                           CreateTestTree().release());
     ResetModel();
 
     // The managed node always exists.
     ASSERT_TRUE(managed_->managed_node());
     ASSERT_TRUE(managed_->managed_node()->parent() == model_->root_node());
     EXPECT_NE(-1, model_->root_node()->GetIndexOf(managed_->managed_node()));
   }
 
   void TearDown() override { model_->RemoveObserver(&observer_); }
 
@@ skipping 11 matching lines @@
       const std::string& url) {
     EXPECT_TRUE(GURL(url).is_valid());
     auto dict = base::MakeUnique<base::DictionaryValue>();
     dict->SetString("name", title);
     dict->SetString("url", GURL(url).spec());
     return dict;
   }
 
   static std::unique_ptr<base::DictionaryValue> CreateFolder(
       const std::string& title,
-      base::ListValue* children) {
+      std::unique_ptr<base::ListValue> children) {
     auto dict = base::MakeUnique<base::DictionaryValue>();
     dict->SetString("name", title);
-    dict->Set("children", children);
+    dict->Set("children", std::move(children));
     return dict;
   }
 
-  static base::ListValue* CreateTestTree() {
-    base::ListValue* folder = new base::ListValue();
-    base::ListValue* empty = new base::ListValue();
-    folder->Append(CreateFolder("Empty", empty));
+  static std::unique_ptr<base::ListValue> CreateTestTree() {
+    auto folder = base::MakeUnique<base::ListValue>();
+    folder->Append(CreateFolder("Empty", base::MakeUnique<base::ListValue>()));
     folder->Append(CreateBookmark("Youtube", "http://youtube.com/"));
 
-    base::ListValue* list = new base::ListValue();
+    auto list = base::MakeUnique<base::ListValue>();
     list->Append(CreateBookmark("Google", "http://google.com/"));
-    list->Append(CreateFolder("Folder", folder));
+    list->Append(CreateFolder("Folder", std::move(folder)));
 
     return list;
   }
 
   static std::unique_ptr<base::DictionaryValue> CreateExpectedTree() {
     return CreateFolder(GetManagedFolderTitle(), CreateTestTree());
   }
 
   static std::string GetManagedFolderTitle() {
     return l10n_util::GetStringUTF8(
@@ skipping 71 matching lines @@
 
   // These two nodes should just be swapped.
   const BookmarkNode* parent = managed_->managed_node();
   EXPECT_CALL(observer_, BookmarkNodeMoved(model_, parent, 1, parent, 0));
   prefs_->SetManagedPref(bookmarks::prefs::kManagedBookmarks,
                          updated->DeepCopy());
   Mock::VerifyAndClearExpectations(&observer_);
 
   // Verify the final tree.
   std::unique_ptr<base::DictionaryValue> expected(
-      CreateFolder(GetManagedFolderTitle(), updated.release()));
+      CreateFolder(GetManagedFolderTitle(), std::move(updated)));
   EXPECT_TRUE(NodeMatchesValue(managed_->managed_node(), expected.get()));
 }
 
 TEST_F(ManagedBookmarkServiceTest, RemoveNode) {
   // Remove the Folder.
   std::unique_ptr<base::ListValue> updated(CreateTestTree());
   ASSERT_TRUE(updated->Remove(1, NULL));
 
   const BookmarkNode* parent = managed_->managed_node();
   EXPECT_CALL(observer_, BookmarkNodeRemoved(model_, parent, 1, _, _));
   prefs_->SetManagedPref(bookmarks::prefs::kManagedBookmarks,
                          updated->DeepCopy());
   Mock::VerifyAndClearExpectations(&observer_);
 
   // Verify the final tree.
   std::unique_ptr<base::DictionaryValue> expected(
-      CreateFolder(GetManagedFolderTitle(), updated.release()));
+      CreateFolder(GetManagedFolderTitle(), std::move(updated)));
   EXPECT_TRUE(NodeMatchesValue(managed_->managed_node(), expected.get()));
 }
 
 TEST_F(ManagedBookmarkServiceTest, CreateNewNodes) {
   // Put all the nodes inside another folder.
   std::unique_ptr<base::ListValue> updated(new base::ListValue);
   updated->Append(CreateFolder("Container", CreateTestTree()));
 
   EXPECT_CALL(observer_, BookmarkNodeAdded(model_, _, _)).Times(5);
   // The remaining nodes have been pushed to positions 1 and 2; they'll both be
   // removed when at position 1.
   const BookmarkNode* parent = managed_->managed_node();
   EXPECT_CALL(observer_, BookmarkNodeRemoved(model_, parent, 1, _, _)).Times(2);
   prefs_->SetManagedPref(bookmarks::prefs::kManagedBookmarks,
                          updated->DeepCopy());
   Mock::VerifyAndClearExpectations(&observer_);
 
   // Verify the final tree.
   std::unique_ptr<base::DictionaryValue> expected(
-      CreateFolder(GetManagedFolderTitle(), updated.release()));
+      CreateFolder(GetManagedFolderTitle(), std::move(updated)));
   EXPECT_TRUE(NodeMatchesValue(managed_->managed_node(), expected.get()));
 }
 
 TEST_F(ManagedBookmarkServiceTest, RemoveAllUserBookmarks) {
   // Remove the policy.
   const BookmarkNode* parent = managed_->managed_node();
   EXPECT_CALL(observer_, BookmarkNodeRemoved(model_, parent, 0, _, _)).Times(2);
   prefs_->RemoveManagedPref(bookmarks::prefs::kManagedBookmarks);
   Mock::VerifyAndClearExpectations(&observer_);
 
@@ skipping 56 matching lines @@
   const BookmarkNode* managed_node = managed_->managed_node()->GetChild(0);
   ASSERT_TRUE(managed_node);
 
   std::vector<const BookmarkNode*> nodes;
   EXPECT_FALSE(bookmarks::HasDescendantsOf(nodes, managed_->managed_node()));
   nodes.push_back(user_node);
   EXPECT_FALSE(bookmarks::HasDescendantsOf(nodes, managed_->managed_node()));
   nodes.push_back(managed_node);
   EXPECT_TRUE(bookmarks::HasDescendantsOf(nodes, managed_->managed_node()));
 }