Remove deprecated ListValue::Append(Value*) overload on Linux.

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"
+#include "base/memory/ptr_util.h"
 #include "base/strings/utf_string_conversions.h"
 #include "base/values.h"
 #include "chrome/browser/bookmarks/bookmark_model_factory.h"
 #include "chrome/browser/bookmarks/chrome_bookmark_client.h"
 #include "chrome/browser/bookmarks/managed_bookmark_service_factory.h"
 #include "chrome/test/base/testing_profile.h"
 #include "components/bookmarks/browser/bookmark_model.h"
 #include "components/bookmarks/browser/bookmark_node.h"
 #include "components/bookmarks/browser/bookmark_utils.h"
 #include "components/bookmarks/common/bookmark_pref_names.h"
@@ skipping 35 matching lines @@
 
   void ResetModel() {
     profile_.CreateBookmarkModel(false);
     model_ = BookmarkModelFactory::GetForBrowserContext(&profile_);
     bookmarks::test::WaitForBookmarkModelToLoad(model_);
     model_->AddObserver(&observer_);
     managed_ = ManagedBookmarkServiceFactory::GetForProfile(&profile_);
     DCHECK(managed_);
   }
 
-  static base::DictionaryValue* CreateBookmark(const std::string& title,
-                                               const std::string& url) {
+  static std::unique_ptr<base::DictionaryValue> CreateBookmark(
+      const std::string& title,
+      const std::string& url) {
     EXPECT_TRUE(GURL(url).is_valid());
-    base::DictionaryValue* dict = new base::DictionaryValue();
+    auto dict = base::MakeUnique<base::DictionaryValue>();
     dict->SetString("name", title);
     dict->SetString("url", GURL(url).spec());
     return dict;
   }
 
-  static base::DictionaryValue* CreateFolder(const std::string& title,
-                                             base::ListValue* children) {
-    base::DictionaryValue* dict = new base::DictionaryValue();
+  static std::unique_ptr<base::DictionaryValue> CreateFolder(
+      const std::string& title,
+      base::ListValue* children) {
+    auto dict = base::MakeUnique<base::DictionaryValue>();
     dict->SetString("name", title);
     dict->Set("children", children);
     return dict;
   }
 
   static base::ListValue* CreateTestTree() {
     base::ListValue* folder = new base::ListValue();
     base::ListValue* empty = new base::ListValue();
     folder->Append(CreateFolder("Empty", empty));
     folder->Append(CreateBookmark("Youtube", "http://youtube.com/"));
 
     base::ListValue* list = new base::ListValue();
     list->Append(CreateBookmark("Google", "http://google.com/"));
     list->Append(CreateFolder("Folder", folder));
 
     return list;
   }
 
-  static base::DictionaryValue* CreateExpectedTree() {
+  static std::unique_ptr<base::DictionaryValue> CreateExpectedTree() {
     return CreateFolder(GetManagedFolderTitle(), CreateTestTree());
   }
 
   static std::string GetManagedFolderTitle() {
     return l10n_util::GetStringUTF8(
         IDS_BOOKMARK_BAR_MANAGED_FOLDER_DEFAULT_NAME);
   }
 
   static bool NodeMatchesValue(const BookmarkNode* node,
                                const base::DictionaryValue* dict) {
@@ skipping 180 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()));
 }