Remove SetWithoutPathExpansion

chrome/browser/supervised_user/supervised_user_bookmarks_handler_unittest.cc

 // Copyright 2015 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/supervised_user/supervised_user_bookmarks_handler.h"
 
 #include <stddef.h>
 
 #include <iostream>
 #include <map>
 #include <memory>
 #include <string>
+#include <utility>
 #include <vector>
 
 #include "base/json/json_reader.h"
 #include "base/json/json_writer.h"
 #include "base/macros.h"
 #include "base/memory/ptr_util.h"
 #include "base/values.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 using Folder = SupervisedUserBookmarksHandler::Folder;
@@ skipping 165 matching lines @@
   return str;
 }
 
 std::ostream& operator<<(std::ostream& str, const Link& link) {
   str << link.url << " " << link.name << " " << link.parent_id;
   return str;
 }
 
 class SupervisedUserBookmarksHandlerTest : public ::testing::Test {
  protected:
-  static base::DictionaryValue* CreateSettings(base::DictionaryValue* links,
-                                               base::DictionaryValue* folders) {
-    base::DictionaryValue* settings = new base::DictionaryValue;
+  static std::unique_ptr<base::DictionaryValue> CreateSettings(
+      std::unique_ptr<base::DictionaryValue> links,
+      std::unique_ptr<base::DictionaryValue> folders) {
+    auto settings = base::MakeUnique<base::DictionaryValue>();
     settings->SetStringWithoutPathExpansion("some_setting", "bleh");
-    settings->SetWithoutPathExpansion("SupervisedBookmarkLink", links);
+    settings->SetWithoutPathExpansion("SupervisedBookmarkLink",
+                                      std::move(links));
     settings->SetStringWithoutPathExpansion("some_other_setting", "foo");
-    settings->SetWithoutPathExpansion("SupervisedBookmarkFolder", folders);
+    settings->SetWithoutPathExpansion("SupervisedBookmarkFolder",
+                                      std::move(folders));
     settings->SetStringWithoutPathExpansion("another_one", "blurb");
     return settings;
   }
 
-  static base::DictionaryValue* CreateDictionary(const Setting* begin,
-                                                 const Setting* end) {
-    base::DictionaryValue* dict = new base::DictionaryValue;
+  static std::unique_ptr<base::DictionaryValue> CreateDictionary(
+      const Setting* begin,
+      const Setting* end) {
+    auto dict = base::MakeUnique<base::DictionaryValue>();
     for (const Setting* setting = begin; setting != end; ++setting)
       dict->SetStringWithoutPathExpansion(setting->first, setting->second);
     return dict;
   }
 
-  static base::DictionaryValue* CreateLinkDictionary() {
+  static std::unique_ptr<base::DictionaryValue> CreateLinkDictionary() {
     return CreateDictionary(LINK_SETTINGS,
                             LINK_SETTINGS + arraysize(LINK_SETTINGS));
   }
 
-  static base::DictionaryValue* CreateLinkDictionaryWithInvalidParents() {
+  static std::unique_ptr<base::DictionaryValue>
+  CreateLinkDictionaryWithInvalidParents() {
     return CreateDictionary(
         LINK_SETTINGS_INVALID_PARENT,
         LINK_SETTINGS_INVALID_PARENT + arraysize(LINK_SETTINGS_INVALID_PARENT));
   }
 
-  static base::DictionaryValue* CreateFolderDictionary() {
+  static std::unique_ptr<base::DictionaryValue> CreateFolderDictionary() {
     return CreateDictionary(FOLDER_SETTINGS,
                             FOLDER_SETTINGS + arraysize(FOLDER_SETTINGS));
   }
 
-  static base::DictionaryValue* CreateFolderDictionaryWithInvalidParents() {
-    return CreateDictionary(
-        FOLDER_SETTINGS_INVALID_PARENT,
-        FOLDER_SETTINGS_INVALID_PARENT +
-            arraysize(FOLDER_SETTINGS_INVALID_PARENT));
+  static std::unique_ptr<base::DictionaryValue>
+  CreateFolderDictionaryWithInvalidParents() {
+    return CreateDictionary(FOLDER_SETTINGS_INVALID_PARENT,
+                            FOLDER_SETTINGS_INVALID_PARENT +
+                                arraysize(FOLDER_SETTINGS_INVALID_PARENT));
   }
 
-  static base::DictionaryValue* CreateFolderDictionaryWithCircle() {
+  static std::unique_ptr<base::DictionaryValue>
+  CreateFolderDictionaryWithCircle() {
     return CreateDictionary(
         FOLDER_SETTINGS_CIRCLE,
         FOLDER_SETTINGS_CIRCLE + arraysize(FOLDER_SETTINGS_CIRCLE));
   }
 
   void ParseFolders(const base::DictionaryValue& folders) {
     deserializer_.ParseFolders(folders);
   }
 
   void ParseLinks(const base::DictionaryValue& links) {
@@ skipping 67 matching lines @@
 
 TEST_F(SupervisedUserBookmarksHandlerTest, Circle) {
   // Make some fake settings which include a circular reference in the folders.
   std::unique_ptr<base::DictionaryValue> settings(CreateSettings(
       CreateLinkDictionary(), CreateFolderDictionaryWithCircle()));
   std::unique_ptr<base::ListValue> bookmarks(
       SupervisedUserBookmarksHandler::BuildBookmarksTree(*settings.get()));
   // Don't care what exactly the result looks like, just that we don't run into
   // an endless loop.
 }