Convert //chrome/browser/supervised_user from scoped_ptr to std::unique_ptr

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 <vector>
 
 #include "base/json/json_reader.h"
 #include "base/json/json_writer.h"
 #include "base/macros.h"
-#include "base/memory/scoped_ptr.h"
+#include "base/memory/ptr_util.h"
 #include "base/values.h"
-#include "chrome/browser/supervised_user/supervised_user_bookmarks_handler.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 using Folder = SupervisedUserBookmarksHandler::Folder;
 using Link = SupervisedUserBookmarksHandler::Link;
 
 namespace {
 
 typedef std::pair<std::string, std::string> Setting;
 
 // Settings representing the following tree:
@@ skipping 119 matching lines @@
     "            \"name\":\"\","
     "            \"url\":\"http://www.theoatmeal.com/\""
     "          }"
     "        ]"
     "      }"
     "    ]"
     "  }"
     "]";
 
 // Builds the base::Values tree from a json string above.
-scoped_ptr<base::ListValue> CreateTree(const char* json) {
-  scoped_ptr<base::Value> value = base::JSONReader::Read(json);
+std::unique_ptr<base::ListValue> CreateTree(const char* json) {
+  std::unique_ptr<base::Value> value = base::JSONReader::Read(json);
   EXPECT_NE(value.get(), nullptr);
   base::ListValue* list;
   EXPECT_TRUE(value->GetAsList(&list));
   ignore_result(value.release());
-  return make_scoped_ptr(list);
+  return base::WrapUnique(list);
 }
 
-scoped_ptr<base::ListValue> CreateBookmarksTree() {
+std::unique_ptr<base::ListValue> CreateBookmarksTree() {
   return CreateTree(BOOKMARKS_TREE_JSON);
 }
 
-scoped_ptr<base::ListValue> CreateBookmarksTreeWithInvalidParents() {
+std::unique_ptr<base::ListValue> CreateBookmarksTreeWithInvalidParents() {
   return CreateTree(BOOKMARKS_TREE_INVALID_PARENTS_JSON);
 }
 
 }  // namespace
 
 static bool operator==(const Folder& f1, const Folder& f2) {
   return f1.id == f2.id && f1.name == f2.name && f1.parent_id == f2.parent_id;
 }
 
 static bool operator==(const Link& l1, const Link& l2) {
@@ skipping 74 matching lines @@
 
   const std::vector<Link>& GetLinks() const {
     return deserializer_.links_for_testing();
   }
 
  private:
   SupervisedUserBookmarksHandler deserializer_;
 };
 
 TEST_F(SupervisedUserBookmarksHandlerTest, ParseSettings) {
-  scoped_ptr<base::DictionaryValue> link_dictionary(CreateLinkDictionary());
-  scoped_ptr<base::DictionaryValue> folder_dictionary(CreateFolderDictionary());
+  std::unique_ptr<base::DictionaryValue> link_dictionary(
+      CreateLinkDictionary());
+  std::unique_ptr<base::DictionaryValue> folder_dictionary(
+      CreateFolderDictionary());
 
   ParseLinks(*link_dictionary.get());
   ParseFolders(*folder_dictionary.get());
 
   const std::vector<Link>& links = GetLinks();
   EXPECT_EQ(arraysize(PARSED_LINKS), links.size());
   for (size_t i = 0; i < links.size(); ++i)
     EXPECT_EQ(PARSED_LINKS[i], links[i]);
 
   const std::vector<Folder>& folders = GetFolders();
   EXPECT_EQ(arraysize(PARSED_FOLDERS), folders.size());
   for (size_t i = 0; i < folders.size(); ++i)
     EXPECT_EQ(PARSED_FOLDERS[i], folders[i]);
 }
 
 TEST_F(SupervisedUserBookmarksHandlerTest, BuildBookmarksTree) {
   // Make some fake settings.
-  scoped_ptr<base::DictionaryValue> settings(
+  std::unique_ptr<base::DictionaryValue> settings(
       CreateSettings(CreateLinkDictionary(), CreateFolderDictionary()));
   // Parse the settings into a bookmarks tree.
-  scoped_ptr<base::ListValue> bookmarks(
+  std::unique_ptr<base::ListValue> bookmarks(
       SupervisedUserBookmarksHandler::BuildBookmarksTree(*settings.get()));
 
   // Check that the parsed tree matches the expected tree constructed directly
   // from the hardcoded json above.
-  scoped_ptr<base::ListValue> expected_bookmarks(CreateBookmarksTree());
+  std::unique_ptr<base::ListValue> expected_bookmarks(CreateBookmarksTree());
   EXPECT_TRUE(bookmarks->Equals(expected_bookmarks.get()));
 }
 
 TEST_F(SupervisedUserBookmarksHandlerTest,
        BuildBookmarksTreeWithInvalidParents) {
   // Make some fake settings, including some entries with invalid parent
   // references.
-  scoped_ptr<base::DictionaryValue> settings(
+  std::unique_ptr<base::DictionaryValue> settings(
       CreateSettings(CreateLinkDictionaryWithInvalidParents(),
                      CreateFolderDictionaryWithInvalidParents()));
   // Parse the settings into a bookmarks tree.
-  scoped_ptr<base::ListValue> bookmarks(
+  std::unique_ptr<base::ListValue> bookmarks(
       SupervisedUserBookmarksHandler::BuildBookmarksTree(*settings.get()));
 
   // Check that the parsed tree matches the expected tree constructed directly
   // from the hardcoded json above (which does not contain the entries with
   // invalid parents!).
-  scoped_ptr<base::ListValue> expected_bookmarks(
+  std::unique_ptr<base::ListValue> expected_bookmarks(
       CreateBookmarksTreeWithInvalidParents());
   EXPECT_TRUE(bookmarks->Equals(expected_bookmarks.get()));
 }
 
 TEST_F(SupervisedUserBookmarksHandlerTest, Circle) {
   // Make some fake settings which include a circular reference in the folders.
-  scoped_ptr<base::DictionaryValue> settings(
-      CreateSettings(CreateLinkDictionary(),
-                     CreateFolderDictionaryWithCircle()));
-  scoped_ptr<base::ListValue> bookmarks(
+  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.
 }